ACPI_TABLE_HEADER *
AcpiTbCopyDsdt (
UINT32 TableIndex)
{
ACPI_TABLE_HEADER *NewTable;
ACPI_TABLE_DESC *TableDesc;
TableDesc = &AcpiGbl_RootTableList.Tables[TableIndex];
NewTable = ACPI_ALLOCATE (TableDesc->Length);
if (!NewTable)
{
ACPI_ERROR ((AE_INFO, "Could not copy DSDT of length 0x%X",
TableDesc->Length));
return (NULL);
}
memcpy (NewTable, TableDesc->Pointer, TableDesc->Length);
AcpiTbUninstallTable (TableDesc);
AcpiTbInitTableDescriptor (
&AcpiGbl_RootTableList.Tables[AcpiGbl_DsdtIndex],
ACPI_PTR_TO_PHYSADDR (NewTable),
ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, NewTable);
ACPI_INFO ((
"Forced DSDT copy: length 0x%05X copied locally, original unmapped",
NewTable->Length));
return (NewTable);
}
ACPI_STATUS
AcpiTbAcquireTempTable (
ACPI_TABLE_DESC *TableDesc,
ACPI_PHYSICAL_ADDRESS Address,
UINT8 Flags)
{
ACPI_TABLE_HEADER *TableHeader;
switch (Flags & ACPI_TABLE_ORIGIN_MASK)
{
case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
/* Get the length of the full table from the header */
TableHeader = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));
if (!TableHeader)
{
return (AE_NO_MEMORY);
}
AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);
AcpiOsUnmapMemory (TableHeader, sizeof (ACPI_TABLE_HEADER));
return (AE_OK);
case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
TableHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER,
ACPI_PHYSADDR_TO_PTR (Address));
if (!TableHeader)
{
return (AE_NO_MEMORY);
}
AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader);
return (AE_OK);
default:
break;
}
/* Table is not valid yet */
return (AE_NO_MEMORY);
}
static ACPI_STATUS
AeLocalLoadTable (
ACPI_TABLE_HEADER *Table)
{
ACPI_STATUS Status = AE_OK;
/* ACPI_TABLE_DESC TableInfo; */
ACPI_FUNCTION_TRACE (AeLocalLoadTable);
#if 0
if (!Table)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
TableInfo.Pointer = Table;
Status = AcpiTbRecognizeTable (&TableInfo, ACPI_TABLE_ALL);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Install the new table into the local data structures */
Status = AcpiTbInitTableDescriptor (&TableInfo);
if (ACPI_FAILURE (Status))
{
if (Status == AE_ALREADY_EXISTS)
{
/* Table already exists, no error */
Status = AE_OK;
}
/* Free table allocated by AcpiTbGetTable */
AcpiTbDeleteSingleTable (&TableInfo);
return_ACPI_STATUS (Status);
}
#if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
Status = AcpiNsLoadTable (TableInfo.InstalledDesc, AcpiGbl_RootNode);
if (ACPI_FAILURE (Status))
{
/* Uninstall table and free the buffer */
AcpiTbDeleteTablesByType (ACPI_TABLE_ID_DSDT);
return_ACPI_STATUS (Status);
}
#endif
#endif
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiTbInstallTable (
ACPI_TABLE_DESC *TableInfo)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (TbInstallTable);
/* Lock tables while installing */
Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "Could not acquire table mutex"));
return_ACPI_STATUS (Status);
}
/*
* Ignore a table that is already installed. For example, some BIOS
* ASL code will repeatedly attempt to load the same SSDT.
*/
Status = AcpiTbIsTableInstalled (TableInfo);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
/* Install the table into the global data structure */
Status = AcpiTbInitTableDescriptor (TableInfo->Type, TableInfo);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "Could not install table [%4.4s]",
TableInfo->Pointer->Signature));
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "%s located at %p\n",
AcpiGbl_TableData[TableInfo->Type].Name, TableInfo->Pointer));
UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
return_ACPI_STATUS (Status);
}
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 ACPI_STATUS
AdStoreTable (
ACPI_TABLE_HEADER *Table,
UINT32 *TableIndex)
{
ACPI_STATUS Status;
ACPI_TABLE_DESC *TableDesc;
Status = AcpiTbGetNextTableDescriptor (TableIndex, &TableDesc);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Initialize added table */
AcpiTbInitTableDescriptor (TableDesc, ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table);
Status = AcpiTbValidateTable (TableDesc);
return (Status);
}
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);
}
}
void
AcpiTbOverrideTable (
ACPI_TABLE_DESC *OldTableDesc)
{
ACPI_STATUS Status;
char *OverrideType;
ACPI_TABLE_DESC NewTableDesc;
ACPI_TABLE_HEADER *Table;
ACPI_PHYSICAL_ADDRESS Address;
UINT32 Length;
/* (1) Attempt logical override (returns a logical address) */
Status = AcpiOsTableOverride (OldTableDesc->Pointer, &Table);
if (ACPI_SUCCESS (Status) && Table)
{
AcpiTbAcquireTempTable (&NewTableDesc, ACPI_PTR_TO_PHYSADDR (Table),
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL);
OverrideType = "Logical";
goto FinishOverride;
}
/* (2) Attempt physical override (returns a physical address) */
Status = AcpiOsPhysicalTableOverride (OldTableDesc->Pointer,
&Address, &Length);
if (ACPI_SUCCESS (Status) && Address && Length)
{
AcpiTbAcquireTempTable (&NewTableDesc, Address,
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
OverrideType = "Physical";
goto FinishOverride;
}
return; /* There was no override */
FinishOverride:
/* Validate and verify a table before overriding */
Status = AcpiTbVerifyTempTable (&NewTableDesc, NULL);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_INFO ((AE_INFO, "%4.4s 0x%8.8X%8.8X"
" %s table override, new table: 0x%8.8X%8.8X",
OldTableDesc->Signature.Ascii,
ACPI_FORMAT_UINT64 (OldTableDesc->Address),
OverrideType, ACPI_FORMAT_UINT64 (NewTableDesc.Address)));
/* We can now uninstall the original table */
AcpiTbUninstallTable (OldTableDesc);
/*
* Replace the original table descriptor and keep its state as
* "VALIDATED".
*/
AcpiTbInitTableDescriptor (OldTableDesc, NewTableDesc.Address,
NewTableDesc.Flags, NewTableDesc.Pointer);
AcpiTbValidateTempTable (OldTableDesc);
/* Release the temporary table descriptor */
AcpiTbReleaseTempTable (&NewTableDesc);
}
