mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-26 16:47:40 +01:00
2547 lines
87 KiB
C++
2547 lines
87 KiB
C++
/**
|
|
initial concept of DSDT patching by mackerintel
|
|
|
|
Re-Work by Slice 2011.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
**/
|
|
|
|
#include "StateGenerator.h"
|
|
#include "AmlGenerator.h"
|
|
|
|
#define HPET_SIGN SIGNATURE_32('H','P','E','T')
|
|
#define APIC_SIGN SIGNATURE_32('A','P','I','C')
|
|
#define MCFG_SIGN SIGNATURE_32('M','C','F','G')
|
|
#define ECDT_SIGN SIGNATURE_32('E','C','D','T')
|
|
#define DMAR_SIGN SIGNATURE_32('D','M','A','R')
|
|
#define BGRT_SIGN SIGNATURE_32('B','G','R','T')
|
|
#define SLIC_SIGN SIGNATURE_32('S','L','I','C')
|
|
#define APPLE_OEM_ID { 'A', 'P', 'P', 'L', 'E', ' ' }
|
|
#define APPLE_OEM_TABLE_ID { 'A', 'p', 'p', 'l', 'e', '0', '0', ' ' }
|
|
#define APPLE_CREATOR_ID { 'L', 'o', 'k', 'i' }
|
|
|
|
#define IGNORE_INDEX (~((UINTN)0)) // index ignored for matching (not ignored for >= 0)
|
|
#define AUTOMERGE_PASS1 1 // load just those that match existing entries
|
|
#define AUTOMERGE_PASS2 2 // load the rest
|
|
|
|
CONST CHAR8 oemID[6] = APPLE_OEM_ID;
|
|
CONST CHAR8 oemTableID[8] = APPLE_OEM_TABLE_ID;
|
|
CONST CHAR8 creatorID[4] = APPLE_CREATOR_ID;
|
|
|
|
//Global pointers
|
|
RSDT_TABLE *Rsdt = NULL;
|
|
XSDT_TABLE *Xsdt = NULL;
|
|
UINTN *XsdtReplaceSizes = NULL;
|
|
|
|
#define IndexFromEntryPtr(xsdt_or_rsdt, entry_ptr) \
|
|
((UINT32)(((CHAR8*)(entry_ptr) - (CHAR8*)&(xsdt_or_rsdt)->Entry)/sizeof((xsdt_or_rsdt)->Entry)))
|
|
#define IndexFromRsdtEntryPtr(entry_ptr) IndexFromEntryPtr(Rsdt, entry_ptr)
|
|
#define IndexFromXsdtEntryPtr(entry_ptr) IndexFromEntryPtr(Xsdt, entry_ptr)
|
|
#define TableCount(xsdt_or_rsdt) \
|
|
(((xsdt_or_rsdt)->Header.Length - sizeof(EFI_ACPI_DESCRIPTION_HEADER)) / sizeof((xsdt_or_rsdt)->Entry))
|
|
#define RsdtTableCount() TableCount(Rsdt)
|
|
#define XsdtTableCount() TableCount(Xsdt)
|
|
#define RsdtEntryPtrFromIndex(index) (&Rsdt->Entry + index)
|
|
#define XsdtEntryPtrFromIndex(index) ((UINT64*)((CHAR8*)&Xsdt->Entry + sizeof(UINT64)*(index)))
|
|
#define RsdtEntryFromIndex(index) (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)*RsdtEntryPtrFromIndex(index)
|
|
#define XsdtEntryFromIndex(index) (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(XsdtEntryPtrFromIndex(index))
|
|
|
|
UINT64 BiosDsdt;
|
|
UINT32 BiosDsdtLen;
|
|
UINT8 acpi_cpu_count;
|
|
CHAR8* acpi_cpu_name[acpi_cpu_max];
|
|
UINT8 acpi_cpu_processor_id[acpi_cpu_max];
|
|
CHAR8* acpi_cpu_score;
|
|
|
|
UINT64 machineSignature;
|
|
|
|
extern OPER_REGION *gRegions;
|
|
//-----------------------------------
|
|
|
|
|
|
UINT8 pmBlock[] = {
|
|
|
|
/*0070: 0xA5, 0x84, 0x00, 0x00,*/ 0x01, 0x08, 0x00, 0x01, 0xF9, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/*0080:*/ 0x06, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x67, 0xBF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x6F, 0xBF,
|
|
/*0090:*/ 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/*00A0:*/ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x02,
|
|
/*00B0:*/ 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/*00C0:*/ 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
/*00D0:*/ 0x01, 0x20, 0x00, 0x03, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x01,
|
|
/*00E0:*/ 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
|
|
/*00F0:*/ 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
// RehabMan: for stripping trailing spaces
|
|
static void stripTrailingSpaces(CHAR8* sgn)
|
|
{
|
|
CHAR8* lastNonSpace = sgn-1;
|
|
for (; *sgn; sgn++) {
|
|
if (*sgn != ' ') {
|
|
lastNonSpace = sgn;
|
|
}
|
|
}
|
|
lastNonSpace[1] = 0;
|
|
}
|
|
|
|
VOID* FindAcpiRsdPtr()
|
|
{
|
|
UINTN Address;
|
|
UINTN Index;
|
|
//
|
|
// First Seach 0x0e0000 - 0x0fffff for RSD Ptr
|
|
//
|
|
for (Address = 0xe0000; Address < 0xfffff; Address += 0x10) {
|
|
if (*(UINT64 *)(Address) == EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE) {
|
|
return (VOID *)Address;
|
|
}
|
|
}
|
|
//
|
|
// Search EBDA
|
|
//
|
|
Address = (*(UINT16 *)(UINTN)(EBDA_BASE_ADDRESS)) << 4;
|
|
if ( Address == 0 ) return 0; // Jief : if Address==0, the first access at *(UINT64 *)(Address + Index) is at address 0. It's supposed to crash.
|
|
for (Index = 0; Index < 0x400 ; Index += 16) {
|
|
if (*(UINT64 *)(Address + Index) == EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE) {
|
|
return (VOID *)Address;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
UINT8 Checksum8(VOID* startPtr, UINT32 len)
|
|
{
|
|
UINT8 Value = 0;
|
|
UINT8 *ptr = (UINT8*)startPtr;
|
|
UINT8 *endPtr = ptr + len;
|
|
while (ptr < endPtr)
|
|
Value += *ptr++;
|
|
return Value;
|
|
}
|
|
|
|
void FixChecksum(EFI_ACPI_DESCRIPTION_HEADER* Table)
|
|
{
|
|
Table->Checksum = 0;
|
|
Table->Checksum = (UINT8)(256-Checksum8(Table, Table->Length));
|
|
}
|
|
|
|
void SaveMergedXsdtEntrySize(UINT32 Index, UINTN Size)
|
|
{
|
|
// manage XsdtReplaceSizes (free existing, store new)
|
|
if (XsdtReplaceSizes) {
|
|
if (XsdtReplaceSizes[Index]) {
|
|
// came from patched table in ACPI/patched, so free original pages
|
|
gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)XsdtEntryFromIndex(Index), XsdtReplaceSizes[Index]);
|
|
XsdtReplaceSizes[Index] = 0;
|
|
}
|
|
XsdtReplaceSizes[Index] = EFI_SIZE_TO_PAGES(Size);
|
|
}
|
|
}
|
|
|
|
BOOLEAN IsXsdtEntryMerged(UINT32 Index)
|
|
{
|
|
if (!XsdtReplaceSizes) {
|
|
return FALSE;
|
|
}
|
|
return 0 != XsdtReplaceSizes[Index];
|
|
}
|
|
|
|
UINT32* ScanRSDT2(UINT32 Signature, UINT64 TableId, UINTN MatchIndex)
|
|
{
|
|
if (!Rsdt || (0 == Signature && 0 == TableId)) {
|
|
return NULL;
|
|
}
|
|
|
|
UINT32 Count = RsdtTableCount();
|
|
UINTN MatchingCount = 0;
|
|
UINT32* Ptr = RsdtEntryPtrFromIndex(0);
|
|
UINT32* EndPtr = RsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)*Ptr;
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
if (0 == Signature || Table->Signature == Signature) {
|
|
if ((0 == TableId || Table->OemTableId == TableId) && (IGNORE_INDEX == MatchIndex || MatchingCount == MatchIndex)) {
|
|
return Ptr; // pointer to the matching entry
|
|
}
|
|
++MatchingCount;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
UINT32* ScanRSDT(UINT32 Signature, UINT64 TableId)
|
|
{
|
|
return ScanRSDT2(Signature, TableId, IGNORE_INDEX);
|
|
}
|
|
|
|
UINT64* ScanXSDT2(UINT32 Signature, UINT64 TableId, UINTN MatchIndex)
|
|
{
|
|
if (!Xsdt || (0 == Signature && 0 == TableId)) {
|
|
return NULL;
|
|
}
|
|
|
|
UINT32 Count = XsdtTableCount();
|
|
UINTN MatchingCount = 0;
|
|
UINT64* Ptr = XsdtEntryPtrFromIndex(0);
|
|
UINT64* EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(Ptr);
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
if (0 == Signature || Table->Signature == Signature) {
|
|
if ((0 == TableId || Table->OemTableId == TableId) && (IGNORE_INDEX == MatchIndex || MatchingCount == MatchIndex)) {
|
|
return Ptr; // pointer to the matching entry
|
|
}
|
|
++MatchingCount;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
UINT64* ScanXSDT(UINT32 Signature, UINT64 TableId)
|
|
{
|
|
return ScanXSDT2(Signature, TableId, IGNORE_INDEX);
|
|
}
|
|
|
|
|
|
void AddDropTable(EFI_ACPI_DESCRIPTION_HEADER* Table, UINT32 Index)
|
|
{
|
|
CHAR8 sign[5], OTID[9];
|
|
sign[4] = 0;
|
|
OTID[8] = 0;
|
|
CopyMem(&sign[0], &Table->Signature, 4);
|
|
CopyMem(&OTID[0], &Table->OemTableId, 8);
|
|
//DBG(" Found table: %a %a len=%d\n", sign, OTID, (INT32)Table->Length);
|
|
DBG(" - [%02d]: %a %a len=%d\n", Index, sign, OTID, (INT32)Table->Length);
|
|
ACPI_DROP_TABLE* DropTable = (__typeof__(DropTable))AllocateZeroPool(sizeof(ACPI_DROP_TABLE));
|
|
DropTable->Signature = Table->Signature;
|
|
DropTable->TableId = Table->OemTableId;
|
|
DropTable->Length = Table->Length;
|
|
DropTable->MenuItem.BValue = FALSE;
|
|
DropTable->Next = gSettings.ACPIDropTables;
|
|
gSettings.ACPIDropTables = DropTable;
|
|
}
|
|
|
|
VOID GetAcpiTablesList()
|
|
{
|
|
DbgHeader("GetAcpiTablesList");
|
|
|
|
GetFadt(); //this is a first call to acpi, we need it to make a pointer to Xsdt
|
|
gSettings.ACPIDropTables = NULL;
|
|
|
|
DBG("Get Acpi Tables List ");
|
|
if (Xsdt) {
|
|
UINT32 Count = XsdtTableCount();
|
|
UINT64* Ptr = XsdtEntryPtrFromIndex(0);
|
|
UINT64* EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
DBG("from XSDT:\n");
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(Ptr);
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
AddDropTable(Table, IndexFromXsdtEntryPtr(Ptr));
|
|
}
|
|
} else if (Rsdt) {
|
|
DBG("from RSDT:\n");
|
|
UINT32 Count = RsdtTableCount();
|
|
UINT32* Ptr = RsdtEntryPtrFromIndex(0);
|
|
UINT32* EndPtr = RsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)*Ptr;
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
AddDropTable(Table, IndexFromRsdtEntryPtr(Ptr));
|
|
}
|
|
} else {
|
|
DBG(": [!] Error! ACPI not found:\n");
|
|
}
|
|
}
|
|
|
|
|
|
void DropTableFromRSDT(UINT32 Signature, UINT64 TableId, UINT32 Length)
|
|
{
|
|
if (!Rsdt || (0 == Signature && 0 == TableId)) {
|
|
return;
|
|
}
|
|
|
|
CHAR8 sign[5], OTID[9];
|
|
sign[4] = 0;
|
|
OTID[8] = 0;
|
|
CopyMem(sign, &Signature, 4);
|
|
CopyMem(OTID, &TableId, 8);
|
|
DBG("Drop tables from RSDT, SIGN=%a TableID=%a Length=%d\n", sign, OTID, (INT32)Length);
|
|
|
|
UINT32 Count = RsdtTableCount();
|
|
//DBG(" Rsdt has tables count=%d\n", Count);
|
|
UINT32* Ptr = RsdtEntryPtrFromIndex(0);
|
|
UINT32* EndPtr = RsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)*Ptr;
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
CopyMem(&sign, &Table->Signature, 4);
|
|
CopyMem(&OTID, &Table->OemTableId, 8);
|
|
//DBG(" Found table: %a %a\n", sign, OTID);
|
|
if (!((Signature && Table->Signature == Signature) &&
|
|
(!TableId || Table->OemTableId == TableId) &&
|
|
(!Length || Table->Length == Length))) {
|
|
continue;
|
|
}
|
|
if (IsXsdtEntryMerged(IndexFromXsdtEntryPtr(Ptr))) {
|
|
DBG(" attempt to drop already merged table[%d]: %a %a %d ignored\n", IndexFromXsdtEntryPtr(Ptr), sign, OTID, (INT32)Table->Length);
|
|
continue;
|
|
}
|
|
// drop matching table by simply replacing entry with NULL
|
|
*Ptr = 0;
|
|
DBG(" Table[%d]: %a %a %d dropped\n", IndexFromXsdtEntryPtr(Ptr), sign, OTID, (INT32)Table->Length);
|
|
}
|
|
}
|
|
|
|
void DropTableFromXSDT(UINT32 Signature, UINT64 TableId, UINT32 Length)
|
|
{
|
|
if (!Xsdt || (0 == Signature && 0 == TableId)) {
|
|
return;
|
|
}
|
|
|
|
CHAR8 sign[5], OTID[9];
|
|
sign[4] = 0;
|
|
OTID[8] = 0;
|
|
CopyMem(sign, &Signature, 4);
|
|
CopyMem(OTID, &TableId, 8);
|
|
DBG("Drop tables from XSDT, SIGN=%a TableID=%a Length=%d\n", sign, OTID, (INT32)Length);
|
|
|
|
UINT32 Count = XsdtTableCount();
|
|
//DBG(" Xsdt has tables count=%d\n", Count);
|
|
UINT64* Ptr = XsdtEntryPtrFromIndex(0);
|
|
UINT64* EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(Ptr);
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
CopyMem(&sign, &Table->Signature, 4);
|
|
CopyMem(&OTID, &Table->OemTableId, 8);
|
|
//DBG(" Found table: %a %a\n", sign, OTID);
|
|
if (!((Signature && Table->Signature == Signature) &&
|
|
(!TableId || Table->OemTableId == TableId) &&
|
|
(!Length || Table->Length == Length))) {
|
|
continue;
|
|
}
|
|
if (IsXsdtEntryMerged(IndexFromXsdtEntryPtr(Ptr))) {
|
|
DBG(" attempt to drop already merged table[%d]: %a %a %d ignored\n", IndexFromXsdtEntryPtr(Ptr), sign, OTID, (INT32)Table->Length);
|
|
continue;
|
|
}
|
|
// drop matching table by simply replacing entry with NULL
|
|
WriteUnaligned64(Ptr, 0);
|
|
DBG(" Table[%d]: %a %a %d dropped\n", IndexFromXsdtEntryPtr(Ptr), sign, OTID, (INT32)Table->Length);
|
|
}
|
|
}
|
|
|
|
|
|
// by cecekpawon, edited by Slice, further edits by RehabMan
|
|
BOOLEAN FixAsciiTableHeader(UINT8 *Str, UINTN Len)
|
|
{
|
|
BOOLEAN NonAscii = FALSE;
|
|
UINT8* StrEnd = Str + Len;
|
|
for (; Str < StrEnd; Str++) {
|
|
if (!*Str) continue; // NUL is allowed
|
|
if (*Str < ' ') {
|
|
*Str = ' ';
|
|
NonAscii = TRUE;
|
|
}
|
|
else if (*Str > 0x7e) {
|
|
*Str = '_';
|
|
NonAscii = TRUE;
|
|
}
|
|
}
|
|
return NonAscii;
|
|
}
|
|
|
|
BOOLEAN PatchTableHeader(EFI_ACPI_DESCRIPTION_HEADER *Header)
|
|
{
|
|
BOOLEAN Ret1, Ret2, Ret3;
|
|
if (!(gSettings.FixDsdt & FIX_HEADERS) && !gSettings.FixHeaders) {
|
|
return FALSE;
|
|
}
|
|
Ret1 = FixAsciiTableHeader((UINT8*)&Header->CreatorId, 4);
|
|
Ret2 = FixAsciiTableHeader((UINT8*)&Header->OemTableId, 8);
|
|
Ret3 = FixAsciiTableHeader((UINT8*)&Header->OemId, 6);
|
|
return (Ret1 || Ret2 || Ret3);
|
|
}
|
|
|
|
VOID PatchAllTables()
|
|
{
|
|
UINT32 Count = XsdtTableCount();
|
|
UINT64* Ptr = XsdtEntryPtrFromIndex(0);
|
|
UINT64* EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
BOOLEAN Patched = FALSE;
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(Ptr);
|
|
if (!Table) {
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
if (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE == Table->Signature) {
|
|
// may be also EFI_ACPI_4_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE?
|
|
continue; // will be patched elsewhere
|
|
}
|
|
|
|
//do new table with patched header
|
|
UINT32 Len = Table->Length;
|
|
EFI_PHYSICAL_ADDRESS BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
EFI_STATUS Status = gBS->AllocatePages(AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(Len + 4096),
|
|
&BufferPtr);
|
|
if(EFI_ERROR(Status)) {
|
|
//DBG(" ... not patched\n");
|
|
continue;
|
|
}
|
|
EFI_ACPI_DESCRIPTION_HEADER* NewTable = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)BufferPtr;
|
|
CopyMem(NewTable, Table, Len);
|
|
if ((gSettings.FixDsdt & FIX_HEADERS) || gSettings.FixHeaders) {
|
|
// Merged tables already have the header patched, so no need to do it again
|
|
if (!IsXsdtEntryMerged(IndexFromXsdtEntryPtr(Ptr))) {
|
|
// table header NOT already patched
|
|
Patched = PatchTableHeader(NewTable);
|
|
}
|
|
}
|
|
if (NewTable->Signature == EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (gSettings.PatchDsdtNum > 0) {
|
|
//DBG("Patching SSDT:\n");
|
|
UINT32 i;
|
|
CHAR8 OTID[9];
|
|
OTID[8] = 0;
|
|
CopyMem(OTID, &NewTable->OemTableId, 8);
|
|
DBG("Patching SSDT %a Length=%d\n", OTID, (INT32)Len);
|
|
|
|
for (i = 0; i < gSettings.PatchDsdtNum; i++) {
|
|
if (!gSettings.PatchDsdtFind[i] || !gSettings.LenToFind[i]) {
|
|
continue;
|
|
}
|
|
DBG("%d. [%a]:", i, gSettings.PatchDsdtLabel[i]);
|
|
if (!gSettings.PatchDsdtMenuItem[i].BValue) {
|
|
DBG(" disabled\n");
|
|
continue;
|
|
}
|
|
Len = FixAny((UINT8*)NewTable, Len,
|
|
gSettings.PatchDsdtFind[i], gSettings.LenToFind[i],
|
|
gSettings.PatchDsdtReplace[i], gSettings.LenToReplace[i]);
|
|
//DBG(" OK\n");
|
|
}
|
|
}
|
|
// fixup length and checksum
|
|
NewTable->Length = Len;
|
|
RenameDevices((UINT8*)NewTable);
|
|
GetBiosRegions((UINT8*)NewTable); //take Regions from SSDT even if they will be dropped
|
|
Patched = TRUE;
|
|
}
|
|
if (NewTable->Signature == MCFG_SIGN && gSettings.FixMCFG) {
|
|
INTN Len1 = ((Len + 4 - 1) / 16 + 1) * 16 - 4;
|
|
CopyMem(NewTable, Table, Len1); //Len increased but less than EFI_PAGE
|
|
NewTable->Length = (UINT32)(UINTN)Len1; Patched = TRUE;
|
|
}
|
|
if (Patched) {
|
|
WriteUnaligned64(Ptr, BufferPtr);
|
|
FixChecksum(NewTable);
|
|
}
|
|
else {
|
|
gBS->FreePages(BufferPtr, EFI_SIZE_TO_PAGES(Len + 4096));
|
|
}
|
|
}
|
|
}
|
|
|
|
EFI_STATUS InsertTable(VOID* TableEntry, UINTN Length)
|
|
{
|
|
if (!TableEntry) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
EFI_PHYSICAL_ADDRESS BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
EFI_STATUS Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(Length),
|
|
&BufferPtr
|
|
);
|
|
//if success insert table pointer into ACPI tables
|
|
if(!EFI_ERROR(Status)) {
|
|
// DBG("page is allocated, write SSDT into\n");
|
|
EFI_ACPI_DESCRIPTION_HEADER* TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)BufferPtr;
|
|
CopyMem(TableHeader, TableEntry, Length);
|
|
// Now is a good time to fix the table header and checksum
|
|
PatchTableHeader(TableHeader);
|
|
FixChecksum(TableHeader);
|
|
|
|
//insert into RSDT
|
|
if (Rsdt) {
|
|
UINT32* Ptr = RsdtEntryPtrFromIndex(RsdtTableCount());
|
|
*Ptr = (UINT32)(UINTN)BufferPtr;
|
|
Rsdt->Header.Length += sizeof(UINT32);
|
|
//DBG("Rsdt->Length = %d\n", Rsdt->Header.Length);
|
|
}
|
|
//insert into XSDT
|
|
if (Xsdt) {
|
|
UINT64* Ptr = XsdtEntryPtrFromIndex(XsdtTableCount());
|
|
WriteUnaligned64(Ptr, BufferPtr);
|
|
Xsdt->Header.Length += sizeof(UINT64);
|
|
//DBG("Xsdt->Length = %d\n", Xsdt->Header.Length);
|
|
}
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
UINTN IndexFromFileName(CHAR16* FileName)
|
|
{
|
|
// FileName must be as "XXXX-number-..." or "XXXX-number.aml", such as "SSDT-9.aml", or "SSDT-11-SaSsdt.aml"
|
|
// But just checking for '-' or '.' following the number.
|
|
|
|
// search for '-'
|
|
UINTN Result = IGNORE_INDEX;
|
|
CHAR16* temp = FileName;
|
|
for (; *temp != 0 && *temp != '-'; temp++);
|
|
if ('-' == *temp && 4 == temp-FileName) {
|
|
++temp;
|
|
if (*temp >= '0' && *temp <= '9') {
|
|
Result = 0;
|
|
for (; *temp >= '0' && *temp <= '9'; temp++) {
|
|
Result *= 10;
|
|
Result += *temp - '0';
|
|
}
|
|
// a FileName such as "SSDT-4x30s.aml" is not considered as "SSDT-4.aml"
|
|
if ('.' != *temp && '-' != *temp)
|
|
Result = IGNORE_INDEX;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
EFI_STATUS ReplaceOrInsertTable(VOID* TableEntry, UINTN Length, UINTN MatchIndex, INTN Pass)
|
|
{
|
|
if (!TableEntry) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
EFI_PHYSICAL_ADDRESS BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
EFI_STATUS Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(Length),
|
|
&BufferPtr
|
|
);
|
|
EFI_ACPI_DESCRIPTION_HEADER* hdr = (EFI_ACPI_DESCRIPTION_HEADER*)TableEntry;
|
|
|
|
//if success insert or replace table pointer into ACPI tables
|
|
if(!EFI_ERROR(Status)) {
|
|
Status = EFI_ABORTED;
|
|
//DBG("page is allocated, write SSDT into\n");
|
|
EFI_ACPI_DESCRIPTION_HEADER* TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)BufferPtr;
|
|
CopyMem(TableHeader, TableEntry, Length);
|
|
#if 0 //REVIEW: seems as if Rsdt is always NULL for ReplaceOrInsertTable scenarios (macOS/OS X)
|
|
//insert/modify into RSDT
|
|
if (Rsdt) {
|
|
UINT32* Ptr = NULL;
|
|
if (hdr->Signature != EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE || MatchIndex != IGNORE_INDEX) {
|
|
// SSDT with target index or non-SSDT, try to find matching entry
|
|
Ptr = ScanRSDT2(hdr->Signature, hdr->OemTableId, MatchIndex);
|
|
}
|
|
if (Ptr) {
|
|
*Ptr = (UINT32)(UINTN)BufferPtr;
|
|
Status = EFI_SUCCESS;
|
|
} else if (AUTOMERGE_PASS2 == Pass) {
|
|
Ptr = RsdtEntryPtrFromIndex(RsdtTableCount());
|
|
*Ptr = (UINT32)(UINTN)BufferPtr;
|
|
Rsdt->Header.Length += sizeof(UINT32);
|
|
//DBG("Rsdt->Length = %d\n", Rsdt->Header.Length);
|
|
Status = EFI_SUCCESS;
|
|
}
|
|
}
|
|
#endif
|
|
//insert/modify into XSDT
|
|
if (Xsdt) {
|
|
UINT64* Ptr = NULL;
|
|
if (hdr->Signature != EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE || MatchIndex != IGNORE_INDEX) {
|
|
// SSDT with target index or non-SSDT, try to find matching entry
|
|
Ptr = ScanXSDT2(hdr->Signature, hdr->OemTableId, MatchIndex);
|
|
}
|
|
// Now is a good time to fix the table header and checksum (*MUST* be done after matching)
|
|
PatchTableHeader(TableHeader);
|
|
FixChecksum(TableHeader);
|
|
if (Ptr) {
|
|
UINT32 Index = IndexFromXsdtEntryPtr(Ptr);
|
|
DBG("@%d ", (UINT64)Index);
|
|
// keep track of new table size in case it needs to be freed later
|
|
SaveMergedXsdtEntrySize(Index, Length);
|
|
WriteUnaligned64(Ptr, BufferPtr);
|
|
Status = EFI_SUCCESS;
|
|
} else if (AUTOMERGE_PASS2 == Pass) {
|
|
Ptr = XsdtEntryPtrFromIndex(XsdtTableCount());
|
|
WriteUnaligned64(Ptr, BufferPtr);
|
|
Xsdt->Header.Length += sizeof(UINT64);
|
|
//DBG("Xsdt->Length = %d\n", Xsdt->Header.Length);
|
|
Status = EFI_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
void PreCleanupRSDT()
|
|
{
|
|
if (!Rsdt) {
|
|
return;
|
|
}
|
|
|
|
//REVIEW: really?
|
|
// Если адрес RSDT < адреса XSDT и хвост RSDT наползает на XSDT, то подрезаем хвост RSDT до начала XSDT
|
|
// English: If the RSDT address of the XSDT address and the tail of the RSDT crawls onto the XSDT, then we
|
|
// trim the RSDT tail before the XSDT starts
|
|
if ((UINTN)Rsdt < (UINTN)Xsdt && (UINTN)Rsdt + Rsdt->Header.Length > (UINTN)Xsdt) {
|
|
UINTN v = ((UINTN)Xsdt - (UINTN)Rsdt) & ~3;
|
|
if ( v > MAX_UINT32 ) panic("((UINTN)Xsdt - (UINTN)Rsdt) & ~3 > MAX_UINT32");
|
|
Rsdt->Header.Length = (UINT32)v;
|
|
DBG("Cropped Rsdt->Header.Length=%d\n", (UINT32)Rsdt->Header.Length);
|
|
}
|
|
|
|
//REVIEW: why?
|
|
// terminate RSDT table at first double zero, if present
|
|
UINT32 Count = RsdtTableCount();
|
|
if (Count <= 2) {
|
|
return;
|
|
}
|
|
|
|
DBG("PreCleanup RSDT: count=%d, length=%d\n", Count, (UINT32)Rsdt->Header.Length);
|
|
UINT32* Ptr = RsdtEntryPtrFromIndex(0);
|
|
UINT32* EndPtr = RsdtEntryPtrFromIndex(Count-1);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
if (0 == Ptr[0] && 0 == Ptr[1]) {
|
|
// double zero found, terminate RSDT entry table here
|
|
DBG("DoubleZero in RSDT table\n");
|
|
Rsdt->Header.Length = (UINT32)((CHAR8*)Ptr - (CHAR8*)Rsdt);
|
|
break;
|
|
}
|
|
}
|
|
DBG("PreCleanup RSDT, corrected RSDT: count=%d, length=%d\n", Count, (UINT32)Rsdt->Header.Length);
|
|
}
|
|
|
|
void PostCleanupRSDT()
|
|
{
|
|
if (!Rsdt) {
|
|
return;
|
|
}
|
|
|
|
// remove NULL entries from RSDT table
|
|
UINT32 Count = RsdtTableCount();
|
|
DBG("Cleanup RSDT: count=%d, length=%d\n", Count, (UINT32)Rsdt->Header.Length);
|
|
UINT32* Source = RsdtEntryPtrFromIndex(0);
|
|
UINT32* Dest = Source;
|
|
UINT32* EndPtr = RsdtEntryPtrFromIndex(Count);
|
|
while (Source < EndPtr) {
|
|
if (0 == *Source) {
|
|
// skip NULL entry
|
|
Source++;
|
|
continue;
|
|
}
|
|
*Dest++ = *Source++;
|
|
}
|
|
// fix header length
|
|
Rsdt->Header.Length = (UINT32)((CHAR8*)Dest - (CHAR8*)Rsdt);
|
|
Count = RsdtTableCount();
|
|
DBG("corrected RSDT: count=%d, length=%d\n", Count, (UINT32)Rsdt->Header.Length);
|
|
FixChecksum(&Rsdt->Header);
|
|
}
|
|
|
|
void PreCleanupXSDT()
|
|
{
|
|
UINT64 *Ptr, *EndPtr;
|
|
if (!Xsdt) {
|
|
return;
|
|
}
|
|
|
|
//REVIEW: why?
|
|
// terminate RSDT table at first double zero, if present
|
|
UINT32 Count = XsdtTableCount();
|
|
if (Count <= 2) {
|
|
return;
|
|
}
|
|
DBG("PreCleanup XSDT: count=%d, length=%d\n", Count, (UINT32)Xsdt->Header.Length);
|
|
Ptr = XsdtEntryPtrFromIndex(0);
|
|
EndPtr = XsdtEntryPtrFromIndex(Count-1);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
if (0 == ReadUnaligned64(Ptr+0) && 0 == ReadUnaligned64(Ptr+1)) {
|
|
// double zero found, terminate XSDT entry table here
|
|
DBG("DoubleZero in XSDT table\n");
|
|
Xsdt->Header.Length = (UINT32)((CHAR8*)Ptr - (CHAR8*)Xsdt);
|
|
break;
|
|
}
|
|
}
|
|
DBG("PreCleanup XSDT, corrected XSDT: count=%d, length=%d\n", Count, (UINT32)Xsdt->Header.Length);
|
|
}
|
|
|
|
void PostCleanupXSDT()
|
|
{
|
|
UINT64 *Dest, *EndPtr, *Source;
|
|
if (!Xsdt) {
|
|
return;
|
|
}
|
|
|
|
// remove NULL entries from XSDT table
|
|
UINT32 Count = XsdtTableCount();
|
|
DBG("Cleanup XSDT: count=%d, length=%d\n", Count, (UINT32)Xsdt->Header.Length);
|
|
Source = XsdtEntryPtrFromIndex(0);
|
|
Dest = Source;
|
|
EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
while (Source < EndPtr) {
|
|
if (0 == *Source) {
|
|
// skip NULL entry
|
|
Source++;
|
|
continue;
|
|
}
|
|
WriteUnaligned64(Dest++, ReadUnaligned64(Source++));
|
|
}
|
|
// fix header length
|
|
Xsdt->Header.Length = (UINT32)((CHAR8*)Dest - (CHAR8*)Xsdt);
|
|
Count = XsdtTableCount();
|
|
DBG("corrected XSDT count=%d, length=%d\n", Count, (UINT32)Xsdt->Header.Length);
|
|
FixChecksum(&Xsdt->Header);
|
|
}
|
|
|
|
|
|
/** Saves Buffer of Length to disk as DirName\\FileName. */
|
|
EFI_STATUS SaveBufferToDisk(VOID *Buffer, UINTN Length, CONST CHAR16 *DirName, CONST CHAR16 *FileName)
|
|
{
|
|
if (DirName == NULL || FileName == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
FileName = PoolPrint(L"%s\\%s", DirName, FileName);
|
|
if (FileName == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
EFI_STATUS Status = egSaveFile(SelfRootDir, FileName, Buffer, Length);
|
|
if (EFI_ERROR(Status)) {
|
|
Status = egSaveFile(NULL, FileName, Buffer, Length);
|
|
}
|
|
FreePool(FileName);
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Remembering saved tables
|
|
//
|
|
#define SAVED_TABLES_ALLOC_ENTRIES 64
|
|
VOID **mSavedTables = NULL;
|
|
UINTN mSavedTablesEntries = 0;
|
|
UINTN mSavedTablesNum = 0;
|
|
|
|
/** Returns TRUE is TableEntry is already saved. */
|
|
BOOLEAN IsTableSaved(VOID *TableEntry)
|
|
{
|
|
UINTN Index;
|
|
|
|
if (mSavedTables != NULL) {
|
|
for (Index = 0; Index < mSavedTablesNum; Index++) {
|
|
if (mSavedTables[Index] == TableEntry) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/** Adds TableEntry to mSavedTables if not already there. */
|
|
VOID MarkTableAsSaved(VOID *TableEntry)
|
|
{
|
|
//
|
|
// If mSavedTables does not exists yet - allocate it
|
|
//
|
|
if (mSavedTables == NULL) {
|
|
//DBG(" Allocaing mSavedTables");
|
|
mSavedTablesEntries = SAVED_TABLES_ALLOC_ENTRIES;
|
|
mSavedTablesNum = 0;
|
|
mSavedTables = (__typeof__(mSavedTables))AllocateZeroPool(sizeof(*mSavedTables) * mSavedTablesEntries);
|
|
if (mSavedTables == NULL) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If TableEntry is not in mSavedTables - add it
|
|
//
|
|
//DBG(" MarkTableAsSaved %p", TableEntry);
|
|
if (IsTableSaved(TableEntry)) {
|
|
// already saved
|
|
//DBG(" - already saved\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// If mSavedTables is full - extend it
|
|
//
|
|
if (mSavedTablesNum + 1 >= mSavedTablesEntries) {
|
|
// not enough space
|
|
//DBG(" - extending mSavedTables from %d", mSavedTablesEntries);
|
|
mSavedTables = (__typeof__(mSavedTables))ReallocatePool(
|
|
sizeof(*mSavedTables) * mSavedTablesEntries,
|
|
sizeof(*mSavedTables) * (mSavedTablesEntries + SAVED_TABLES_ALLOC_ENTRIES),
|
|
mSavedTables
|
|
);
|
|
if (mSavedTables == NULL) {
|
|
return;
|
|
}
|
|
mSavedTablesEntries = mSavedTablesEntries + SAVED_TABLES_ALLOC_ENTRIES;
|
|
//DBG(" to %d", mSavedTablesEntries);
|
|
}
|
|
|
|
//
|
|
// Add TableEntry to mSavedTables
|
|
//
|
|
mSavedTables[mSavedTablesNum] = TableEntry;
|
|
//DBG(" - added to index %d\n", mSavedTablesNum);
|
|
mSavedTablesNum++;
|
|
}
|
|
|
|
#define AML_OP_NAME 0x08
|
|
#define AML_OP_PACKAGE 0x12
|
|
|
|
STATIC CHAR8 NameSSDT[] = {AML_OP_NAME, 'S', 'S', 'D', 'T', AML_OP_PACKAGE};
|
|
STATIC CHAR8 NameCSDT[] = {AML_OP_NAME, 'C', 'S', 'D', 'T', AML_OP_PACKAGE};
|
|
STATIC CHAR8 NameTSDT[] = {AML_OP_NAME, 'T', 'S', 'D', 'T', AML_OP_PACKAGE};
|
|
|
|
// OperationRegion (SSDT, SystemMemory, 0xDF5DAC18, 0x038C)
|
|
STATIC UINT8 NameSSDT2[] = {0x80, 0x53, 0x53, 0x44, 0x54};
|
|
// OperationRegion (CSDT, SystemMemory, 0xDF5DBE18, 0x84)
|
|
STATIC UINT8 NameCSDT2[] = {0x80, 0x43, 0x53, 0x44, 0x54};
|
|
|
|
//UINT32 get_size(UINT8 * An, UINT32 ); // Let borrow from FixBiosDsdt.
|
|
|
|
static CHAR16* GenerateFileName(CONST CHAR16* FileNamePrefix, UINTN SsdtCount, UINTN ChildCount, CHAR8 OemTableId[9])
|
|
// ChildCount == IGNORE_INDEX indicates normal SSDT
|
|
// SsdtCount == IGNORE_INDEX indicates dynamic SSDT in DSDT
|
|
// otherwise is child SSDT from normal SSDT
|
|
{
|
|
CHAR16* FileName;
|
|
CHAR8 Suffix[10]; // "-" + OemTableId + NUL
|
|
if (gSettings.NoOemTableId || 0 == OemTableId[0]) {
|
|
Suffix[0] = 0;
|
|
} else {
|
|
Suffix[0] = '-';
|
|
CopyMem(Suffix+1, OemTableId, 9);
|
|
}
|
|
if (IGNORE_INDEX == ChildCount) {
|
|
// normal SSDT
|
|
FileName = PoolPrint(L"%sSSDT-%d%a.aml", FileNamePrefix, SsdtCount, Suffix);
|
|
} else if (IGNORE_INDEX == SsdtCount) {
|
|
// dynamic SSDT in DSDT
|
|
FileName = PoolPrint(L"%sSSDT-xDSDT_%d%a.aml", FileNamePrefix, ChildCount, Suffix);
|
|
} else {
|
|
// dynamic SSDT in static SSDT
|
|
FileName = PoolPrint(L"%sSSDT-x%d_%d%a.aml", FileNamePrefix, SsdtCount, ChildCount, Suffix);
|
|
}
|
|
// caller must free PoolPrint return value with FreePool
|
|
return FileName;
|
|
}
|
|
|
|
VOID DumpChildSsdt(EFI_ACPI_DESCRIPTION_HEADER *TableEntry, CONST CHAR16 *DirName, CONST CHAR16 *FileNamePrefix, UINTN SsdtCount)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
INTN j, k, pacLen, pacCount;
|
|
CHAR16 *FileName;
|
|
CHAR8 Signature[5];
|
|
CHAR8 OemTableId[9];
|
|
UINTN adr, len;
|
|
UINT8 *Entry;
|
|
UINT8 *End;
|
|
UINT8 *pacBody;
|
|
INTN ChildCount = 0;
|
|
|
|
if (gSettings.NoDynamicExtract) {
|
|
return;
|
|
}
|
|
|
|
Entry = (UINT8*)TableEntry; //first entry is parent SSDT
|
|
End = Entry + TableEntry->Length;
|
|
while (Entry < End) {
|
|
|
|
if ((CompareMem(Entry, NameSSDT, sizeof (NameSSDT)) == 0) ||
|
|
(CompareMem(Entry, NameCSDT, sizeof (NameCSDT)) == 0) ||
|
|
(CompareMem(Entry, NameTSDT, sizeof (NameTSDT)) == 0)) {
|
|
pacLen = get_size(Entry, sizeof (NameSSDT));
|
|
|
|
pacBody = Entry + sizeof (NameSSDT) + (pacLen > 63 ? 2 : 1); // Our packages are not huge
|
|
pacCount = *pacBody++;
|
|
|
|
if (pacCount > 0 && pacCount % 3 == 0) {
|
|
pacCount /= 3;
|
|
DBG(" (Found hidden SSDT %d pcs)\n", pacCount);
|
|
|
|
while (pacCount-- > 0) {
|
|
// Skip text marker and addr type tag
|
|
pacBody += 1 + 8 + 1 + 1;
|
|
|
|
adr = ReadUnaligned32((UINT32*)(pacBody));
|
|
len = 0;
|
|
pacBody += 4;
|
|
|
|
if (*pacBody == AML_CHUNK_DWORD) {
|
|
len = ReadUnaligned32((UINT32*)(pacBody + 1));
|
|
pacBody += 5;
|
|
} else if (*pacBody == AML_CHUNK_WORD) {
|
|
len = ReadUnaligned16((UINT16*)(pacBody + 1));
|
|
pacBody += 3;
|
|
}
|
|
|
|
// Take Signature and OemId for printing
|
|
CopyMem(&Signature, &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Signature, 4);
|
|
Signature[4] = 0;
|
|
CopyMem(&OemTableId, &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->OemTableId, 8);
|
|
OemTableId[8] = 0;
|
|
stripTrailingSpaces(OemTableId);
|
|
DBG(" * %p: '%a', '%a', Rev: %d, Len: %d ", adr, Signature, OemTableId,
|
|
((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Revision, ((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Length);
|
|
for (k = 0; k < 16; k++) {
|
|
DBG("%02x ", ((UINT8*)adr)[k]);
|
|
}
|
|
if ((AsciiStrCmp(Signature, "SSDT") == 0) && (len < 0x20000) && DirName != NULL && !IsTableSaved((VOID*)adr)) {
|
|
FileName = GenerateFileName(FileNamePrefix, SsdtCount, ChildCount, OemTableId);
|
|
len = ((UINT16*)adr)[2];
|
|
DBG("Internal length = %d", len);
|
|
Status = SaveBufferToDisk((VOID*)adr, len, DirName, FileName);
|
|
if (!EFI_ERROR(Status)) {
|
|
DBG(" -> %s", FileName);
|
|
MarkTableAsSaved((VOID*)adr);
|
|
ChildCount++;
|
|
} else {
|
|
DBG(" -> %r", Status);
|
|
}
|
|
FreePool(FileName);
|
|
}
|
|
DBG("\n");
|
|
}
|
|
}
|
|
Entry += sizeof (NameSSDT) + pacLen;
|
|
} else if (CompareMem(Entry, NameSSDT2, 5) == 0 ||
|
|
CompareMem(Entry, NameCSDT2, 5) == 0) {
|
|
|
|
adr = ReadUnaligned32((UINT32*)(Entry + 7));
|
|
len = 0;
|
|
j = *(Entry + 11);
|
|
if (j == 0x0b) {
|
|
len = ReadUnaligned16((UINT16*)(Entry + 12));
|
|
} else if (j == 0x0a) {
|
|
len = *(Entry + 12);
|
|
} else {
|
|
//not a number so skip for security
|
|
Entry += 5;
|
|
continue;
|
|
}
|
|
|
|
if (len > 0) {
|
|
// Take Signature and OemId for printing
|
|
CopyMem(&Signature, &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Signature, 4);
|
|
Signature[4] = 0;
|
|
CopyMem(&OemTableId, &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->OemTableId, 8);
|
|
OemTableId[8] = 0;
|
|
stripTrailingSpaces(OemTableId);
|
|
DBG(" * %p: '%a', '%a', Rev: %d, Len: %d ", adr, Signature, OemTableId,
|
|
((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Revision, ((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Length);
|
|
for(k=0; k<16; k++){
|
|
DBG("%02x ", ((UINT8*)adr)[k]);
|
|
}
|
|
if ((AsciiStrCmp(Signature, "SSDT") == 0) && (len < 0x20000) && DirName != NULL && !IsTableSaved((VOID*)adr)) {
|
|
FileName = GenerateFileName(FileNamePrefix, SsdtCount, ChildCount, OemTableId);
|
|
Status = SaveBufferToDisk((VOID*)adr, len, DirName, FileName);
|
|
if (!EFI_ERROR(Status)) {
|
|
DBG(" -> %s", FileName);
|
|
MarkTableAsSaved((VOID*)adr);
|
|
ChildCount++;
|
|
} else {
|
|
DBG(" -> %r", Status);
|
|
}
|
|
FreePool(FileName);
|
|
}
|
|
DBG("\n");
|
|
}
|
|
Entry += 5;
|
|
} else {
|
|
Entry++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Saves Table to disk as DirName\\FileName (DirName != NULL)
|
|
* or just prints basic table data to log (DirName == NULL).
|
|
*/
|
|
EFI_STATUS DumpTable(EFI_ACPI_DESCRIPTION_HEADER *TableEntry, CONST CHAR8 *CheckSignature, CONST CHAR16 *DirName, CONST CHAR16 *FileName, CONST CHAR16 *FileNamePrefix, INTN *SsdtCount)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR8 Signature[5];
|
|
CHAR8 OemTableId[9];
|
|
BOOLEAN ReleaseFileName = FALSE;
|
|
|
|
// Take Signature and OemId for printing
|
|
CopyMem(&Signature, &TableEntry->Signature, 4);
|
|
Signature[4] = 0;
|
|
CopyMem(&OemTableId, &TableEntry->OemTableId, 8);
|
|
OemTableId[8] = 0;
|
|
stripTrailingSpaces(OemTableId);
|
|
|
|
DBG(" %p: '%a', '%a', Rev: %d, Len: %d", TableEntry, Signature, OemTableId, TableEntry->Revision, TableEntry->Length);
|
|
|
|
//
|
|
// Additional checks
|
|
//
|
|
if (CheckSignature != NULL && AsciiStrCmp(Signature, CheckSignature) != 0) {
|
|
DBG(" -> invalid signature, expecting %a\n", CheckSignature);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
// XSDT checks
|
|
if (TableEntry->Signature == EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (TableEntry->Length < sizeof(XSDT_TABLE)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
// RSDT checks
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (TableEntry->Length < sizeof(RSDT_TABLE)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
// FADT/FACP checks
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (TableEntry->Length < sizeof(EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
// DSDT checks
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (TableEntry->Length < sizeof(EFI_ACPI_DESCRIPTION_HEADER)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
// SSDT checks
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
if (TableEntry->Length < sizeof(EFI_ACPI_DESCRIPTION_HEADER)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
if (DirName == NULL || IsTableSaved(TableEntry)) {
|
|
// just debug log dump
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (FileNamePrefix == NULL) {
|
|
FileNamePrefix = L"";
|
|
}
|
|
|
|
if (FileName == NULL) {
|
|
// take the name from the signature
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE && SsdtCount != NULL) {
|
|
FileName = GenerateFileName(FileNamePrefix, *SsdtCount, IGNORE_INDEX, OemTableId);
|
|
} else {
|
|
FileName = PoolPrint(L"%s%a.aml", FileNamePrefix, Signature);
|
|
}
|
|
|
|
if (FileName == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
ReleaseFileName = TRUE;
|
|
}
|
|
DBG(" -> %s", FileName);
|
|
|
|
// Save it
|
|
Status = SaveBufferToDisk(TableEntry, TableEntry->Length, DirName, FileName);
|
|
MarkTableAsSaved(TableEntry);
|
|
|
|
if (TableEntry->Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE && SsdtCount != NULL) {
|
|
DumpChildSsdt(TableEntry, DirName, FileNamePrefix, *SsdtCount);
|
|
*SsdtCount += 1;
|
|
}
|
|
|
|
if (ReleaseFileName) {
|
|
FreePool(FileName);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/** Saves to disk (DirName != NULL) or prints to log (DirName == NULL) Fadt tables: Dsdt and Facs. */
|
|
EFI_STATUS DumpFadtTables(EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *Fadt, CONST CHAR16 *DirName, CONST CHAR16 *FileNamePrefix, INTN *SsdtCount)
|
|
{
|
|
EFI_ACPI_DESCRIPTION_HEADER *TableEntry;
|
|
EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *Facs;
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
UINT64 DsdtAdr;
|
|
UINT64 FacsAdr;
|
|
CHAR8 Signature[5];
|
|
CHAR16 *FileName;
|
|
|
|
//
|
|
// if Fadt->Revision < 3 (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION), then it is Acpi 1.0
|
|
// and fields after Flags are not available
|
|
//
|
|
DBG(" (Dsdt: %x, Facs: %x", Fadt->Dsdt, Fadt->FirmwareCtrl);
|
|
// for Acpi 1.0
|
|
DsdtAdr = Fadt->Dsdt;
|
|
FacsAdr = Fadt->FirmwareCtrl;
|
|
|
|
if (Fadt->Header.Revision >= EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION) {
|
|
// Acpi 2.0 or up
|
|
// may have it in XDsdt or XFirmwareCtrl
|
|
DBG(", XDsdt: %lx, XFacs: %lx", Fadt->XDsdt, Fadt->XFirmwareCtrl);
|
|
if (Fadt->XDsdt != 0) {
|
|
DsdtAdr = Fadt->XDsdt;
|
|
}
|
|
if (Fadt->XFirmwareCtrl != 0) {
|
|
FacsAdr = Fadt->XFirmwareCtrl;
|
|
}
|
|
}
|
|
DBG(")\n");
|
|
|
|
//
|
|
// Save Dsdt
|
|
//
|
|
if (DsdtAdr != 0) {
|
|
DBG(" ");
|
|
TableEntry = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)DsdtAdr;
|
|
Status = DumpTable(TableEntry, "DSDT", DirName, NULL, FileNamePrefix, NULL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return Status;
|
|
}
|
|
DBG("\n");
|
|
DumpChildSsdt(TableEntry, DirName, FileNamePrefix, IGNORE_INDEX);
|
|
}
|
|
//
|
|
// Save Facs
|
|
//
|
|
if (FacsAdr != 0) {
|
|
// Taking it as structure from Acpi 2.0 just to get Version (it's reserved field in Acpi 1.0 and == 0)
|
|
Facs = (EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE*)(UINTN)FacsAdr;
|
|
// Take Signature for printing
|
|
CopyMem(&Signature, &Facs->Signature, 4);
|
|
Signature[4] = 0;
|
|
DBG(" %p: '%a', Ver: %d, Len: %d", Facs, Signature, Facs->Version, Facs->Length);
|
|
|
|
// FACS checks
|
|
if (Facs->Signature != EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) {
|
|
DBG(" -> invalid signature, expecting FACS\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (Facs->Length < sizeof(EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE)) {
|
|
DBG(" -> invalid length\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (DirName != NULL && !IsTableSaved(Facs)) {
|
|
FileName = PoolPrint(L"%sFACS.aml", FileNamePrefix);
|
|
DBG(" -> %s", FileName);
|
|
Status = SaveBufferToDisk(Facs, Facs->Length, DirName, FileName);
|
|
MarkTableAsSaved(Facs);
|
|
FreePool(FileName);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return Status;
|
|
}
|
|
}
|
|
DBG("\n");
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE* GetFadt()
|
|
{
|
|
EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER *RsdPtr;
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer = NULL;
|
|
|
|
// EFI_STATUS Status;
|
|
|
|
RsdPtr = (__typeof__(RsdPtr))FindAcpiRsdPtr();
|
|
if (RsdPtr == NULL) {
|
|
/*Status = */EfiGetSystemConfigurationTable (&gEfiAcpi20TableGuid, (VOID **)&RsdPtr);
|
|
if (RsdPtr == NULL) {
|
|
/*Status = */EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **)&RsdPtr);
|
|
if (RsdPtr == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPtr->RsdtAddress);
|
|
if (RsdPtr->Revision > 0) {
|
|
if (Rsdt == NULL || Rsdt->Header.Signature != EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
Xsdt = (XSDT_TABLE *)(UINTN)(RsdPtr->XsdtAddress);
|
|
}
|
|
}
|
|
if (Rsdt == NULL && Xsdt == NULL) {
|
|
//
|
|
// Search Acpi 2.0 or newer in UEFI Sys.Tables
|
|
//
|
|
RsdPtr = NULL;
|
|
/*Status = */EfiGetSystemConfigurationTable (&gEfiAcpi20TableGuid, (VOID**)&RsdPtr);
|
|
if (RsdPtr != NULL) {
|
|
DBG("Found UEFI Acpi 2.0 RSDP at %p\n", RsdPtr);
|
|
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPtr->RsdtAddress);
|
|
if (RsdPtr->Revision > 0) {
|
|
if (Rsdt == NULL || Rsdt->Header.Signature != EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
Xsdt = (XSDT_TABLE *)(UINTN)(RsdPtr->XsdtAddress);
|
|
}
|
|
}
|
|
}
|
|
if (Rsdt == NULL && Xsdt == NULL) {
|
|
DBG("No RSDT or XSDT found!\n");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (Rsdt) {
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(Rsdt->Entry);
|
|
}
|
|
if (Xsdt) {
|
|
//overwrite previous find as xsdt priority
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(Xsdt->Entry);
|
|
}
|
|
return FadtPointer;
|
|
}
|
|
|
|
/** Saves to disk (DirName != NULL)
|
|
* or prints to debug log (DirName == NULL)
|
|
* ACPI tables given by RsdPtr.
|
|
* Takes tables from Xsdt if present or from Rsdt if Xsdt is not present.
|
|
*/
|
|
VOID DumpTables(VOID *RsdPtrVoid, CHAR16 *DirName)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Length;
|
|
INTN SsdtCount;
|
|
CONST CHAR16 *FileNamePrefix;
|
|
//
|
|
// RSDP
|
|
// Take it as Acpi 2.0, but take care that if RsdPtr->Revision == 0
|
|
// then it is actually Acpi 1.0 and fields after RsdtAddress (like XsdtAddress)
|
|
// are not available
|
|
//
|
|
EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER* RsdPtr = (EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER*)RsdPtrVoid;
|
|
if (DirName != NULL) {
|
|
DBG("Saving ACPI tables from RSDP %p to %s ...\n", RsdPtr, DirName);
|
|
} else {
|
|
DBG("Printing ACPI tables from RSDP %p ...\n", RsdPtr);
|
|
}
|
|
|
|
if (RsdPtr->Signature != EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE) {
|
|
DBG(" RsdPrt at %p has invaid signature 0x%lx - exiting.\n", RsdPtr, RsdPtr->Signature);
|
|
return;
|
|
}
|
|
|
|
// Take Signature for printing
|
|
CHAR8 Signature[9];
|
|
CopyMem(&Signature, &RsdPtr->Signature, 8);
|
|
Signature[8] = 0;
|
|
|
|
// Take Rsdt and Xsdt
|
|
Rsdt = NULL;
|
|
Xsdt = NULL;
|
|
|
|
DBG(" %p: '%a', Rev: %d", RsdPtr, Signature, RsdPtr->Revision);
|
|
if (RsdPtr->Revision == 0) {
|
|
// Acpi 1.0
|
|
Length = sizeof(EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
|
|
DBG(" (Acpi 1.0)");
|
|
} else {
|
|
// Acpi 2.0 or newer
|
|
Length = RsdPtr->Length;
|
|
DBG(" (Acpi 2.0 or newer)");
|
|
}
|
|
DBG(", Len: %d", Length);
|
|
|
|
//
|
|
// Save RsdPtr
|
|
//
|
|
if (DirName != NULL && !IsTableSaved(RsdPtr)) {
|
|
DBG(" -> RSDP.aml");
|
|
Status = SaveBufferToDisk(RsdPtr, Length, DirName, L"RSDP.aml");
|
|
MarkTableAsSaved(RsdPtr);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return;
|
|
}
|
|
}
|
|
DBG("\n");
|
|
|
|
if (RsdPtr->Revision == 0) {
|
|
// Acpi 1.0 - no Xsdt
|
|
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPtr->RsdtAddress);
|
|
DBG(" (Rsdt: %p)\n", Rsdt);
|
|
} else {
|
|
// Acpi 2.0 or newer - may have Xsdt and/or Rsdt
|
|
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPtr->RsdtAddress);
|
|
Xsdt = (XSDT_TABLE *)(UINTN)(RsdPtr->XsdtAddress);
|
|
DBG(" (Xsdt: %p, Rsdt: %p)\n", Xsdt, Rsdt);
|
|
}
|
|
|
|
if (Rsdt == NULL && Xsdt == NULL) {
|
|
DBG(" No Rsdt and Xsdt - exiting.\n");
|
|
return;
|
|
}
|
|
|
|
FileNamePrefix = L"";
|
|
//
|
|
// Save Xsdt
|
|
//
|
|
if (Xsdt != NULL) {
|
|
DBG(" ");
|
|
Status = DumpTable((EFI_ACPI_DESCRIPTION_HEADER *)Xsdt, "XSDT", DirName, L"XSDT.aml", FileNamePrefix, NULL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r", Status);
|
|
Xsdt = NULL;
|
|
}
|
|
DBG("\n");
|
|
}
|
|
//
|
|
// Save Rsdt
|
|
//
|
|
if (Rsdt != NULL) {
|
|
DBG(" ");
|
|
Status = DumpTable((EFI_ACPI_DESCRIPTION_HEADER *)Rsdt, "RSDT", DirName, L"RSDT.aml", FileNamePrefix, NULL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r", Status);
|
|
Rsdt = NULL;
|
|
}
|
|
DBG("\n");
|
|
}
|
|
//
|
|
// Check once more since they might be invalid
|
|
//
|
|
if (Rsdt == NULL && Xsdt == NULL) {
|
|
DBG(" No Rsdt and Xsdt - exiting.\n");
|
|
return;
|
|
}
|
|
if (Xsdt) {
|
|
UINT64 *Ptr, *EndPtr;
|
|
UINT32 Count = XsdtTableCount();
|
|
DBG(" Tables in Xsdt: %d\n", Count);
|
|
if (Count > 100) Count = 100; //it's enough
|
|
|
|
Ptr = XsdtEntryPtrFromIndex(0);
|
|
EndPtr = XsdtEntryPtrFromIndex(Count);
|
|
SsdtCount = 0;
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
DBG(" %d.", IndexFromXsdtEntryPtr(Ptr));
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)ReadUnaligned64(Ptr);
|
|
if (!Table) {
|
|
DBG(" = 0\n");
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
if (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE == Table->Signature) {
|
|
// Fadt - save Dsdt and Facs
|
|
Status = DumpTable(Table, NULL, DirName, NULL, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return;
|
|
}
|
|
DBG("\n");
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE* Fadt = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)Table;
|
|
Status = DumpFadtTables(Fadt, DirName, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
return;
|
|
}
|
|
} else {
|
|
Status = DumpTable(Table, NULL, DirName, NULL, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return;
|
|
}
|
|
DBG("\n");
|
|
}
|
|
}
|
|
} // if Xsdt
|
|
|
|
if (Rsdt) {
|
|
UINT32 *Ptr, *EndPtr;
|
|
// additional Rsdt tables which are not present in Xsdt will have "RSDT-" prefix, like RSDT-FACS.aml
|
|
FileNamePrefix = L"RSDT-";
|
|
// Take tables from Rsdt
|
|
// if saved from Xsdt already, then just print debug
|
|
UINT32 Count = RsdtTableCount();
|
|
DBG(" Tables in Rsdt: %d\n", Count);
|
|
if (Count > 100) Count = 100; //it's enough
|
|
Ptr = RsdtEntryPtrFromIndex(0);
|
|
EndPtr = RsdtEntryPtrFromIndex(Count);
|
|
for (; Ptr < EndPtr; Ptr++) {
|
|
DBG(" %d.", IndexFromRsdtEntryPtr(Ptr));
|
|
EFI_ACPI_DESCRIPTION_HEADER* Table = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)*Ptr;
|
|
if (!Table) {
|
|
DBG(" = 0\n");
|
|
// skip NULL entry
|
|
continue;
|
|
}
|
|
if (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE == Table->Signature) {
|
|
// Fadt - save Dsdt and Facs
|
|
Status = DumpTable(Table, NULL, DirName, NULL, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return;
|
|
}
|
|
DBG("\n");
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE* Fadt = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)Table;
|
|
Status = DumpFadtTables(Fadt, DirName, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
return;
|
|
}
|
|
} else {
|
|
Status = DumpTable(Table, NULL, DirName, NULL, FileNamePrefix, &SsdtCount);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG(" - %r\n", Status);
|
|
return;
|
|
}
|
|
DBG("\n");
|
|
}
|
|
}
|
|
} // if Rsdt
|
|
}
|
|
|
|
/** Saves OEM ACPI tables to disk.
|
|
* Searches BIOS, then UEFI Sys.Tables for Acpi 2.0 or newer tables, then for Acpi 1.0 tables
|
|
* CloverEFI:
|
|
* - saves first one found, dump others to log
|
|
* UEFI:
|
|
* - saves first one found in UEFI Sys.Tables, dump others to log
|
|
*
|
|
* Dumping of other tables to log can be removed if it turns out that there is no value in doing it.
|
|
*/
|
|
VOID SaveOemTables()
|
|
{
|
|
EFI_STATUS Status;
|
|
VOID *RsdPtr;
|
|
CHAR16 *AcpiOriginPath = PoolPrint(L"%s\\ACPI\\origin", OEMPath);
|
|
BOOLEAN Saved = FALSE;
|
|
CHAR8 *MemLogStart;
|
|
UINTN MemLogStartLen;
|
|
|
|
MemLogStartLen = GetMemLogLen();
|
|
MemLogStart = GetMemLogBuffer() + MemLogStartLen;
|
|
//
|
|
// Search in BIOS
|
|
// CloverEFI - Save
|
|
// UEFI - just print to log
|
|
//
|
|
// RsdPtr = NULL;
|
|
RsdPtr = FindAcpiRsdPtr();
|
|
if (RsdPtr != NULL) {
|
|
DBG("Found BIOS RSDP at %p\n", RsdPtr);
|
|
if (gFirmwareClover) {
|
|
// Save it
|
|
DumpTables(RsdPtr, AcpiOriginPath);
|
|
Saved = TRUE;
|
|
} else {
|
|
// just print to log
|
|
DumpTables(RsdPtr, NULL);
|
|
}
|
|
}
|
|
//
|
|
// Search Acpi 2.0 or newer in UEFI Sys.Tables
|
|
//
|
|
RsdPtr = NULL;
|
|
Status = EfiGetSystemConfigurationTable (&gEfiAcpi20TableGuid, &RsdPtr);
|
|
if (RsdPtr != NULL) {
|
|
DBG("Found UEFI Acpi 2.0 RSDP at %p\n", RsdPtr);
|
|
// if tables already saved, then just print to log
|
|
DumpTables(RsdPtr, Saved ? NULL : AcpiOriginPath);
|
|
Saved = TRUE;
|
|
}
|
|
//
|
|
// Then search Acpi 1.0 UEFI Sys.Tables
|
|
//
|
|
RsdPtr = NULL;
|
|
/*Status = */EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, &RsdPtr);
|
|
if (RsdPtr != NULL) {
|
|
DBG("Found UEFI Acpi 1.0 RSDP at %p\n", RsdPtr);
|
|
// if tables already saved, then just print to log
|
|
DumpTables(RsdPtr, Saved ? NULL : AcpiOriginPath);
|
|
// Saved = TRUE;
|
|
}
|
|
SaveBufferToDisk(MemLogStart, GetMemLogLen() - MemLogStartLen, AcpiOriginPath, L"DumpLog.txt");
|
|
FreePool(mSavedTables);
|
|
FreePool(AcpiOriginPath);
|
|
}
|
|
|
|
VOID SaveOemDsdt(BOOLEAN FullPatch)
|
|
{
|
|
EFI_STATUS Status = EFI_NOT_FOUND;
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer = NULL;
|
|
EFI_PHYSICAL_ADDRESS dsdt = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
|
|
UINTN Pages;
|
|
UINT8 *buffer = NULL;
|
|
UINTN DsdtLen = 0;
|
|
CHAR16* OriginDsdt = PoolPrint(L"%s\\ACPI\\origin\\DSDT.aml", OEMPath);
|
|
CHAR16* OriginDsdtFixed = PoolPrint(L"%s\\ACPI\\origin\\DSDT-%x.aml", OEMPath, gSettings.FixDsdt);
|
|
CONST CHAR16* PathPatched = L"\\EFI\\CLOVER\\ACPI\\patched";
|
|
CHAR16* PathDsdt; // = L"\\DSDT.aml";
|
|
CHAR16* AcpiOemPath = PoolPrint(L"%s\\ACPI\\patched", OEMPath);
|
|
|
|
PathDsdt = PoolPrint(L"\\%s", gSettings.DsdtName);
|
|
|
|
if (FileExists(SelfRootDir, PoolPrint(L"%s%s", AcpiOemPath, PathDsdt))) {
|
|
DBG("DSDT found in Clover volume OEM folder: %s%s\n", AcpiOemPath, PathDsdt);
|
|
Status = egLoadFile(SelfRootDir, PoolPrint(L"%s%s", AcpiOemPath, PathDsdt), &buffer, &DsdtLen);
|
|
//REVIEW: memory leak...buffer
|
|
}
|
|
|
|
if (EFI_ERROR(Status) && FileExists(SelfRootDir, PoolPrint(L"%s%s", PathPatched, PathDsdt))) {
|
|
DBG("DSDT found in Clover volume common folder: %s%s\n", PathPatched, PathDsdt);
|
|
Status = egLoadFile(SelfRootDir, PoolPrint(L"%s%s", PathPatched, PathDsdt), &buffer, &DsdtLen);
|
|
//REVIEW: memory leak...buffer
|
|
}
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
FadtPointer = GetFadt();
|
|
if (FadtPointer == NULL) {
|
|
DBG("Cannot found FADT in BIOS or in UEFI!\n"); //really?!
|
|
return;
|
|
}
|
|
BiosDsdt = FadtPointer->Dsdt;
|
|
if (FadtPointer->Header.Revision >= EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION &&
|
|
FadtPointer->XDsdt != 0) {
|
|
BiosDsdt = FadtPointer->XDsdt;
|
|
}
|
|
buffer = (UINT8*)(UINTN)BiosDsdt;
|
|
}
|
|
|
|
if (!buffer) {
|
|
DBG("Cannot found DSDT in BIOS or in files!\n");
|
|
return;
|
|
}
|
|
|
|
DsdtLen = ((EFI_ACPI_DESCRIPTION_HEADER*)buffer)->Length;
|
|
Pages = EFI_SIZE_TO_PAGES(DsdtLen + DsdtLen / 8); // take some extra space for patches
|
|
Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiBootServicesData,
|
|
Pages,
|
|
&dsdt
|
|
);
|
|
//if success insert dsdt pointer into ACPI tables
|
|
if(!EFI_ERROR(Status))
|
|
{
|
|
CopyMem((VOID*)(UINTN)dsdt, buffer, DsdtLen);
|
|
buffer = (UINT8*)(UINTN)dsdt;
|
|
if (FullPatch) {
|
|
FixBiosDsdt(buffer, FadtPointer, NULL);
|
|
DsdtLen = ((EFI_ACPI_DESCRIPTION_HEADER*)buffer)->Length;
|
|
FreePool(OriginDsdt); //avoid memory leak
|
|
OriginDsdt = OriginDsdtFixed;
|
|
OriginDsdtFixed = NULL; //to not free twice
|
|
}
|
|
Status = egSaveFile(SelfRootDir, OriginDsdt, buffer, DsdtLen);
|
|
if (EFI_ERROR(Status)) {
|
|
Status = egSaveFile(NULL, OriginDsdt, buffer, DsdtLen);
|
|
}
|
|
if (!EFI_ERROR(Status)) {
|
|
MsgLog("DSDT saved to %s\n", OriginDsdt);
|
|
} else {
|
|
MsgLog("Saving DSDT to % s failed - %r\n", OriginDsdt, Status);
|
|
}
|
|
gBS->FreePages(dsdt, Pages);
|
|
}
|
|
FreePool(OriginDsdt);
|
|
if (OriginDsdtFixed) FreePool(OriginDsdtFixed);
|
|
FreePool(AcpiOemPath);
|
|
}
|
|
|
|
BOOLEAN LoadPatchedAML(CHAR16* AcpiOemPath, CHAR16* PartName, UINTN Pass)
|
|
{
|
|
CHAR16 FullName[256];
|
|
// pass1 prefilter based on file names (optimization that avoids loading same files twice)
|
|
UINTN Index = IGNORE_INDEX;
|
|
if (AUTOMERGE_PASS1 == Pass) {
|
|
Index = IndexFromFileName(PartName);
|
|
// gSettings.AutoMerge always true in this case
|
|
// file names such as: ECDT.aml, SSDT-0.aml, SSDT-1-CpuPm.aml, attempt merge on pass1
|
|
// others: no attempt for merge
|
|
// special case for SSDT.aml: no attempt to merge
|
|
if (0 == StriCmp(PartName, L"SSDT.aml") || (8 != StrLen(PartName) && IGNORE_INDEX == Index)) {
|
|
DBG("ignore on pass 1\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
UnicodeSPrint(FullName, sizeof(FullName), L"%s\\%s", AcpiOemPath, PartName);
|
|
UINT8 *buffer = NULL;
|
|
UINTN bufferLen = 0;
|
|
EFI_STATUS Status = egLoadFile(SelfRootDir, FullName, &buffer, &bufferLen);
|
|
if (!EFI_ERROR(Status)) {
|
|
if (buffer) {
|
|
EFI_ACPI_DESCRIPTION_HEADER* TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)buffer;
|
|
if (TableHeader->Length > 500 * kilo) {
|
|
DBG("wrong table\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
DBG("size=%lld ", (UINT64)bufferLen);
|
|
if (!gSettings.AutoMerge) {
|
|
// Note: with AutoMerge=false, Pass is only AUTOMERGE_PASS2 here
|
|
Status = InsertTable(buffer, bufferLen);
|
|
} else {
|
|
Status = ReplaceOrInsertTable(buffer, bufferLen, Index, Pass);
|
|
}
|
|
FreePool(buffer);
|
|
}
|
|
DBG("... %r\n", Status);
|
|
return !EFI_ERROR(Status);
|
|
}
|
|
|
|
#define BVALUE_ATTEMPTED 2 // special value for MenuItem.BValue to avoid excessive log output
|
|
|
|
void LoadAllPatchedAML(CHAR16* AcpiOemPath, UINTN Pass)
|
|
{
|
|
if (!gSettings.AutoMerge && AUTOMERGE_PASS1 == Pass) {
|
|
// nothing to do in this case, since AutoMerge=false -> no tables ever merged
|
|
return;
|
|
}
|
|
if (ACPIPatchedAML) {
|
|
DbgHeader("ACPIPatchedAML");
|
|
if (gSettings.AutoMerge) {
|
|
DBG("AutoMerge pass %d\n", Pass);
|
|
}
|
|
//DBG("Start: Processing Patched AML(s): ");
|
|
if (gSettings.SortedACPICount) {
|
|
UINTN Index;
|
|
DBG("Sorted\n");
|
|
for (Index = 0; Index < gSettings.SortedACPICount; Index++) {
|
|
ACPI_PATCHED_AML *ACPIPatchedAMLTmp;
|
|
for (ACPIPatchedAMLTmp = ACPIPatchedAML; ACPIPatchedAMLTmp; ACPIPatchedAMLTmp = ACPIPatchedAMLTmp->Next) {
|
|
if (0 == StriCmp(ACPIPatchedAMLTmp->FileName, gSettings.SortedACPI[Index]) && ACPIPatchedAMLTmp->MenuItem.BValue) {
|
|
if (BVALUE_ATTEMPTED != ACPIPatchedAMLTmp->MenuItem.BValue)
|
|
DBG("Disabled: %s, skip\n", ACPIPatchedAMLTmp->FileName);
|
|
ACPIPatchedAMLTmp->MenuItem.BValue = BVALUE_ATTEMPTED;
|
|
break;
|
|
}
|
|
}
|
|
if (!ACPIPatchedAMLTmp) { // NULL when not disabled
|
|
DBG("Inserting table[%d]:%s from %s: ", Index, gSettings.SortedACPI[Index], AcpiOemPath);
|
|
if (LoadPatchedAML(AcpiOemPath, gSettings.SortedACPI[Index], Pass)) {
|
|
// avoid inserting table again on second pass
|
|
for (ACPI_PATCHED_AML* temp2 = ACPIPatchedAML; temp2; temp2 = temp2->Next) {
|
|
if (0 == StriCmp(temp2->FileName, gSettings.SortedACPI[Index])) {
|
|
temp2->MenuItem.BValue = BVALUE_ATTEMPTED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
ACPI_PATCHED_AML *ACPIPatchedAMLTmp;
|
|
DBG("Unsorted\n");
|
|
for (ACPIPatchedAMLTmp = ACPIPatchedAML; ACPIPatchedAMLTmp; ACPIPatchedAMLTmp = ACPIPatchedAMLTmp->Next) {
|
|
if (!ACPIPatchedAMLTmp->MenuItem.BValue) {
|
|
DBG("Inserting %s from %s: ", ACPIPatchedAMLTmp->FileName, AcpiOemPath);
|
|
if (LoadPatchedAML(AcpiOemPath, ACPIPatchedAMLTmp->FileName, Pass)) {
|
|
// avoid inserting table again on second pass
|
|
ACPIPatchedAMLTmp->MenuItem.BValue = BVALUE_ATTEMPTED;
|
|
}
|
|
} else {
|
|
if (BVALUE_ATTEMPTED != ACPIPatchedAMLTmp->MenuItem.BValue)
|
|
DBG("Disabled: %s, skip\n", ACPIPatchedAMLTmp->FileName);
|
|
ACPIPatchedAMLTmp->MenuItem.BValue = BVALUE_ATTEMPTED;
|
|
}
|
|
}
|
|
}
|
|
//DBG("End: Processing Patched AML(s)\n");
|
|
}
|
|
}
|
|
|
|
EFI_STATUS PatchACPI(IN REFIT_VOLUME *Volume, CHAR8 *OSVersion)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
UINTN Index;
|
|
EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER *RsdPointer = NULL;
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer = NULL;
|
|
EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE *newFadt = NULL;
|
|
// EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER *Hpet = NULL;
|
|
EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *Facs = NULL;
|
|
EFI_PHYSICAL_ADDRESS dsdt = EFI_SYSTEM_TABLE_MAX_ADDRESS; //0xFE000000;
|
|
EFI_PHYSICAL_ADDRESS BufferPtr;
|
|
SSDT_TABLE *Ssdt = NULL;
|
|
UINT8 *buffer = NULL;
|
|
UINTN bufferLen = 0;
|
|
CONST CHAR16* PathPatched = L"\\EFI\\CLOVER\\ACPI\\patched";
|
|
CHAR16* PathDsdt; // = L"\\DSDT.aml";
|
|
// CHAR16* PatchedAPIC = L"\\EFI\\CLOVER\\ACPI\\origin\\APIC-p.aml";
|
|
UINT32* rf = NULL;
|
|
UINT64* xf = NULL;
|
|
UINT64 XDsdt; //save values if present
|
|
UINT64 XFirmwareCtrl;
|
|
EFI_FILE *RootDir;
|
|
UINT32 eCntR; //, eCntX;
|
|
UINT32 *pEntryR;
|
|
CHAR8 *pEntry;
|
|
EFI_ACPI_DESCRIPTION_HEADER *TableHeader;
|
|
// -===== APIC =====-
|
|
EFI_ACPI_DESCRIPTION_HEADER *ApicTable;
|
|
// EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *ApicHeader;
|
|
EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE *ProcLocalApic;
|
|
EFI_ACPI_2_0_LOCAL_APIC_NMI_STRUCTURE *LocalApicNMI;
|
|
// UINTN ApicLen;
|
|
UINTN ApicCPUNum;
|
|
UINT8 *SubTable;
|
|
BOOLEAN DsdtLoaded = FALSE;
|
|
BOOLEAN NeedUpdate = FALSE;
|
|
OPER_REGION *tmpRegion;
|
|
CHAR16* AcpiOemPath = PoolPrint(L"%s\\ACPI\\patched", OEMPath);
|
|
|
|
DbgHeader("PatchACPI");
|
|
|
|
PathDsdt = PoolPrint(L"\\%s", gSettings.DsdtName);
|
|
//try to find in SystemTable
|
|
for(Index = 0; Index < gST->NumberOfTableEntries; Index++) {
|
|
if(CompareGuid (&gST->ConfigurationTable[Index].VendorGuid, &gEfiAcpi20TableGuid)) {
|
|
// Acpi 2.0
|
|
RsdPointer = (EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER*)gST->ConfigurationTable[Index].VendorTable;
|
|
break;
|
|
}
|
|
else if(CompareGuid (&gST->ConfigurationTable[Index].VendorGuid, &gEfiAcpi10TableGuid)) {
|
|
// Acpi 1.0 - RSDT only
|
|
RsdPointer = (EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER*)gST->ConfigurationTable[Index].VendorTable;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (!RsdPointer) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
Rsdt = (RSDT_TABLE*)(UINTN)RsdPointer->RsdtAddress;
|
|
// DBG("RSDT 0x%p\n", Rsdt);
|
|
rf = ScanRSDT(EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE, 0);
|
|
if(rf) {
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(*rf);
|
|
// DBG("FADT from RSDT: 0x%p\n", FadtPointer);
|
|
}
|
|
|
|
Xsdt = NULL;
|
|
if (RsdPointer->Revision >=2 && (RsdPointer->XsdtAddress < (UINT64)(UINTN)-1)) {
|
|
Xsdt = (XSDT_TABLE*)(UINTN)RsdPointer->XsdtAddress;
|
|
// DBG("XSDT 0x%p\n", Xsdt);
|
|
xf = ScanXSDT(EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE, 0);
|
|
if(xf) {
|
|
//Slice - change priority. First Xsdt, second Rsdt
|
|
if (*xf) {
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(*xf);
|
|
// DBG("FADT from XSDT: 0x%p\n", FadtPointer);
|
|
} else {
|
|
*xf = (UINT64)(UINTN)FadtPointer;
|
|
// DBG("reuse FADT\n"); //never happens
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!xf && Rsdt) {
|
|
DBG("Xsdt is not found! Creating new one\n");
|
|
//We should make here ACPI20 RSDP with all needed subtables based on ACPI10
|
|
BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status = gBS->AllocatePages(AllocateMaxAddress, EfiACPIReclaimMemory, 1, &BufferPtr);
|
|
if(!EFI_ERROR(Status)) {
|
|
if (RsdPointer->Revision == 0) {
|
|
// Acpi 1.0 RsdPtr, but we need Acpi 2.0
|
|
EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER *NewRsdPointer;
|
|
DBG("RsdPointer is Acpi 1.0 - creating new one Acpi 2.0\n");
|
|
|
|
// add new pointer to the beginning of a new buffer
|
|
NewRsdPointer = (EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER*)(UINTN)BufferPtr;
|
|
|
|
// and Xsdt will come after it
|
|
BufferPtr += 0x30;
|
|
// DBG("::pointers %p %p\n", NewRsdPointer, RsdPointer);
|
|
// Signature, Checksum, OemId, Reserved/Revision, RsdtAddress
|
|
CopyMem(NewRsdPointer, RsdPointer, sizeof(EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER));
|
|
NewRsdPointer->Revision = 2;
|
|
NewRsdPointer->Length = sizeof(EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER);
|
|
RsdPointer = NewRsdPointer;
|
|
NeedUpdate = TRUE;
|
|
// gBS->InstallConfigurationTable(&gEfiAcpiTableGuid, RsdPointer);
|
|
// DBG("first install success\n");
|
|
// gBS->InstallConfigurationTable(&gEfiAcpi10TableGuid, RsdPointer);
|
|
DBG("RsdPointer Acpi 2.0 installed\n");
|
|
}
|
|
Xsdt = (XSDT_TABLE*)(UINTN)BufferPtr;
|
|
// Print(L"XSDT = 0x%x\n\r", Xsdt);
|
|
Xsdt->Header.Signature = 0x54445358; //EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE
|
|
eCntR = (Rsdt->Header.Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof(UINT32);
|
|
Xsdt->Header.Length = eCntR * sizeof(UINT64) + sizeof (EFI_ACPI_DESCRIPTION_HEADER);
|
|
Xsdt->Header.Revision = 1;
|
|
CopyMem(&Xsdt->Header.OemId, &FadtPointer->Header.OemId, 6);
|
|
// Xsdt->Header.OemTableId = Rsdt->Header.OemTableId;
|
|
CopyMem(&Xsdt->Header.OemTableId, &Rsdt->Header.OemTableId, 8);
|
|
Xsdt->Header.OemRevision = Rsdt->Header.OemRevision;
|
|
Xsdt->Header.CreatorId = Rsdt->Header.CreatorId;
|
|
Xsdt->Header.CreatorRevision = Rsdt->Header.CreatorRevision;
|
|
pEntryR = (UINT32*)(&(Rsdt->Entry));
|
|
pEntry = (CHAR8*)(&(Xsdt->Entry));
|
|
DBG("RSDT entries = %d\n", eCntR);
|
|
for (Index = 0; Index < eCntR; Index ++)
|
|
{
|
|
UINT64 *pEntryX = (UINT64 *)pEntry;
|
|
// DBG("RSDT entry = 0x%x\n", *pEntryR);
|
|
if (*pEntryR != 0) {
|
|
*pEntryX = 0;
|
|
CopyMem (pEntryX, pEntryR, sizeof(UINT32));
|
|
pEntryR++;
|
|
pEntry += sizeof(UINT64);
|
|
} else {
|
|
DBG("RSDT entry %d = 0 ... skip it\n", Index);
|
|
Xsdt->Header.Length -= sizeof(UINT64);
|
|
pEntryR++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Xsdt) {
|
|
//Now we need no more Rsdt
|
|
Rsdt = NULL;
|
|
RsdPointer->RsdtAddress = 0;
|
|
//and we want to reallocate Xsdt
|
|
BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status = gBS->AllocatePages(AllocateMaxAddress, EfiACPIReclaimMemory, 1, &BufferPtr);
|
|
if(!EFI_ERROR(Status))
|
|
{
|
|
CopyMem((VOID*)(UINTN)BufferPtr, Xsdt, Xsdt->Header.Length);
|
|
Xsdt = (XSDT_TABLE*)(UINTN)BufferPtr;
|
|
}
|
|
// DBG("Finishing RsdPointer\n");
|
|
RsdPointer->XsdtAddress = (UINT64)(UINTN)Xsdt;
|
|
RsdPointer->Checksum = 0;
|
|
RsdPointer->Checksum = (UINT8)(256-Checksum8((CHAR8*)RsdPointer, 20));
|
|
RsdPointer->ExtendedChecksum = 0;
|
|
RsdPointer->ExtendedChecksum = (UINT8)(256-Checksum8((CHAR8*)RsdPointer, RsdPointer->Length));
|
|
DBG("Xsdt reallocation done\n");
|
|
}
|
|
// DBG("FADT pointer = %x\n", (UINTN)FadtPointer);
|
|
if(!FadtPointer) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
//Slice - then we do FADT patch no matter if we don't have DSDT.aml
|
|
BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status = gBS->AllocatePages(AllocateMaxAddress, EfiACPIReclaimMemory, 1, &BufferPtr);
|
|
if(!EFI_ERROR(Status))
|
|
{
|
|
UINT32 oldLength = ((EFI_ACPI_DESCRIPTION_HEADER*)FadtPointer)->Length;
|
|
newFadt = (EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)BufferPtr;
|
|
DBG("old FADT length=%x\n", oldLength);
|
|
CopyMem(newFadt, FadtPointer, oldLength); //old data
|
|
newFadt->Header.Length = 0xF4;
|
|
CopyMem(newFadt->Header.OemId, BiosVendor, 6);
|
|
if (newFadt->Header.Revision < EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION) {
|
|
newFadt->Header.Revision = EFI_ACPI_4_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION;
|
|
}
|
|
newFadt->Reserved0 = 0; //ACPIspec said it should be 0, while 1 is possible, but no more
|
|
|
|
//should correct headers if needed and if asked
|
|
PatchTableHeader((EFI_ACPI_DESCRIPTION_HEADER*)newFadt);
|
|
|
|
if (gSettings.smartUPS==TRUE) {
|
|
newFadt->PreferredPmProfile = 3;
|
|
} else {
|
|
newFadt->PreferredPmProfile = gMobile?2:1; //as calculated before
|
|
}
|
|
if (gSettings.EnableC6 || gSettings.EnableISS) {
|
|
newFadt->CstCnt = 0x85; //as in Mac
|
|
}
|
|
if (gSettings.EnableC2) newFadt->PLvl2Lat = 0x65;
|
|
if (gSettings.C3Latency > 0) {
|
|
newFadt->PLvl3Lat = gSettings.C3Latency;
|
|
} else if (gSettings.EnableC4) {
|
|
newFadt->PLvl3Lat = 0x3E9;
|
|
}
|
|
if (gSettings.C3Latency == 0) {
|
|
gSettings.C3Latency = newFadt->PLvl3Lat;
|
|
}
|
|
|
|
newFadt->IaPcBootArch = 0x3;
|
|
if (gSettings.NoASPM) {
|
|
newFadt->IaPcBootArch |= 0x10; // disable ASPM
|
|
}
|
|
newFadt->Flags |= 0x420; //Reset Register Supported and SleepButton active
|
|
newFadt->Flags &= ~0x10010; //RTC_STS not valid and PowerButton disable
|
|
XDsdt = newFadt->XDsdt; //save values if present
|
|
XFirmwareCtrl = newFadt->XFirmwareCtrl;
|
|
CopyMem(&newFadt->ResetReg, pmBlock, 0x80);
|
|
//but these common values are not specific, so adjust
|
|
//ACPIspec said that if Xdsdt !=0 then Dsdt must be =0. But real Mac no! Both values present
|
|
if (BiosDsdt) {
|
|
newFadt->XDsdt = BiosDsdt;
|
|
newFadt->Dsdt = (UINT32)BiosDsdt;
|
|
} else if (newFadt->Dsdt) {
|
|
newFadt->XDsdt = (UINT64)(newFadt->Dsdt);
|
|
} else if (XDsdt) {
|
|
newFadt->Dsdt = (UINT32)XDsdt;
|
|
}
|
|
if (newFadt->FirmwareCtrl) {
|
|
Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE*)(UINTN)newFadt->FirmwareCtrl;
|
|
newFadt->XFirmwareCtrl = (UINT64)(UINTN)(Facs);
|
|
} else if (newFadt->XFirmwareCtrl) {
|
|
newFadt->FirmwareCtrl = (UINT32)XFirmwareCtrl;
|
|
Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE*)(UINTN)XFirmwareCtrl;
|
|
}
|
|
|
|
//patch for FACS included here
|
|
Facs->Version = EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION;
|
|
if (GlobalConfig.SignatureFixup) {
|
|
DBG(" SignatureFixup: 0x%x -> 0x%x\n", Facs->HardwareSignature, machineSignature);
|
|
Facs->HardwareSignature = (UINT32)machineSignature;
|
|
} else {
|
|
DBG(" SignatureFixup: 0x%x -> 0x0\n", Facs->HardwareSignature);
|
|
Facs->HardwareSignature = 0x0;
|
|
}
|
|
Facs->Flags = 0; //dont' support S4BIOS, as well as 64bit wake
|
|
//
|
|
|
|
if ((gSettings.ResetAddr == 0) && ((oldLength < 0x80) || (newFadt->ResetReg.Address == 0))) {
|
|
newFadt->ResetReg.Address = 0x64;
|
|
newFadt->ResetValue = 0xFE;
|
|
gSettings.ResetAddr = 0x64;
|
|
gSettings.ResetVal = 0xFE;
|
|
} else if (gSettings.ResetAddr != 0) {
|
|
newFadt->ResetReg.Address = gSettings.ResetAddr;
|
|
newFadt->ResetValue = gSettings.ResetVal;
|
|
}
|
|
newFadt->XPm1aEvtBlk.Address = (UINT64)(newFadt->Pm1aEvtBlk);
|
|
newFadt->XPm1bEvtBlk.Address = (UINT64)(newFadt->Pm1bEvtBlk);
|
|
newFadt->XPm1aCntBlk.Address = (UINT64)(newFadt->Pm1aCntBlk);
|
|
newFadt->XPm1bCntBlk.Address = (UINT64)(newFadt->Pm1bCntBlk);
|
|
newFadt->XPm2CntBlk.Address = (UINT64)(newFadt->Pm2CntBlk);
|
|
newFadt->XPmTmrBlk.Address = (UINT64)(newFadt->PmTmrBlk);
|
|
newFadt->XGpe0Blk.Address = (UINT64)(newFadt->Gpe0Blk);
|
|
newFadt->XGpe1Blk.Address = (UINT64)(newFadt->Gpe1Blk);
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)newFadt;
|
|
//We are sure that Fadt is the first entry in RSDT/XSDT table
|
|
if (Rsdt!=NULL) {
|
|
Rsdt->Entry = (UINT32)(UINTN)newFadt;
|
|
}
|
|
if (Xsdt!=NULL) {
|
|
Xsdt->Entry = (UINT64)((UINT32)(UINTN)newFadt);
|
|
}
|
|
FixChecksum(&FadtPointer->Header);
|
|
if (gSettings.SlpSmiEnable) {
|
|
UINT32 *SlpSmiEn = (UINT32*)((UINTN)(newFadt->Pm1aEvtBlk) + 0x30);
|
|
UINT32 Value = *SlpSmiEn;
|
|
Value &= ~ bit(4);
|
|
*SlpSmiEn = Value;
|
|
}
|
|
}
|
|
|
|
//Get regions from BIOS DSDT
|
|
if ((gSettings.FixDsdt & FIX_REGIONS) != 0) {
|
|
GetBiosRegions((UINT8*)(UINTN)(newFadt->Dsdt));
|
|
}
|
|
// DBG("DSDT finding\n");
|
|
if (!Volume) {
|
|
DBG("Volume not found!\n");
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
RootDir = Volume->RootDir;
|
|
Status = EFI_NOT_FOUND;
|
|
|
|
if (FileExists(SelfRootDir, PoolPrint(L"%s%s", AcpiOemPath, PathDsdt))) {
|
|
DBG("DSDT found in Clover volume OEM folder: %s%s\n", AcpiOemPath, PathDsdt);
|
|
Status = egLoadFile(SelfRootDir, PoolPrint(L"%s%s", AcpiOemPath, PathDsdt), &buffer, &bufferLen);
|
|
//REVIEW: memory leak... buffer
|
|
}
|
|
|
|
if (EFI_ERROR(Status) && FileExists(RootDir, PathDsdt)) {
|
|
DBG("DSDT found in booted volume\n");
|
|
Status = egLoadFile(RootDir, PathDsdt, &buffer, &bufferLen);
|
|
//REVIEW: memory leak... buffer
|
|
}
|
|
|
|
if (EFI_ERROR(Status) && FileExists(SelfRootDir, PoolPrint(L"%s%s", PathPatched, PathDsdt))) {
|
|
DBG("DSDT found in Clover volume: %s%s\n", PathPatched, PathDsdt);
|
|
Status = egLoadFile(SelfRootDir, PoolPrint(L"%s%s", PathPatched, PathDsdt), &buffer, &bufferLen);
|
|
//REVIEW: memory leak... buffer
|
|
}
|
|
//
|
|
//apply DSDT loaded from a file into buffer
|
|
//else FADT will contain old BIOS DSDT
|
|
//
|
|
DsdtLoaded = FALSE;
|
|
if (!EFI_ERROR(Status)) {
|
|
//custom DSDT is loaded so not need to drop _DSM - NO! We need to drop them!
|
|
// if we will apply fixes, allocate additional space
|
|
bufferLen = bufferLen + bufferLen / 8;
|
|
dsdt = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(bufferLen),
|
|
&dsdt
|
|
);
|
|
|
|
//if success insert dsdt pointer into ACPI tables
|
|
if(!EFI_ERROR(Status)) {
|
|
// DBG("page is allocated, write DSDT into\n");
|
|
CopyMem((VOID*)(UINTN)dsdt, buffer, bufferLen);
|
|
|
|
FadtPointer->Dsdt = (UINT32)dsdt;
|
|
FadtPointer->XDsdt = dsdt;
|
|
FixChecksum(&FadtPointer->Header);
|
|
DsdtLoaded = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!DsdtLoaded) {
|
|
// allocate space for fixes
|
|
TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)FadtPointer->Dsdt;
|
|
bufferLen = TableHeader->Length;
|
|
// DBG("DSDT len = 0x%x", bufferLen);
|
|
// bufferLen = bufferLen + bufferLen / 8;
|
|
// DBG(" new len = 0x%x\n", bufferLen);
|
|
|
|
dsdt = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status = gBS->AllocatePages(AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(bufferLen + bufferLen / 8),
|
|
&dsdt);
|
|
|
|
//if success insert dsdt pointer into ACPI tables
|
|
if(!EFI_ERROR(Status)) {
|
|
CopyMem((VOID*)(UINTN)dsdt, TableHeader, bufferLen);
|
|
|
|
FadtPointer->Dsdt = (UINT32)dsdt;
|
|
FadtPointer->XDsdt = dsdt;
|
|
FixChecksum(&FadtPointer->Header);
|
|
}
|
|
}
|
|
dropDSM = 0xFFFF; //by default we drop all OEM _DSM. They have no sense for us.
|
|
if (defDSM) {
|
|
dropDSM = gSettings.DropOEM_DSM; //if set by user
|
|
}
|
|
|
|
if (gSettings.DebugDSDT) {
|
|
DBG("Output DSDT before patch to /EFI/CLOVER/ACPI/origin/DSDT-or.aml\n");
|
|
Status = egSaveFile(SelfRootDir, L"\\EFI\\CLOVER\\ACPI\\origin\\DSDT-or.aml",
|
|
(UINT8*)(UINTN)FadtPointer->XDsdt, bufferLen);
|
|
}
|
|
//native DSDT or loaded we want to apply autoFix to this
|
|
// if (gSettings.FixDsdt) { //fix even with zero mask because we want to know PCIRootUID and count(?)
|
|
DBG("Apply DsdtFixMask=0x%08x\n", gSettings.FixDsdt);
|
|
DBG(" drop _DSM mask=0x%04x\n", dropDSM);
|
|
FixBiosDsdt((UINT8*)(UINTN)FadtPointer->XDsdt, FadtPointer, OSVersion);
|
|
if (gSettings.DebugDSDT) {
|
|
for (Index=0; Index < 60; Index++) {
|
|
CHAR16 DsdtPatchedName[128];
|
|
UnicodeSPrint(DsdtPatchedName, 256, L"\\EFI\\CLOVER\\ACPI\\origin\\DSDT-pa%d.aml", Index);
|
|
if(!FileExists(SelfRootDir, DsdtPatchedName)){
|
|
Status = egSaveFile(SelfRootDir, DsdtPatchedName,
|
|
(UINT8*)(UINTN)FadtPointer->XDsdt, bufferLen);
|
|
if (!EFI_ERROR(Status)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("...saving DSDT failed with status=%r\n", Status);
|
|
}
|
|
}
|
|
|
|
// handle unusual situations with XSDT and RSDT
|
|
PreCleanupRSDT();
|
|
PreCleanupXSDT();
|
|
|
|
// XsdtReplaceSizes array is used to keep track of allocations for the merged tables,
|
|
// as those tables may need to be freed if patched later.
|
|
XsdtReplaceSizes = (__typeof__(XsdtReplaceSizes))AllocateZeroPool(XsdtTableCount() * sizeof(*XsdtReplaceSizes));
|
|
|
|
// Load merged ACPI files from ACPI/patched
|
|
LoadAllPatchedAML(AcpiOemPath, AUTOMERGE_PASS1);
|
|
|
|
// Drop tables
|
|
if (gSettings.ACPIDropTables) {
|
|
ACPI_DROP_TABLE *DropTable;
|
|
DbgHeader("ACPIDropTables");
|
|
for (DropTable = gSettings.ACPIDropTables; DropTable; DropTable = DropTable->Next) {
|
|
if (DropTable->MenuItem.BValue) {
|
|
//DBG("Attempting to drop \"%4.4a\" (%8.8X) \"%8.8a\" (%16.16lX) L=%d\n", &(DropTable->Signature), DropTable->Signature, &(DropTable->TableId), DropTable->TableId, DropTable->Length);
|
|
DropTableFromXSDT(DropTable->Signature, DropTable->TableId, DropTable->Length);
|
|
DropTableFromRSDT(DropTable->Signature, DropTable->TableId, DropTable->Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gSettings.DropSSDT) {
|
|
DbgHeader("DropSSDT");
|
|
//special case if we set into menu drop all SSDT
|
|
DropTableFromXSDT(EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE, 0, 0);
|
|
DropTableFromRSDT(EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE, 0, 0);
|
|
}
|
|
//It's time to fix headers of all remaining ACPI tables.
|
|
// The bug reported by TheRacerMaster and https://alextjam.es/debugging-appleacpiplatform/
|
|
// Workaround proposed by cecekpawon, revised by Slice
|
|
PatchAllTables();
|
|
|
|
// Load add-on ACPI files from ACPI/patched
|
|
LoadAllPatchedAML(AcpiOemPath, AUTOMERGE_PASS2);
|
|
|
|
if (XsdtReplaceSizes) {
|
|
FreePool(XsdtReplaceSizes);
|
|
XsdtReplaceSizes = NULL;
|
|
}
|
|
|
|
//Slice - this is a time to patch MADT table.
|
|
// DBG("Fool proof: size of APIC NMI = %d\n", sizeof(EFI_ACPI_2_0_LOCAL_APIC_NMI_STRUCTURE));
|
|
// DBG("----------- size of APIC DESC = %d\n", sizeof(EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER));
|
|
// DBG("----------- size of APIC PROC = %d\n", sizeof(EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE));
|
|
|
|
ApicCPUNum = 0;
|
|
// 2. For absent NMI subtable
|
|
xf = ScanXSDT(APIC_SIGN, 0);
|
|
if (xf) {
|
|
ApicTable = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)(*xf);
|
|
// ApicLen = ApicTable->Length;
|
|
ProcLocalApic = (EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE *)(UINTN)(*xf + sizeof(EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER));
|
|
|
|
while ((ProcLocalApic->Type == EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC) && (ProcLocalApic->Length == 8)) {
|
|
if (ProcLocalApic->Flags & EFI_ACPI_4_0_LOCAL_APIC_ENABLED) {
|
|
ApicCPUNum++;
|
|
}
|
|
ProcLocalApic++;
|
|
if (ApicCPUNum > 16) {
|
|
DBG("Out of control with CPU numbers\n");
|
|
break;
|
|
}
|
|
}
|
|
//fool proof
|
|
if ((ApicCPUNum == 0) || (ApicCPUNum > 16)) {
|
|
ApicCPUNum = gCPUStructure.Threads;
|
|
}
|
|
|
|
DBG("ApicCPUNum=%d\n", ApicCPUNum);
|
|
//reallocate table
|
|
if (gSettings.PatchNMI) {
|
|
BufferPtr = EFI_SYSTEM_TABLE_MAX_ADDRESS;
|
|
Status=gBS->AllocatePages(AllocateMaxAddress, EfiACPIReclaimMemory, 1, &BufferPtr);
|
|
if(!EFI_ERROR(Status)) {
|
|
//save old table and drop it from XSDT
|
|
CopyMem((VOID*)(UINTN)BufferPtr, ApicTable, ApicTable->Length);
|
|
DropTableFromXSDT(APIC_SIGN, 0, 0);
|
|
ApicTable = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)BufferPtr;
|
|
ApicTable->Revision = EFI_ACPI_4_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION;
|
|
CopyMem(&ApicTable->OemId, oemID, 6);
|
|
CopyMem(&ApicTable->OemTableId, oemTableID, 8);
|
|
ApicTable->OemRevision = 0x00000001;
|
|
CopyMem(&ApicTable->CreatorId, creatorID, 4);
|
|
|
|
SubTable = (UINT8*)((UINTN)BufferPtr + sizeof(EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER));
|
|
Index = 0;
|
|
while (*SubTable != EFI_ACPI_4_0_LOCAL_APIC_NMI) {
|
|
DBG("Found subtable in MADT: type=%d\n", *SubTable);
|
|
if (*SubTable == EFI_ACPI_4_0_PROCESSOR_LOCAL_APIC) {
|
|
ProcLocalApic = (EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE *)SubTable;
|
|
// macOS assumes that the first processor from DSDT is always enabled, without checking MADT table
|
|
// here we're trying to assign first IDs found in DSDT to enabled processors in MADT, such that macOS assumption to be true
|
|
if (ProcLocalApic->Flags & EFI_ACPI_4_0_LOCAL_APIC_ENABLED) {
|
|
if (ProcLocalApic->AcpiProcessorId != acpi_cpu_processor_id[Index]) {
|
|
DBG("AcpiProcessorId changed: 0x%02x to 0x%02x\n", ProcLocalApic->AcpiProcessorId, acpi_cpu_processor_id[Index]);
|
|
ProcLocalApic->AcpiProcessorId = acpi_cpu_processor_id[Index];
|
|
} else {
|
|
DBG("AcpiProcessorId: 0x%02x\n", ProcLocalApic->AcpiProcessorId);
|
|
}
|
|
Index++;
|
|
}
|
|
}
|
|
bufferLen = (UINTN)SubTable[1];
|
|
SubTable += bufferLen;
|
|
if (((UINTN)SubTable - (UINTN)BufferPtr) >= ApicTable->Length) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (*SubTable == EFI_ACPI_4_0_LOCAL_APIC_NMI) {
|
|
DBG("LocalApicNMI is already present, no patch needed\n");
|
|
} else {
|
|
LocalApicNMI = (EFI_ACPI_2_0_LOCAL_APIC_NMI_STRUCTURE*)((UINTN)ApicTable + ApicTable->Length);
|
|
for (Index = 0; Index < ApicCPUNum; Index++) {
|
|
LocalApicNMI->Type = EFI_ACPI_4_0_LOCAL_APIC_NMI;
|
|
LocalApicNMI->Length = sizeof(EFI_ACPI_4_0_LOCAL_APIC_NMI_STRUCTURE);
|
|
LocalApicNMI->AcpiProcessorId = acpi_cpu_processor_id[Index];
|
|
LocalApicNMI->Flags = 5;
|
|
LocalApicNMI->LocalApicLint = 1;
|
|
LocalApicNMI++;
|
|
ApicTable->Length += sizeof(EFI_ACPI_4_0_LOCAL_APIC_NMI_STRUCTURE);
|
|
}
|
|
DBG("ApicTable new Length=%d\n", ApicTable->Length);
|
|
// insert corrected MADT
|
|
}
|
|
|
|
Status = InsertTable(ApicTable, ApicTable->Length);
|
|
if (!EFI_ERROR(Status)) {
|
|
DBG("New APIC table successfully inserted\n");
|
|
}
|
|
/*
|
|
Status = egSaveFile(SelfRootDir, PatchedAPIC, (UINT8 *)ApicTable, ApicTable->Length);
|
|
if (EFI_ERROR(Status)) {
|
|
Status = egSaveFile(NULL, PatchedAPIC, (UINT8 *)ApicTable, ApicTable->Length);
|
|
}
|
|
if (!EFI_ERROR(Status)) {
|
|
DBG("Patched APIC table saved into efi/clover/acpi/origin/APIC-p.aml \n");
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
DBG("No APIC table Found !!!\n");
|
|
}
|
|
|
|
if (gCPUStructure.Threads >= gCPUStructure.Cores) {
|
|
ApicCPUNum = gCPUStructure.Threads;
|
|
} else {
|
|
ApicCPUNum = gCPUStructure.Cores;
|
|
}
|
|
// }
|
|
/*
|
|
At this moment we have CPU numbers from DSDT - acpi_cpu_num
|
|
and from CPU characteristics gCPUStructure
|
|
Also we had the number from APIC table ApicCPUNum
|
|
What to choose?
|
|
Since rev745 I will return to acpi_cpu_count global variable
|
|
*/
|
|
if (acpi_cpu_count) {
|
|
ApicCPUNum = acpi_cpu_count;
|
|
}
|
|
|
|
if (gSettings.GeneratePStates || gSettings.GeneratePluginType) {
|
|
Status = EFI_NOT_FOUND;
|
|
Ssdt = generate_pss_ssdt(ApicCPUNum);
|
|
if (Ssdt) {
|
|
Status = InsertTable(Ssdt, Ssdt->Length);
|
|
}
|
|
if(EFI_ERROR(Status)){
|
|
DBG("GeneratePStates failed: Status=%r\n", Status);
|
|
}
|
|
}
|
|
|
|
if (gSettings.GenerateCStates) {
|
|
Status = EFI_NOT_FOUND;
|
|
Ssdt = generate_cst_ssdt(FadtPointer, ApicCPUNum);
|
|
if (Ssdt) {
|
|
Status = InsertTable(Ssdt, Ssdt->Length);
|
|
}
|
|
if(EFI_ERROR(Status)){
|
|
DBG("GenerateCStates failed Status=%r\n", Status);
|
|
}
|
|
}
|
|
|
|
// remove NULL entries from RSDT and XSDT
|
|
PostCleanupRSDT();
|
|
PostCleanupXSDT();
|
|
|
|
if (NeedUpdate) {
|
|
gBS->InstallConfigurationTable(&gEfiAcpiTableGuid, RsdPointer);
|
|
gBS->InstallConfigurationTable(&gEfiAcpi10TableGuid, RsdPointer);
|
|
}
|
|
|
|
//free regions?
|
|
while (gRegions) {
|
|
tmpRegion = gRegions->next;
|
|
FreePool(gRegions);
|
|
gRegions = tmpRegion;
|
|
}
|
|
FreePool(AcpiOemPath);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Searches for TableName in PathPatched dirs and loads it
|
|
* to Buffer if found. Buffer is allocated here and should be released
|
|
* by caller.
|
|
*/
|
|
EFI_STATUS LoadAcpiTable (
|
|
CHAR16 *PathPatched,
|
|
CHAR16 *TableName,
|
|
UINT8 **Buffer,
|
|
UINTN *BufferLen
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR16* TmpStr;
|
|
|
|
Status = EFI_NOT_FOUND;
|
|
|
|
// checking \EFI\ACPI\patched dir
|
|
TmpStr = PoolPrint(L"%s\\%s", PathPatched, TableName);
|
|
if (FileExists(SelfRootDir, TmpStr)) {
|
|
DBG("found %s\n", TmpStr);
|
|
Status = egLoadFile(SelfRootDir, TmpStr, Buffer, BufferLen);
|
|
}
|
|
FreePool(TmpStr);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
* Searches for DSDT in AcpiOemPath or PathPatched dirs and inserts it
|
|
* to FadtPointer if found.
|
|
*/
|
|
EFI_STATUS LoadAndInjectDSDT(CHAR16 *PathPatched,
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 *Buffer = NULL;
|
|
UINTN BufferLen = 0;
|
|
EFI_PHYSICAL_ADDRESS Dsdt;
|
|
|
|
// load if exists
|
|
Status = LoadAcpiTable(PathPatched, gSettings.DsdtName, &Buffer, &BufferLen);
|
|
|
|
if (!EFI_ERROR(Status)) {
|
|
// loaded - allocate EfiACPIReclaim
|
|
DBG("Loaded DSDT at %s\\%s\n", PathPatched, gSettings.DsdtName);
|
|
Dsdt = EFI_SYSTEM_TABLE_MAX_ADDRESS; //0xFE000000;
|
|
Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiACPIReclaimMemory,
|
|
EFI_SIZE_TO_PAGES(BufferLen),
|
|
&Dsdt
|
|
);
|
|
|
|
if(!EFI_ERROR(Status)) {
|
|
// copy DSDT into EfiACPIReclaim block
|
|
CopyMem((VOID*)(UINTN)Dsdt, Buffer, BufferLen);
|
|
|
|
// update FADT
|
|
FadtPointer->Dsdt = (UINT32)Dsdt;
|
|
FadtPointer->XDsdt = Dsdt;
|
|
FixChecksum(&FadtPointer->Header);
|
|
DBG("DSDT at 0x%x injected to FADT 0x%p\n", Dsdt, FadtPointer);
|
|
}
|
|
|
|
FreePool(Buffer);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
* Searches for TableName in AcpiOemPath or PathPatched dirs and inserts it
|
|
* to Rsdt and/or Xsdt (globals) if found.
|
|
*/
|
|
EFI_STATUS LoadAndInjectAcpiTable(CHAR16 *PathPatched,
|
|
CHAR16 *TableName)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 *Buffer = NULL;
|
|
UINTN BufferLen = 0;
|
|
EFI_ACPI_DESCRIPTION_HEADER *TableHeader = NULL;
|
|
|
|
|
|
// load if exists
|
|
Status = LoadAcpiTable(PathPatched, TableName, &Buffer, &BufferLen);
|
|
|
|
if(!EFI_ERROR(Status)) {
|
|
if (Buffer) {
|
|
// if this is SLIC, then remove previous SLIC if it is there
|
|
TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)Buffer;
|
|
if (TableHeader->Signature == SLIC_SIGN) {
|
|
DropTableFromXSDT(SLIC_SIGN, 0, 0);
|
|
DropTableFromRSDT(SLIC_SIGN, 0, 0);
|
|
}
|
|
}
|
|
|
|
// loaded - insert it into XSDT/RSDT
|
|
Status = InsertTable(Buffer, BufferLen);
|
|
|
|
if(!EFI_ERROR(Status)) {
|
|
DBG("Table %s inserted.\n", TableName);
|
|
|
|
// if this was SLIC, then update IDs in XSDT/RSDT
|
|
|
|
if (TableHeader->Signature == SLIC_SIGN) {
|
|
if (Rsdt) {
|
|
DBG("SLIC: Rsdt OEMid '%6.6a', TabId '%8.8a'", (CHAR8*)&Rsdt->Header.OemId, (CHAR8*)&Rsdt->Header.OemTableId);
|
|
CopyMem(&Rsdt->Header.OemId, &TableHeader->OemId, 6);
|
|
Rsdt->Header.OemTableId = TableHeader->OemTableId;
|
|
DBG(" to OEMid '%6.6a', TabId '%8.8a'\n", (CHAR8*)&Rsdt->Header.OemId, (CHAR8*)&Rsdt->Header.OemTableId);
|
|
}
|
|
if (Xsdt) {
|
|
DBG("SLIC: Xsdt OEMid '%6.6a', TabId '%8.8a'", (CHAR8*)&Xsdt->Header.OemId, (CHAR8*)&Xsdt->Header.OemTableId);
|
|
CopyMem(&Xsdt->Header.OemId, &TableHeader->OemId, 6);
|
|
Xsdt->Header.OemTableId = TableHeader->OemTableId;
|
|
DBG(" to OEMid '%6.6a', TabId '%8.8a'\n", (CHAR8*)&Xsdt->Header.OemId, (CHAR8*)&Xsdt->Header.OemTableId);
|
|
}
|
|
}
|
|
} else {
|
|
DBG("Insert return status %r\n", Status);
|
|
}
|
|
|
|
FreePool(Buffer);
|
|
} // if table loaded
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
* Patches UEFI ACPI tables with tables found in OsSubdir.
|
|
*/
|
|
EFI_STATUS PatchACPI_OtherOS(CONST CHAR16* OsSubdir, BOOLEAN DropSSDT)
|
|
{
|
|
EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER *RsdPointer;
|
|
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer;
|
|
|
|
EFI_STATUS Status; // = EFI_SUCCESS;
|
|
// UINTN Index;
|
|
CHAR16* PathPatched;
|
|
CHAR16* AcpiOemPath;
|
|
REFIT_DIR_ITER DirIter;
|
|
EFI_FILE_INFO *DirEntry;
|
|
|
|
//
|
|
// Search for RSDP in UEFI SystemTable/ConfigTable (first Acpi 2.0, then 1.0)
|
|
//
|
|
RsdPointer = NULL;
|
|
|
|
Status = EfiGetSystemConfigurationTable (&gEfiAcpi20TableGuid, (VOID **) &RsdPointer);
|
|
if (RsdPointer != NULL) {
|
|
DBG("OtherOS: Found Acpi 2.0 RSDP 0x%x\n", RsdPointer);
|
|
} else {
|
|
Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **) &RsdPointer);
|
|
if (RsdPointer != NULL) {
|
|
DBG("Found Acpi 1.0 RSDP 0x%x\n", RsdPointer);
|
|
}
|
|
}
|
|
// if RSDP not found - quit
|
|
if (!RsdPointer) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Find RSDT and/or XSDT
|
|
//
|
|
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPointer->RsdtAddress);
|
|
if (Rsdt != NULL && Rsdt->Header.Signature != EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
Rsdt = NULL;
|
|
}
|
|
DBG("RSDT at %p\n", Rsdt);
|
|
|
|
// check for XSDT
|
|
Xsdt = NULL;
|
|
if (RsdPointer->Revision >=2 && (RsdPointer->XsdtAddress < (UINT64)((UINTN)(-1)))) {
|
|
Xsdt = (XSDT_TABLE*)(UINTN)RsdPointer->XsdtAddress;
|
|
if (Xsdt != NULL && Xsdt->Header.Signature != EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) {
|
|
Xsdt = NULL;
|
|
}
|
|
}
|
|
DBG("XSDT at %p\n", Xsdt);
|
|
|
|
// if RSDT and XSDT not found - quit
|
|
if (Rsdt == NULL && Xsdt == NULL) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Take FADT (FACP) from XSDT or RSDT (always first entry)
|
|
//
|
|
FadtPointer = NULL;
|
|
if (Xsdt) {
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(Xsdt->Entry);
|
|
} else if (Rsdt) {
|
|
FadtPointer = (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE*)(UINTN)(Rsdt->Entry);
|
|
}
|
|
DBG("FADT pointer = %p\n", FadtPointer);
|
|
|
|
// if not found - quit
|
|
if(FadtPointer == NULL) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Inject/drop tables
|
|
//
|
|
|
|
// prepare dirs that will be searched for custom ACPI tables
|
|
AcpiOemPath = PoolPrint(L"%s\\ACPI\\%s", OEMPath, OsSubdir);
|
|
if (FileExists(SelfRootDir, AcpiOemPath)) {
|
|
PathPatched = AcpiOemPath;
|
|
} else {
|
|
FreePool(AcpiOemPath);
|
|
PathPatched = PoolPrint(L"\\EFI\\CLOVER\\ACPI\\%s", OsSubdir);
|
|
}
|
|
if (!FileExists(SelfRootDir, PathPatched)) {
|
|
FreePool(PathPatched);
|
|
DBG("Dir %s not found. No patching will be done.\n", OsSubdir);
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Inject DSDT
|
|
//
|
|
/* Status = */LoadAndInjectDSDT(PathPatched, FadtPointer);
|
|
|
|
//
|
|
// Drop SSDT if requested. Not until now
|
|
//
|
|
/*
|
|
if (DropSSDT) {
|
|
DropTableFromXSDT(EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE, 0, 0);
|
|
DropTableFromRSDT(EFI_ACPI_4_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE, 0, 0);
|
|
}
|
|
*/
|
|
//
|
|
// find and inject other ACPI tables
|
|
//
|
|
|
|
DirIterOpen(SelfRootDir, PathPatched, &DirIter);
|
|
while (DirIterNext(&DirIter, 2, L"*.aml", &DirEntry)) {
|
|
|
|
if (DirEntry->FileName[0] == L'.') {
|
|
continue;
|
|
}
|
|
if (StrStr(DirEntry->FileName, L"DSDT")) {
|
|
continue;
|
|
}
|
|
|
|
LoadAndInjectAcpiTable(PathPatched, DirEntry->FileName);
|
|
}
|
|
/*Status = */DirIterClose(&DirIter);
|
|
|
|
// remove NULL entries from RSDT and XSDT
|
|
PostCleanupRSDT();
|
|
PostCleanupXSDT();
|
|
|
|
// release mem
|
|
if (PathPatched) FreePool(PathPatched);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|