You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
655 lines
16 KiB
655 lines
16 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
reg.c
|
|
|
|
Abstract:
|
|
|
|
These functions access the registry
|
|
|
|
Author:
|
|
|
|
Stephane Plante (splante)
|
|
|
|
Environment:
|
|
|
|
Kernel mode only.
|
|
|
|
Revision History:
|
|
|
|
03-Jun-97 Initial Revision
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
#include "amlreg.h"
|
|
#include <stdio.h>
|
|
|
|
//
|
|
// This controls wether or not the various tables will be dumped to the
|
|
// registry
|
|
//
|
|
UCHAR DoAcpiTableDump = 0xFF;
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#define alloc_text(PAGE,ACPIRegLocalCopyString)
|
|
#define alloc_text(PAGE,ACPIRegDumpAcpiTable)
|
|
#define alloc_text(PAGE,ACPIRegDumpAcpiTables)
|
|
#define alloc_text(PAGE,ACPIRegReadEntireAcpiTable)
|
|
#define alloc_text(PAGE,ACPIRegReadAMLRegistryEntry)
|
|
#endif
|
|
|
|
|
|
PUCHAR
|
|
ACPIRegLocalCopyString (
|
|
PUCHAR Destination,
|
|
PUCHAR Source,
|
|
ULONG MaxLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
A little routine to copy short strings, since using sprintf here is
|
|
like hitting a tack with a sledgehammer. Terminates when a null or
|
|
the max length is reached, whichever comes first. Translates blanks
|
|
to underscores, since everyone hates blanks embedded in registry keys.
|
|
|
|
Arguments:
|
|
|
|
Destination - Where to copy the string to
|
|
Source - Source string pointer
|
|
MaxLength - Max number of bytes to copy
|
|
|
|
Return Value:
|
|
|
|
Returns the destination pointer incremented past the copied string
|
|
|
|
__*/
|
|
{
|
|
ULONG i;
|
|
|
|
|
|
for (i = 0; i < MaxLength; i++) {
|
|
|
|
if (Source[i] == 0) {
|
|
break;
|
|
|
|
} else if (Source[i] == ' ') { // Translate blanks to underscores
|
|
Destination [i] = '_';
|
|
|
|
} else {
|
|
Destination [i] = Source[i];
|
|
}
|
|
}
|
|
|
|
Destination [i] = 0;
|
|
return (Destination + i);
|
|
}
|
|
|
|
BOOLEAN
|
|
ACPIRegReadAMLRegistryEntry(
|
|
IN PVOID *Table,
|
|
IN BOOLEAN MemoryMapped
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This reads a table from the registry
|
|
|
|
Arguments:
|
|
|
|
Table - Where to store the pointer to the table. If non-null, this
|
|
contains a pointer to where the Original Table is stored
|
|
MemorMapped - Indicates wether or not the table is memory mapped and should
|
|
be unmapped once we are done with it
|
|
|
|
Return Value:
|
|
|
|
TRUE - Success
|
|
FALSE - Failure
|
|
|
|
__*/
|
|
{
|
|
BOOLEAN rc = FALSE;
|
|
HANDLE revisionKey = NULL;
|
|
HANDLE tableIdKey = NULL;
|
|
NTSTATUS status;
|
|
PDESCRIPTION_HEADER header = (PDESCRIPTION_HEADER) *Table;
|
|
PUCHAR key = NULL; // ACPI_PARAMETERS_REGISTRY_KEY;
|
|
PUCHAR buffer;
|
|
ULONG action;
|
|
ULONG bytesRead;
|
|
ULONG baseSize;
|
|
ULONG totalSize;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Build a full path name to the thing we want in the registry
|
|
//
|
|
baseSize = strlen( ACPI_PARAMETERS_REGISTRY_KEY);
|
|
totalSize = baseSize + ACPI_MAX_TABLE_STRINGS + 4;
|
|
|
|
buffer = key = ExAllocatePool( PagedPool, totalSize );
|
|
if (key == NULL) {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Generate the path name to the key. This avoids a costly sprintf
|
|
//
|
|
RtlZeroMemory( buffer, totalSize );
|
|
RtlCopyMemory(
|
|
buffer,
|
|
ACPI_PARAMETERS_REGISTRY_KEY,
|
|
baseSize
|
|
);
|
|
buffer += baseSize;
|
|
*buffer++ = '\\';
|
|
|
|
//
|
|
// Table Signature (Up to 4 byte string)
|
|
//
|
|
buffer = ACPIRegLocalCopyString (buffer, (PUCHAR) &header->Signature, ACPI_MAX_SIGNATURE);
|
|
*buffer++ = '\\';
|
|
|
|
//
|
|
// OEM ID field (Up to 6 byte string)
|
|
//
|
|
buffer = ACPIRegLocalCopyString (buffer, (PUCHAR) &header->OEMID, ACPI_MAX_OEM_ID);
|
|
*buffer++ = '\\';
|
|
|
|
//
|
|
// OEM Table ID field (Up to 8 byte string)
|
|
//
|
|
buffer = ACPIRegLocalCopyString (buffer, (PUCHAR) &header->OEMTableID, ACPI_MAX_TABLE_ID);
|
|
*buffer = 0; // Terminate
|
|
|
|
ACPIPrint ((
|
|
ACPI_PRINT_REGISTRY,
|
|
"ReadAMLRegistryEntry: opening key: %s\n",
|
|
key));
|
|
|
|
//
|
|
// Open the <TableId>/OemId>/<OemTableId> key
|
|
//
|
|
status = OSOpenHandle(key, NULL, &tableIdKey);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
ACPIPrint ((
|
|
ACPI_PRINT_WARNING,
|
|
"ReadAMLRegistryEntry: failed to open AML registry entry (rc=%x)\n",
|
|
status));
|
|
goto ReadAMLRegistryEntryExit;
|
|
|
|
}
|
|
|
|
//
|
|
// Find the largest subkey that is equal or greater than the ROM
|
|
// BIOS version of the table
|
|
//
|
|
status = OSOpenLargestSubkey(
|
|
tableIdKey,
|
|
&revisionKey,
|
|
header->OEMRevision
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
|
|
ACPIPrint ((
|
|
ACPI_PRINT_WARNING,
|
|
"ReadAMLRegistryEntry: no valid <OemRevision> key (rc=%#08lx)\n",
|
|
status));
|
|
goto ReadAMLRegistryEntryExit;
|
|
|
|
}
|
|
|
|
//
|
|
// Get the Action value for this table, which tells us what to do with
|
|
// the table
|
|
//
|
|
bytesRead = sizeof(action);
|
|
status = OSReadRegValue(
|
|
"Action",
|
|
revisionKey,
|
|
&action,
|
|
&bytesRead
|
|
);
|
|
if (!NT_SUCCESS(status) || bytesRead != sizeof(action)) {
|
|
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"ReadAMLRegistryEntry: read action value = %#08lx. BytesRead=%d\n",
|
|
status, bytesRead
|
|
) );
|
|
action = ACTION_LOAD_TABLE; // Default action
|
|
|
|
}
|
|
|
|
//
|
|
// Do the action
|
|
//
|
|
switch (action) {
|
|
case ACTION_LOAD_TABLE:
|
|
//
|
|
// Overload entire ROM table
|
|
//
|
|
status = ACPIRegReadEntireAcpiTable(revisionKey, Table, MemoryMapped);
|
|
if (NT_SUCCESS( status ) ) {
|
|
|
|
rc = TRUE;
|
|
|
|
}
|
|
break;
|
|
|
|
case ACTION_LOAD_ROM:
|
|
case ACTION_LOAD_NOTHING:
|
|
//
|
|
// Nothing to do for these cases (return FALSE however);
|
|
//
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Unsupported actions (return FALSE)
|
|
//
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"ReadAMLRegistryEntry: Unsupported action value (action=%d)\n",
|
|
action
|
|
) );
|
|
break;
|
|
|
|
}
|
|
|
|
//
|
|
// Always close the open keys
|
|
//
|
|
ReadAMLRegistryEntryExit:
|
|
if (key != NULL) {
|
|
|
|
ExFreePool( key );
|
|
|
|
}
|
|
if (tableIdKey != NULL) {
|
|
|
|
OSCloseHandle( tableIdKey );
|
|
|
|
}
|
|
if (revisionKey != NULL) {
|
|
|
|
OSCloseHandle( revisionKey );
|
|
|
|
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
NTSTATUS
|
|
ACPIRegReadEntireAcpiTable (
|
|
IN HANDLE RevisionKey,
|
|
IN PVOID *Table,
|
|
IN BOOLEAN MemoryMapped
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads the table from the registry into memory
|
|
|
|
Arguments:
|
|
|
|
RevisionKey - Handle to the key containing the table
|
|
Table - Pointer to the pointer to the table
|
|
MemorymMapped - If True, indicates that we need to MmUnmapIo the table
|
|
otherwise, if False, we do no free the table (the
|
|
memory is static)
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PUCHAR buffer;
|
|
PVOID table;
|
|
UCHAR value[9];
|
|
ULONG bytesRead;
|
|
ULONG index = 0;
|
|
ULONG entry;
|
|
PREGISTRY_HEADER entryHeader;
|
|
PDESCRIPTION_HEADER descHeader = (PDESCRIPTION_HEADER) *Table;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// We need an 8k buffer
|
|
//
|
|
buffer = ExAllocatePool( PagedPool, 8 * 1024 );
|
|
if (buffer == NULL) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
}
|
|
|
|
//
|
|
// Repeat this forever
|
|
//
|
|
for (index = 0; ;index++) {
|
|
|
|
//
|
|
// This is the first data value
|
|
//
|
|
sprintf(value, "%08lx", index );
|
|
|
|
//
|
|
// Read the entry header to get the size of the table. This is stored
|
|
// before the actual table
|
|
//
|
|
bytesRead = 8 * 1024;
|
|
status = OSReadRegValue(
|
|
value,
|
|
RevisionKey,
|
|
buffer,
|
|
&bytesRead
|
|
);
|
|
if (!NT_SUCCESS(status) ) {
|
|
|
|
//
|
|
// Not being able to read the table isn't a failure case
|
|
//
|
|
status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
} else if (bytesRead < sizeof(REGISTRY_HEADER) ) {
|
|
|
|
//
|
|
// Not being to read the proper number of bytes is
|
|
//
|
|
ACPIPrint( (
|
|
ACPI_PRINT_CRITICAL,
|
|
"ReadEntireAcpiTable: read registry header (bytes=%d)\n",
|
|
bytesRead
|
|
) );
|
|
return STATUS_UNSUCCESSFUL;
|
|
|
|
}
|
|
|
|
//
|
|
// Loop while we still have bytes to process
|
|
//
|
|
for (entry = 0;
|
|
entry < bytesRead;
|
|
entry += (entryHeader->Length + sizeof(REGISTRY_HEADER) )
|
|
) {
|
|
|
|
//
|
|
// Grab a pointer to the entry record
|
|
//
|
|
entryHeader = (PREGISTRY_HEADER) &(buffer[entry]);
|
|
|
|
//
|
|
// Crack the record
|
|
//
|
|
if (entryHeader->Length == 0) {
|
|
|
|
//
|
|
// Special Case
|
|
//
|
|
if (entryHeader->Offset != descHeader->Length) {
|
|
|
|
//
|
|
// Must change the table size
|
|
//
|
|
table = ExAllocatePoolWithTag(
|
|
NonPagedPool,
|
|
entryHeader->Offset,
|
|
ACPI_SHARED_TABLE_POOLTAG
|
|
);
|
|
if (table == NULL) {
|
|
|
|
ExFreePool( buffer );
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
}
|
|
|
|
//
|
|
// How much do we have to copy?
|
|
//
|
|
RtlCopyMemory(
|
|
table,
|
|
*Table,
|
|
min( entryHeader->Offset, descHeader->Length )
|
|
);
|
|
|
|
//
|
|
// Free the old table based on wether or not its mm mapped
|
|
//
|
|
if (MemoryMapped) {
|
|
|
|
MmUnmapIoSpace(*Table, descHeader->Length);
|
|
|
|
} else {
|
|
|
|
ExFreePool( *Table );
|
|
|
|
}
|
|
|
|
//
|
|
// Remember the address of the new table
|
|
//
|
|
descHeader = (PDESCRIPTION_HEADER) *Table = table;
|
|
|
|
}
|
|
|
|
//
|
|
// Done with this record
|
|
//
|
|
continue;
|
|
|
|
}
|
|
|
|
//
|
|
// Patch the memory
|
|
//
|
|
ASSERT( entryHeader->Offset < descHeader->Length );
|
|
RtlCopyMemory(
|
|
( (PUCHAR) *Table) + entryHeader->Offset,
|
|
(PUCHAR) entryHeader + sizeof( REGISTRY_HEADER ),
|
|
entryHeader->Length
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Normal exit
|
|
//
|
|
if (buffer != NULL) {
|
|
|
|
ExFreePool( buffer );
|
|
}
|
|
return status;
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DumpAcpiTable
|
|
* Write an ACPI Table to the registry
|
|
*
|
|
* Not exported.
|
|
*
|
|
* ENTRY: pszName - Name of the table to write (4 byte string)
|
|
* Table - Pointer to table data
|
|
* Length - of the table
|
|
* Header - Pointer to the table header
|
|
*
|
|
* EXIT: NONE
|
|
*
|
|
***************************************************************************/
|
|
VOID
|
|
ACPIRegDumpAcpiTable (
|
|
PSZ pszName,
|
|
PVOID Table,
|
|
ULONG Length,
|
|
PDESCRIPTION_HEADER Header
|
|
)
|
|
{
|
|
//NTSTATUS status;
|
|
UCHAR buffer [80] = "\\Registry\\Machine\\Hardware\\ACPI";
|
|
HANDLE hSubKey;
|
|
HANDLE hPrefixKey;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Create /Registry/Machine/Hardware/ACPI subkey
|
|
//
|
|
if ( !NT_SUCCESS(OSCreateHandle (buffer, NULL, &hPrefixKey) ) ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Create table name subkey (DSDT, FACP, FACS, or RSDT) - 4 bytes
|
|
//
|
|
if ( !NT_SUCCESS(OSCreateHandle (pszName, hPrefixKey, &hSubKey) ) ) {
|
|
goto DumpAcpiTableExit;
|
|
}
|
|
|
|
//
|
|
// For tables with headers, add subkeys for
|
|
// <OemId>/<OemTableID>/<OemRevision>
|
|
//
|
|
if (Header) {
|
|
|
|
OSCloseHandle(hPrefixKey);
|
|
hPrefixKey = hSubKey;
|
|
|
|
//
|
|
// OEM ID field (6 byte string)
|
|
//
|
|
ACPIRegLocalCopyString (buffer, Header->OEMID, ACPI_MAX_OEM_ID);
|
|
if ( !NT_SUCCESS(OSCreateHandle (buffer, hPrefixKey, &hSubKey) ) ) {
|
|
goto DumpAcpiTableExit;
|
|
}
|
|
|
|
OSCloseHandle (hPrefixKey);
|
|
hPrefixKey = hSubKey;
|
|
|
|
//
|
|
// OEM Table ID field (8 byte string)
|
|
//
|
|
ACPIRegLocalCopyString (buffer, Header->OEMTableID, ACPI_MAX_TABLE_ID);
|
|
if ( !NT_SUCCESS(OSCreateHandle (buffer, hPrefixKey, &hSubKey) ) ) {
|
|
goto DumpAcpiTableExit;
|
|
}
|
|
|
|
OSCloseHandle (hPrefixKey);
|
|
hPrefixKey = hSubKey;
|
|
|
|
//
|
|
// OEM Revision field (4 byte number)
|
|
//
|
|
sprintf (buffer, "%.8x", Header->OEMRevision);
|
|
if ( !NT_SUCCESS(OSCreateHandle (buffer, hPrefixKey, &hSubKey) ) ) {
|
|
goto DumpAcpiTableExit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Finally, write the entire table
|
|
//
|
|
OSWriteRegValue ("00000000", hSubKey, Table, Length);
|
|
|
|
//
|
|
// Delete open handles
|
|
//
|
|
OSCloseHandle (hSubKey);
|
|
DumpAcpiTableExit:
|
|
OSCloseHandle (hPrefixKey);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DumpAcpiTables
|
|
* Write the ACPI Tables to the registry. Should be called only
|
|
* after table pointers have been initialized.
|
|
*
|
|
* Not exported.
|
|
*
|
|
* ENTRY: NONE
|
|
* EXIT: NONE.
|
|
*
|
|
***************************************************************************/
|
|
VOID
|
|
ACPIRegDumpAcpiTables (VOID)
|
|
{
|
|
PDSDT dsdt = AcpiInformation->DiffSystemDescTable;
|
|
PFACS facs = AcpiInformation->FirmwareACPIControlStructure;
|
|
PFADT fadt = AcpiInformation->FixedACPIDescTable;
|
|
PRSDT rsdt = AcpiInformation->RootSystemDescTable;
|
|
|
|
|
|
if (DoAcpiTableDump) {
|
|
|
|
ACPIPrint ((
|
|
ACPI_PRINT_REGISTRY,
|
|
"DumpAcpiTables: Writing DSDT/FACS/FADT/RSDT to registry\n"));
|
|
|
|
if (dsdt) {
|
|
|
|
ACPIRegDumpAcpiTable(
|
|
"DSDT",
|
|
dsdt,
|
|
dsdt->Header.Length,
|
|
&(dsdt->Header)
|
|
);
|
|
|
|
}
|
|
|
|
if (facs) {
|
|
|
|
ACPIRegDumpAcpiTable(
|
|
"FACS",
|
|
facs,
|
|
facs->Length,
|
|
NULL
|
|
);
|
|
|
|
}
|
|
|
|
if (fadt) {
|
|
|
|
ACPIRegDumpAcpiTable(
|
|
"FADT",
|
|
fadt,
|
|
fadt->Header.Length,
|
|
&(fadt->Header)
|
|
);
|
|
|
|
}
|
|
|
|
if (rsdt) {
|
|
|
|
ACPIRegDumpAcpiTable(
|
|
"RSDT",
|
|
rsdt,
|
|
rsdt->Header.Length,
|
|
&(rsdt->Header)
|
|
);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|