ACPI_STATUS
AcpiDbGetTableFromFile (
char *Filename,
ACPI_TABLE_HEADER **ReturnTable)
{
#ifdef ACPI_APPLICATION
ACPI_STATUS Status;
ACPI_TABLE_HEADER *Table;
BOOLEAN IsAmlTable = TRUE;
Status = AcpiDbReadTableFromFile (Filename, &Table);
if (ACPI_FAILURE (Status))
{
return (Status);
}
#ifdef ACPI_DATA_TABLE_DISASSEMBLY
IsAmlTable = AcpiUtIsAmlTable (Table);
#endif
if (IsAmlTable)
{
/* Attempt to recognize and install the table */
Status = AeLocalLoadTable (Table);
if (ACPI_FAILURE (Status))
{
if (Status == AE_ALREADY_EXISTS)
{
AcpiOsPrintf ("Table %4.4s is already installed\n",
Table->Signature);
}
else
{
AcpiOsPrintf ("Could not install table, %s\n",
AcpiFormatException (Status));
}
return (Status);
}
AcpiTbPrintTableHeader (0, Table);
fprintf (stderr,
"Acpi table [%4.4s] successfully installed and loaded\n",
Table->Signature);
}
AcpiGbl_AcpiHardwarePresent = FALSE;
if (ReturnTable)
{
*ReturnTable = Table;
}
#endif /* ACPI_APPLICATION */
return (AE_OK);
}
void
AcpiTbCheckDsdtHeader (
void)
{
/* Compare original length and checksum to current values */
if (AcpiGbl_OriginalDsdtHeader.Length != AcpiGbl_DSDT->Length ||
AcpiGbl_OriginalDsdtHeader.Checksum != AcpiGbl_DSDT->Checksum)
{
ACPI_BIOS_ERROR ((AE_INFO,
"The DSDT has been corrupted or replaced - "
"old, new headers below"));
AcpiTbPrintTableHeader (0, &AcpiGbl_OriginalDsdtHeader);
AcpiTbPrintTableHeader (0, AcpiGbl_DSDT);
/* Disable further error messages */
AcpiGbl_OriginalDsdtHeader.Length = AcpiGbl_DSDT->Length;
AcpiGbl_OriginalDsdtHeader.Checksum = AcpiGbl_DSDT->Checksum;
}
}
void
AcpiTbInstallTableWithOverride (
ACPI_TABLE_DESC *NewTableDesc,
BOOLEAN Override,
UINT32 *TableIndex)
{
UINT32 i;
ACPI_STATUS Status;
Status = AcpiTbGetNextTableDescriptor (&i, NULL);
if (ACPI_FAILURE (Status))
{
return;
}
/*
* ACPI Table Override:
*
* Before we install the table, let the host OS override it with a new
* one if desired. Any table within the RSDT/XSDT can be replaced,
* including the DSDT which is pointed to by the FADT.
*/
if (Override)
{
AcpiTbOverrideTable (NewTableDesc);
}
AcpiTbInitTableDescriptor (&AcpiGbl_RootTableList.Tables[i],
NewTableDesc->Address, NewTableDesc->Flags, NewTableDesc->Pointer);
AcpiTbPrintTableHeader (NewTableDesc->Address, NewTableDesc->Pointer);
/* This synchronizes AcpiGbl_DsdtIndex */
*TableIndex = i;
/* Set the global integer width (based upon revision of the DSDT) */
if (i == AcpiGbl_DsdtIndex)
{
AcpiUtSetIntegerWidth (NewTableDesc->Pointer->Revision);
}
}
static int
ApDumpTableBuffer (
ACPI_TABLE_HEADER *Table,
UINT32 Instance,
ACPI_PHYSICAL_ADDRESS Address)
{
UINT32 TableLength;
TableLength = ApGetTableLength (Table);
/* Print only the header if requested */
if (Gbl_SummaryMode)
{
AcpiTbPrintTableHeader (Address, Table);
return (0);
}
/* Dump to binary file if requested */
if (Gbl_BinaryMode)
{
return (ApWriteToBinaryFile (Table, Instance));
}
/*
* Dump the table with header for use with acpixtract utility.
* Note: simplest to just always emit a 64-bit address. AcpiXtract
* utility can handle this.
*/
AcpiUtFilePrintf (Gbl_OutputFile, "%4.4s @ 0x%8.8X%8.8X\n",
Table->Signature, ACPI_FORMAT_UINT64 (Address));
AcpiUtDumpBufferToFile (Gbl_OutputFile,
ACPI_CAST_PTR (UINT8, Table), TableLength,
DB_BYTE_DISPLAY, 0);
AcpiUtFilePrintf (Gbl_OutputFile, "\n");
return (0);
}
void
AcpiDbDisplayTableInfo (
char *TableArg)
{
UINT32 i;
ACPI_TABLE_DESC *TableDesc;
ACPI_STATUS Status;
/* Walk the entire root table list */
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
{
TableDesc = &AcpiGbl_RootTableList.Tables[i];
AcpiOsPrintf ("%u ", i);
/* Make sure that the table is mapped */
Status = AcpiTbVerifyTable (TableDesc);
if (ACPI_FAILURE (Status))
{
return;
}
/* Dump the table header */
if (TableDesc->Pointer)
{
AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
}
else
{
/* If the pointer is null, the table has been unloaded */
ACPI_INFO ((AE_INFO, "%4.4s - Table has been unloaded",
TableDesc->Signature.Ascii));
}
}
}
void
AcpiTbInstallTableWithOverride (
UINT32 TableIndex,
ACPI_TABLE_DESC *NewTableDesc,
BOOLEAN Override)
{
if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
{
return;
}
/*
* ACPI Table Override:
*
* Before we install the table, let the host OS override it with a new
* one if desired. Any table within the RSDT/XSDT can be replaced,
* including the DSDT which is pointed to by the FADT.
*/
if (Override)
{
AcpiTbOverrideTable (NewTableDesc);
}
AcpiTbInitTableDescriptor (&AcpiGbl_RootTableList.Tables[TableIndex],
NewTableDesc->Address, NewTableDesc->Flags, NewTableDesc->Pointer);
AcpiTbPrintTableHeader (NewTableDesc->Address, NewTableDesc->Pointer);
/* Set the global integer width (based upon revision of the DSDT) */
if (TableIndex == ACPI_TABLE_INDEX_DSDT)
{
AcpiUtSetIntegerWidth (NewTableDesc->Pointer->Revision);
}
}
ACPI_STATUS
AcpiTbParseRootTable (
ACPI_PHYSICAL_ADDRESS RsdpAddress)
{
ACPI_TABLE_RSDP *Rsdp;
UINT32 TableEntrySize;
UINT32 i;
UINT32 TableCount;
ACPI_TABLE_HEADER *Table;
ACPI_PHYSICAL_ADDRESS Address;
UINT32 Length;
UINT8 *TableEntry;
ACPI_STATUS Status;
UINT32 TableIndex;
ACPI_FUNCTION_TRACE (TbParseRootTable);
/* Map the entire RSDP and extract the address of the RSDT or XSDT */
Rsdp = AcpiOsMapMemory (RsdpAddress, sizeof (ACPI_TABLE_RSDP));
if (!Rsdp)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
AcpiTbPrintTableHeader (RsdpAddress,
ACPI_CAST_PTR (ACPI_TABLE_HEADER, Rsdp));
/* Use XSDT if present and not overridden. Otherwise, use RSDT */
if ((Rsdp->Revision > 1) &&
Rsdp->XsdtPhysicalAddress &&
!AcpiGbl_DoNotUseXsdt)
{
/*
* RSDP contains an XSDT (64-bit physical addresses). We must use
* the XSDT if the revision is > 1 and the XSDT pointer is present,
* as per the ACPI specification.
*/
Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->XsdtPhysicalAddress;
TableEntrySize = ACPI_XSDT_ENTRY_SIZE;
}
else
{
/* Root table is an RSDT (32-bit physical addresses) */
Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->RsdtPhysicalAddress;
TableEntrySize = ACPI_RSDT_ENTRY_SIZE;
}
/*
* It is not possible to map more than one entry in some environments,
* so unmap the RSDP here before mapping other tables
*/
AcpiOsUnmapMemory (Rsdp, sizeof (ACPI_TABLE_RSDP));
/* Map the RSDT/XSDT table header to get the full table length */
Table = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));
if (!Table)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
AcpiTbPrintTableHeader (Address, Table);
/*
* Validate length of the table, and map entire table.
* Minimum length table must contain at least one entry.
*/
Length = Table->Length;
AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER));
if (Length < (sizeof (ACPI_TABLE_HEADER) + TableEntrySize))
{
ACPI_BIOS_ERROR ((AE_INFO,
"Invalid table length 0x%X in RSDT/XSDT", Length));
return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
}
Table = AcpiOsMapMemory (Address, Length);
if (!Table)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Validate the root table checksum */
Status = AcpiTbVerifyChecksum (Table, Length);
if (ACPI_FAILURE (Status))
{
AcpiOsUnmapMemory (Table, Length);
return_ACPI_STATUS (Status);
}
/* Get the number of entries and pointer to first entry */
TableCount = (UINT32) ((Table->Length - sizeof (ACPI_TABLE_HEADER)) /
TableEntrySize);
TableEntry = ACPI_ADD_PTR (UINT8, Table, sizeof (ACPI_TABLE_HEADER));
/* Initialize the root table array from the RSDT/XSDT */
for (i = 0; i < TableCount; i++)
{
/* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */
Address = AcpiTbGetRootTableEntry (TableEntry, TableEntrySize);
/* Skip NULL entries in RSDT/XSDT */
if (!Address)
{
goto NextTable;
}
Status = AcpiTbInstallStandardTable (Address,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, FALSE, TRUE, &TableIndex);
if (ACPI_SUCCESS (Status) &&
ACPI_COMPARE_NAME (
&AcpiGbl_RootTableList.Tables[TableIndex].Signature,
ACPI_SIG_FADT))
{
AcpiGbl_FadtIndex = TableIndex;
AcpiTbParseFadt ();
}
NextTable:
TableEntry += TableEntrySize;
}
AcpiOsUnmapMemory (Table, Length);
return_ACPI_STATUS (AE_OK);
}
ACPI_STATUS
AcpiDbGetTableFromFile (
char *Filename,
ACPI_TABLE_HEADER **ReturnTable,
BOOLEAN MustBeAmlFile)
{
#ifdef ACPI_APPLICATION
ACPI_STATUS Status;
ACPI_TABLE_HEADER *Table;
BOOLEAN IsAmlTable = TRUE;
Status = AcpiUtReadTableFromFile (Filename, &Table);
if (ACPI_FAILURE (Status))
{
return (Status);
}
if (MustBeAmlFile)
{
IsAmlTable = AcpiUtIsAmlTable (Table);
if (!IsAmlTable)
{
ACPI_EXCEPTION ((AE_INFO, AE_OK,
"Input for -e is not an AML table: "
"\"%4.4s\" (must be DSDT/SSDT)",
Table->Signature));
return (AE_TYPE);
}
}
if (IsAmlTable)
{
/* Attempt to recognize and install the table */
Status = AeLocalLoadTable (Table);
if (ACPI_FAILURE (Status))
{
if (Status == AE_ALREADY_EXISTS)
{
AcpiOsPrintf ("Table %4.4s is already installed\n",
Table->Signature);
}
else
{
AcpiOsPrintf ("Could not install table, %s\n",
AcpiFormatException (Status));
}
return (Status);
}
AcpiTbPrintTableHeader (0, Table);
fprintf (stderr,
"Acpi table [%4.4s] successfully installed and loaded\n",
Table->Signature);
}
AcpiGbl_AcpiHardwarePresent = FALSE;
if (ReturnTable)
{
*ReturnTable = Table;
}
#endif /* ACPI_APPLICATION */
return (AE_OK);
}
ACPI_STATUS
AcpiTbAddTable (
ACPI_TABLE_DESC *TableDesc,
UINT32 *TableIndex)
{
UINT32 i;
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (TbAddTable);
if (!TableDesc->Pointer)
{
Status = AcpiTbVerifyTable (TableDesc);
if (ACPI_FAILURE (Status) || !TableDesc->Pointer)
{
return_ACPI_STATUS (Status);
}
}
/*
* Validate the incoming table signature.
*
* 1) Originally, we checked the table signature for "SSDT" or "PSDT".
* 2) We added support for OEMx tables, signature "OEM".
* 3) Valid tables were encountered with a null signature, so we just
* gave up on validating the signature, (05/2008).
* 4) We encountered non-AML tables such as the MADT, which caused
* interpreter errors and kernel faults. So now, we once again allow
* only "SSDT", "OEMx", and now, also a null signature. (05/2011).
*/
if ((TableDesc->Pointer->Signature[0] != 0x00) &&
(!ACPI_COMPARE_NAME (TableDesc->Pointer->Signature, ACPI_SIG_SSDT)) &&
(ACPI_STRNCMP (TableDesc->Pointer->Signature, "OEM", 3)))
{
ACPI_BIOS_ERROR ((AE_INFO,
"Table has invalid signature [%4.4s] (0x%8.8X), "
"must be SSDT or OEMx",
AcpiUtValidAcpiName (TableDesc->Pointer->Signature) ?
TableDesc->Pointer->Signature : "????",
*(UINT32 *) TableDesc->Pointer->Signature));
return_ACPI_STATUS (AE_BAD_SIGNATURE);
}
(void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
/* Check if table is already registered */
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
{
if (!AcpiGbl_RootTableList.Tables[i].Pointer)
{
Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]);
if (ACPI_FAILURE (Status) ||
!AcpiGbl_RootTableList.Tables[i].Pointer)
{
continue;
}
}
/*
* Check for a table match on the entire table length,
* not just the header.
*/
if (TableDesc->Length != AcpiGbl_RootTableList.Tables[i].Length)
{
continue;
}
if (ACPI_MEMCMP (TableDesc->Pointer,
AcpiGbl_RootTableList.Tables[i].Pointer,
AcpiGbl_RootTableList.Tables[i].Length))
{
continue;
}
/*
* Note: the current mechanism does not unregister a table if it is
* dynamically unloaded. The related namespace entries are deleted,
* but the table remains in the root table list.
*
* The assumption here is that the number of different tables that
* will be loaded is actually small, and there is minimal overhead
* in just keeping the table in case it is needed again.
*
* If this assumption changes in the future (perhaps on large
* machines with many table load/unload operations), tables will
* need to be unregistered when they are unloaded, and slots in the
* root table list should be reused when empty.
*/
/*
* Table is already registered.
* We can delete the table that was passed as a parameter.
*/
AcpiTbDeleteTable (TableDesc);
*TableIndex = i;
if (AcpiGbl_RootTableList.Tables[i].Flags & ACPI_TABLE_IS_LOADED)
{
/* Table is still loaded, this is an error */
Status = AE_ALREADY_EXISTS;
goto Release;
}
else
{
/* Table was unloaded, allow it to be reloaded */
TableDesc->Pointer = AcpiGbl_RootTableList.Tables[i].Pointer;
TableDesc->Address = AcpiGbl_RootTableList.Tables[i].Address;
Status = AE_OK;
goto PrintHeader;
}
}
/*
* ACPI Table Override:
* Allow the host to override dynamically loaded tables.
* NOTE: the table is fully mapped at this point, and the mapping will
* be deleted by TbTableOverride if the table is actually overridden.
*/
(void) AcpiTbTableOverride (TableDesc->Pointer, TableDesc);
/* Add the table to the global root table list */
Status = AcpiTbStoreTable (TableDesc->Address, TableDesc->Pointer,
TableDesc->Length, TableDesc->Flags, TableIndex);
if (ACPI_FAILURE (Status))
{
goto Release;
}
PrintHeader:
AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
Release:
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiExLoadOp (
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_OPERAND_OBJECT *Target,
ACPI_WALK_STATE *WalkState)
{
ACPI_OPERAND_OBJECT *DdbHandle;
ACPI_TABLE_HEADER *Table;
ACPI_TABLE_DESC TableDesc;
UINT32 TableIndex;
ACPI_STATUS Status;
UINT32 Length;
ACPI_FUNCTION_TRACE (ExLoadOp);
ACPI_MEMSET (&TableDesc, 0, sizeof (ACPI_TABLE_DESC));
/* Source Object can be either an OpRegion or a Buffer/Field */
switch (ObjDesc->Common.Type)
{
case ACPI_TYPE_REGION:
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Load table from Region %p\n", ObjDesc));
/* Region must be SystemMemory (from ACPI spec) */
if (ObjDesc->Region.SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY)
{
return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
}
/*
* If the Region Address and Length have not been previously evaluated,
* evaluate them now and save the results.
*/
if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
{
Status = AcpiDsGetRegionArguments (ObjDesc);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/* Get the table header first so we can get the table length */
Table = ACPI_ALLOCATE (sizeof (ACPI_TABLE_HEADER));
if (!Table)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiExRegionRead (ObjDesc, sizeof (ACPI_TABLE_HEADER),
ACPI_CAST_PTR (UINT8, Table));
Length = Table->Length;
ACPI_FREE (Table);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Must have at least an ACPI table header */
if (Length < sizeof (ACPI_TABLE_HEADER))
{
return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
}
/*
* The original implementation simply mapped the table, with no copy.
* However, the memory region is not guaranteed to remain stable and
* we must copy the table to a local buffer. For example, the memory
* region is corrupted after suspend on some machines. Dynamically
* loaded tables are usually small, so this overhead is minimal.
*
* The latest implementation (5/2009) does not use a mapping at all.
* We use the low-level operation region interface to read the table
* instead of the obvious optimization of using a direct mapping.
* This maintains a consistent use of operation regions across the
* entire subsystem. This is important if additional processing must
* be performed in the (possibly user-installed) operation region
* handler. For example, AcpiExec and ASLTS depend on this.
*/
/* Allocate a buffer for the table */
TableDesc.Pointer = ACPI_ALLOCATE (Length);
if (!TableDesc.Pointer)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Read the entire table */
Status = AcpiExRegionRead (ObjDesc, Length,
ACPI_CAST_PTR (UINT8, TableDesc.Pointer));
if (ACPI_FAILURE (Status))
{
ACPI_FREE (TableDesc.Pointer);
return_ACPI_STATUS (Status);
}
TableDesc.Address = ObjDesc->Region.Address;
break;
case ACPI_TYPE_BUFFER: /* Buffer or resolved RegionField */
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Load table from Buffer or Field %p\n", ObjDesc));
/* Must have at least an ACPI table header */
if (ObjDesc->Buffer.Length < sizeof (ACPI_TABLE_HEADER))
{
return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
}
/* Get the actual table length from the table header */
Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ObjDesc->Buffer.Pointer);
Length = Table->Length;
/* Table cannot extend beyond the buffer */
if (Length > ObjDesc->Buffer.Length)
{
return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
}
if (Length < sizeof (ACPI_TABLE_HEADER))
{
return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
}
/*
* Copy the table from the buffer because the buffer could be modified
* or even deleted in the future
*/
TableDesc.Pointer = ACPI_ALLOCATE (Length);
if (!TableDesc.Pointer)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
ACPI_MEMCPY (TableDesc.Pointer, Table, Length);
TableDesc.Address = ACPI_TO_INTEGER (TableDesc.Pointer);
break;
default:
return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
}
/* Validate table checksum (will not get validated in TbAddTable) */
Status = AcpiTbVerifyChecksum (TableDesc.Pointer, Length);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (TableDesc.Pointer);
return_ACPI_STATUS (Status);
}
/* Complete the table descriptor */
TableDesc.Length = Length;
TableDesc.Flags = ACPI_TABLE_ORIGIN_ALLOCATED;
/* Install the new table into the local data structures */
Status = AcpiTbAddTable (&TableDesc, &TableIndex);
if (ACPI_FAILURE (Status))
{
/* Delete allocated table buffer */
AcpiTbDeleteTable (&TableDesc);
return_ACPI_STATUS (Status);
}
/*
* Add the table to the namespace.
*
* Note: Load the table objects relative to the root of the namespace.
* This appears to go against the ACPI specification, but we do it for
* compatibility with other ACPI implementations.
*/
Status = AcpiExAddTable (TableIndex, AcpiGbl_RootNode, &DdbHandle);
if (ACPI_FAILURE (Status))
{
/* On error, TablePtr was deallocated above */
return_ACPI_STATUS (Status);
}
/* Store the DdbHandle into the Target operand */
Status = AcpiExStore (DdbHandle, Target, WalkState);
if (ACPI_FAILURE (Status))
{
(void) AcpiExUnloadTable (DdbHandle);
/* TablePtr was deallocated above */
AcpiUtRemoveReference (DdbHandle);
return_ACPI_STATUS (Status);
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Dynamic OEM Table Load:"));
AcpiTbPrintTableHeader (0, TableDesc.Pointer);
/* Remove the reference by added by AcpiExStore above */
AcpiUtRemoveReference (DdbHandle);
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, TableDesc.Pointer,
AcpiGbl_TableHandlerContext);
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiExLoadTableOp (
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT **ReturnDesc)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
ACPI_NAMESPACE_NODE *ParentNode;
ACPI_NAMESPACE_NODE *StartNode;
ACPI_NAMESPACE_NODE *ParameterNode = NULL;
ACPI_OPERAND_OBJECT *DdbHandle;
ACPI_TABLE_HEADER *Table;
UINT32 TableIndex;
ACPI_FUNCTION_TRACE (ExLoadTableOp);
/* Validate lengths for the SignatureString, OEMIDString, OEMTableID */
if ((Operand[0]->String.Length > ACPI_NAME_SIZE) ||
(Operand[1]->String.Length > ACPI_OEM_ID_SIZE) ||
(Operand[2]->String.Length > ACPI_OEM_TABLE_ID_SIZE))
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Find the ACPI table in the RSDT/XSDT */
Status = AcpiTbFindTable (Operand[0]->String.Pointer,
Operand[1]->String.Pointer,
Operand[2]->String.Pointer, &TableIndex);
if (ACPI_FAILURE (Status))
{
if (Status != AE_NOT_FOUND)
{
return_ACPI_STATUS (Status);
}
/* Table not found, return an Integer=0 and AE_OK */
DdbHandle = AcpiUtCreateIntegerObject ((UINT64) 0);
if (!DdbHandle)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
*ReturnDesc = DdbHandle;
return_ACPI_STATUS (AE_OK);
}
/* Default nodes */
StartNode = WalkState->ScopeInfo->Scope.Node;
ParentNode = AcpiGbl_RootNode;
/* RootPath (optional parameter) */
if (Operand[3]->String.Length > 0)
{
/*
* Find the node referenced by the RootPathString. This is the
* location within the namespace where the table will be loaded.
*/
Status = AcpiNsGetNode (StartNode, Operand[3]->String.Pointer,
ACPI_NS_SEARCH_PARENT, &ParentNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/* ParameterPath (optional parameter) */
if (Operand[4]->String.Length > 0)
{
if ((Operand[4]->String.Pointer[0] != '\\') &&
(Operand[4]->String.Pointer[0] != '^'))
{
/*
* Path is not absolute, so it will be relative to the node
* referenced by the RootPathString (or the NS root if omitted)
*/
StartNode = ParentNode;
}
/* Find the node referenced by the ParameterPathString */
Status = AcpiNsGetNode (StartNode, Operand[4]->String.Pointer,
ACPI_NS_SEARCH_PARENT, &ParameterNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/* Load the table into the namespace */
Status = AcpiExAddTable (TableIndex, ParentNode, &DdbHandle);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Parameter Data (optional) */
if (ParameterNode)
{
/* Store the parameter data into the optional parameter object */
Status = AcpiExStore (Operand[5],
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParameterNode),
WalkState);
if (ACPI_FAILURE (Status))
{
(void) AcpiExUnloadTable (DdbHandle);
AcpiUtRemoveReference (DdbHandle);
return_ACPI_STATUS (Status);
}
}
Status = AcpiGetTableByIndex (TableIndex, &Table);
if (ACPI_SUCCESS (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Dynamic OEM Table Load:"));
AcpiTbPrintTableHeader (0, Table);
}
/* Invoke table handler if present */
if (AcpiGbl_TableHandler)
{
(void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
AcpiGbl_TableHandlerContext);
}
*ReturnDesc = DdbHandle;
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcGetAllTablesFromFile (
char *Filename,
UINT8 GetOnlyAmlTables,
ACPI_NEW_TABLE_DESC **ReturnListHead)
{
ACPI_NEW_TABLE_DESC *ListHead = NULL;
ACPI_NEW_TABLE_DESC *ListTail = NULL;
ACPI_NEW_TABLE_DESC *TableDesc;
FILE *File;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 FileSize;
ACPI_STATUS Status = AE_OK;
File = fopen (Filename, "rb");
if (!File)
{
fprintf (stderr, "Could not open input file: %s\n", Filename);
if (errno == ENOENT)
{
return (AE_NOT_EXIST);
}
return (AE_ERROR);
}
/* Get the file size */
FileSize = CmGetFileSize (File);
if (FileSize == ACPI_UINT32_MAX)
{
Status = AE_ERROR;
goto Exit;
}
fprintf (stderr,
"Input file %s, Length 0x%X (%u) bytes\n",
Filename, FileSize, FileSize);
/* We must have at least one ACPI table header */
if (FileSize < sizeof (ACPI_TABLE_HEADER))
{
Status = AE_BAD_HEADER;
goto Exit;
}
/* Check for an non-binary file */
if (!AcIsFileBinary (File))
{
fprintf (stderr,
" %s: File does not appear to contain a valid AML table\n",
Filename);
Status = AE_TYPE;
goto Exit;
}
/* Read all tables within the file */
while (ACPI_SUCCESS (Status))
{
/* Get one entire ACPI table */
Status = AcGetOneTableFromFile (
Filename, File, GetOnlyAmlTables, &Table);
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
break;
}
else if (Status == AE_TYPE)
{
Status = AE_OK;
goto Exit;
}
else if (ACPI_FAILURE (Status))
{
goto Exit;
}
/* Print table header for iASL/disassembler only */
#ifdef ACPI_ASL_COMPILER
AcpiTbPrintTableHeader (0, Table);
#endif
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (ACPI_NEW_TABLE_DESC));
if (!TableDesc)
{
AcpiOsFree (Table);
Status = AE_NO_MEMORY;
goto Exit;
}
TableDesc->Table = Table;
TableDesc->Next = NULL;
/* Link at the end of the local table list */
if (!ListHead)
{
ListHead = TableDesc;
ListTail = TableDesc;
}
else
{
ListTail->Next = TableDesc;
ListTail = TableDesc;
}
}
/* Add the local table list to the end of the global list */
if (*ReturnListHead)
{
ListTail = *ReturnListHead;
while (ListTail->Next)
{
ListTail = ListTail->Next;
}
ListTail->Next = ListHead;
}
else
{
*ReturnListHead = ListHead;
}
Exit:
fclose(File);
return (Status);
}
void
AcpiDbDisplayTableInfo (
char *TableArg)
{
UINT32 i;
ACPI_TABLE_DESC *TableDesc;
ACPI_STATUS Status;
/* Header */
AcpiOsPrintf ("Idx ID Status Type TableHeader (Sig, Address, Length)\n");
/* Walk the entire root table list */
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
{
TableDesc = &AcpiGbl_RootTableList.Tables[i];
/* Index and Table ID */
AcpiOsPrintf ("%3u %.2u ", i, TableDesc->OwnerId);
/* Decode the table flags */
if (!(TableDesc->Flags & ACPI_TABLE_IS_LOADED))
{
AcpiOsPrintf ("NotLoaded ");
}
else
{
AcpiOsPrintf (" Loaded ");
}
switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
{
case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
AcpiOsPrintf ("External/virtual ");
break;
case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
AcpiOsPrintf ("Internal/physical ");
break;
case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
AcpiOsPrintf ("Internal/virtual ");
break;
default:
AcpiOsPrintf ("INVALID TYPE ");
break;
}
/* Make sure that the table is mapped */
Status = AcpiTbValidateTable (TableDesc);
if (ACPI_FAILURE (Status))
{
return;
}
/* Dump the table header */
if (TableDesc->Pointer)
{
AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
}
else
{
/* If the pointer is null, the table has been unloaded */
ACPI_INFO ((AE_INFO, "%4.4s - Table has been unloaded",
TableDesc->Signature.Ascii));
}
}
}
void
AcpiDbDisplayTableInfo (
char *TableArg)
{
UINT32 i;
ACPI_TABLE_DESC *TableDesc;
ACPI_STATUS Status;
/* Header */
AcpiOsPrintf ("Idx ID Status Type Sig Address Len Header\n");
/* Walk the entire root table list */
for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
{
TableDesc = &AcpiGbl_RootTableList.Tables[i];
/* Index and Table ID */
AcpiOsPrintf ("%3u %.2u ", i, TableDesc->OwnerId);
/* Decode the table flags */
if (!(TableDesc->Flags & ACPI_TABLE_IS_LOADED))
{
AcpiOsPrintf ("NotLoaded ");
}
else
{
AcpiOsPrintf (" Loaded ");
}
switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
{
case ACPI_TABLE_ORIGIN_UNKNOWN:
AcpiOsPrintf ("Unknown ");
break;
case ACPI_TABLE_ORIGIN_MAPPED:
AcpiOsPrintf ("Mapped ");
break;
case ACPI_TABLE_ORIGIN_ALLOCATED:
AcpiOsPrintf ("Allocated ");
break;
case ACPI_TABLE_ORIGIN_OVERRIDE:
AcpiOsPrintf ("Override ");
break;
default:
AcpiOsPrintf ("INVALID ");
break;
}
/* Make sure that the table is mapped */
Status = AcpiTbVerifyTable (TableDesc);
if (ACPI_FAILURE (Status))
{
return;
}
/* Dump the table header */
if (TableDesc->Pointer)
{
AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
}
else
{
/* If the pointer is null, the table has been unloaded */
ACPI_INFO ((AE_INFO, "%4.4s - Table has been unloaded",
TableDesc->Signature.Ascii));
}
}
}
