Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-04 13:23:26 +01:00
Code Issues Packages Projects Releases Wiki Activity
12b589410a
CloverBootloader/rEFIt_UEFI/Platform/AcpiPatcher.cpp
jief666 1ea4700bd6 Replace EFI_GUID by a class EFI_GUID.
2022-04-26 00:55:56 +02:00

2604 lines
92 KiB
C++
Raw Blame History

/**
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 <Platform.h> // Only use angled for Platform, else, xcode project won't compile
#include <Efi.h>
#include "../libeg/BmLib.h"
#include "StateGenerator.h"
#include "AmlGenerator.h"
#include "AcpiPatcher.h"
#include "FixBiosDsdt.h"
#include "platformdata.h"
#include "smbios.h"
#include "cpu.h"
#include "../Settings/Self.h"
#include "../Settings/SelfOem.h"
#include "Settings.h"
#define EBDA_BASE_ADDRESS 0x40E
#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);
}
}
XBool 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: %s %s len=%d\n", sign, OTID, (INT32)Table->Length);
DBG(" - [%02d]: %s %s len=%d\n", Index, sign, OTID, (INT32)Table->Length);
ACPI_DROP_TABLE* DropTable = new ACPI_DROP_TABLE;
DropTable->Signature = Table->Signature;
DropTable->TableId = Table->OemTableId;
DropTable->Length = Table->Length;
DropTable->MenuItem.BValue = false;
DropTable->Next = GlobalConfig.ACPIDropTables;
GlobalConfig.ACPIDropTables = DropTable;
}
/*
* There is the case when OemTableId ended by space like "TableID ".
* We will not see the space but comparison will fail.
*/
UINT64 OemTableId_NoSpace(UINT64 origin)
{
UINT64 mask = 0xffULL << 56;
UINT64 space = 0x20ULL << 56;
do {
if ((mask & origin) == space) {
origin &= ~mask;
}
mask >>= 8;
space >>= 8;
} while (mask != 0 && ((mask & origin) == 0 || (mask & origin) == space));
return origin;
}
void GetAcpiTablesList()
{
DbgHeader("GetAcpiTablesList");
GetFadt(); //this is a first call to acpi, we need it to make a pointer to Xsdt
GlobalConfig.ACPIDropTables = NULL;
DBG("Get Acpi Tables List ");
/*
//for test
CHAR8 OTID[9];
OTID[8] = 0;
UINT64 TestTableId = 0x204449656c626154ULL; // <54 61 62 6c 65 49 44 20>
CopyMem(&OTID[0], &TestTableId, 8);
DBG("\n test id=0x%08llx as str=%s\n", TestTableId, OTID);
TestTableId = OemTableId_NoSpace(TestTableId);
DBG("after convert id=0x%08llx as str=%s\n", TestTableId, OTID);
result:
test id=0x204449656c626154 as str=TableID
after convert id=0x4449656c626154 as str=TableID
*/
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[0], &Signature, 4);
CopyMem(&OTID[0], &TableId, 8);
DBG("Drop tables from RSDT, SIGN=%s TableID=%s 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[0], &Table->Signature, 4);
CopyMem(&OTID[0], &Table->OemTableId, 8);
//DBG(" Found table: %s %s\n", sign, OTID);
if (!((Signature && Table->Signature == Signature) &&
(!TableId || OemTableId_NoSpace(Table->OemTableId) == TableId) &&
(!Length || Table->Length == Length))) {
continue;
}
if (IsXsdtEntryMerged(IndexFromXsdtEntryPtr(Ptr))) {
DBG(" attempt to drop already merged table[%d]: %s %s %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]: %s %s %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[0], &Signature, 4);
CopyMem(&OTID[0], &TableId, 8);
DBG("Drop tables from XSDT, SIGN=%s TableID=%s 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[0], &Table->Signature, 4);
CopyMem(&OTID[0], &Table->OemTableId, 8);
//DBG(" Found table: %s %s\n", sign, OTID);
if (!((Signature && Table->Signature == Signature) &&
(!TableId || OemTableId_NoSpace(Table->OemTableId) == TableId) &&
(!Length || Table->Length == Length))) {
continue;
}
if (IsXsdtEntryMerged(IndexFromXsdtEntryPtr(Ptr))) {
DBG(" attempt to drop already merged table[%d]: %s %s %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]: %s %s %d dropped\n", IndexFromXsdtEntryPtr(Ptr), sign, OTID, (INT32)Table->Length);
}
}
// by cecekpawon, edited by Slice, further edits by RehabMan
XBool FixAsciiTableHeader(UINT8 *Str, UINTN Len)
{
XBool 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;
}
XBool PatchTableHeader(EFI_ACPI_DESCRIPTION_HEADER *Header)
{
XBool Ret1, Ret2, Ret3;
if ( !gSettings.ACPI.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++) {
XBool 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.ACPI.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.ACPI.DSDT.DSDTPatchArray.size() > 0) {
DBG("Patching SSDTs: %zu patches each\n", gSettings.ACPI.DSDT.DSDTPatchArray.size());
// CHAR8 OTID[9];
// OTID[8] = 0;
// CopyMem(OTID, &NewTable->OemTableId, 8);
// DBG("Patching SSDT %s Length=%d\n", OTID, (INT32)Len);
for (UINT32 i = 0; i < gSettings.ACPI.DSDT.DSDTPatchArray.size(); i++) {
if ( gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtFind.isEmpty() ) {
continue;
}
// DBG("%d. [%s]:", i, gSettings.PatchDsdtLabel[i]);
if (!gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtMenuItem.BValue) {
// DBG(" disabled\n");
continue;
}
if ( gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtTgt.isEmpty() ) {
Len = FixAny((UINT8*)NewTable, Len,
gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtFind,
gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtReplace,
gSettings.ACPI.DSDT.DSDTPatchArray[i].Skip);
//DBG(" OK\n");
}else{
//DBG("Patching: renaming in bridge\n");
Len = FixRenameByBridge2((UINT8*)NewTable, Len, gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtTgt,
gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtFind,
gSettings.ACPI.DSDT.DSDTPatchArray[i].PatchDsdtReplace,
gSettings.ACPI.DSDT.DSDTPatchArray[i].Skip);
}
}
}
// 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.ACPI.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(CONST 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;
CONST 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("@%llu ", (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 OemDir\\DirName\\FileName. */
EFI_STATUS SaveBufferToDisk(void *Buffer, UINTN Length, CONST CHAR16 *DirName, CONST CHAR16 *FileName)
{
if (DirName == NULL || FileName == NULL) {
return EFI_INVALID_PARAMETER;
}
XStringW PathName = SWPrintf("%ls\\%ls", DirName, FileName);
EFI_STATUS Status = egSaveFile(&selfOem.getConfigDir(), PathName.wc_str(), Buffer, Length);
// Do not write outside OemDir
// if (EFI_ERROR(Status)) {
// Status = egSaveFile(NULL, PathName.wc_str(), Buffer, Length);
// }
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. */
XBool 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 %llx", 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 XStringW 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
{
XStringW FileName;
CHAR8 Suffix[10]; // "-" + OemTableId + NUL
if (gSettings.ACPI.SSDT.NoOemTableId || 0 == OemTableId[0]) {
Suffix[0] = 0;
} else {
Suffix[0] = '-';
CopyMem(Suffix+1, OemTableId, 9);
}
if (IGNORE_INDEX == ChildCount) {
// normal SSDT
FileName = SWPrintf("%lsSSDT-%llu%s.aml", FileNamePrefix, SsdtCount, Suffix);
} else if (IGNORE_INDEX == SsdtCount) {
// dynamic SSDT in DSDT
FileName = SWPrintf("%lsSSDT-xDSDT_%llu%s.aml", FileNamePrefix, ChildCount, Suffix);
} else {
// dynamic SSDT in static SSDT
FileName = SWPrintf("%lsSSDT-x%llu_%llu%s.aml", FileNamePrefix, SsdtCount, ChildCount, Suffix);
}
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;
CHAR8 Signature[5];
CHAR8 OemTableId[9];
UINTN adr, len;
UINT8 *Entry;
UINT8 *End;
UINT8 *pacBody;
INTN ChildCount = 0;
if (gSettings.ACPI.SSDT.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 %lld 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[0], &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Signature, 4);
Signature[4] = 0;
CopyMem(&OemTableId[0], &((EFI_ACPI_DESCRIPTION_HEADER *)adr)->OemTableId, 8);
OemTableId[8] = 0;
stripTrailingSpaces(OemTableId);
int innLen = ((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Length;
if (innLen < 0 || innLen > 0x20000) break;
DBG(" * %llu: '%s', '%s', Rev: %d, Len: %d ", adr, Signature, OemTableId,
((EFI_ACPI_DESCRIPTION_HEADER *)adr)->Revision, innLen);
for (k = 0; k < 16; k++) {
DBG("%02hhX ", ((UINT8*)adr)[k]);
}
if ((AsciiStrCmp(Signature, "SSDT") == 0) && (len < 0x20000) && DirName != NULL && !IsTableSaved((void*)adr)) {
XStringW FileName = GenerateFileName(FileNamePrefix, SsdtCount, ChildCount, OemTableId);
len = ((UINT16*)adr)[2];
DBG("Internal length = %llu", len);
Status = SaveBufferToDisk((void*)adr, len, DirName, FileName.wc_str());
if (!EFI_ERROR(Status)) {
DBG(" -> %ls", FileName.wc_str());
MarkTableAsSaved((void*)adr);
ChildCount++;
} else {
DBG(" -> %s", efiStrError(Status));
}
}
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(" * %llu: '%s', '%s', 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("%02hhX ", ((UINT8*)adr)[k]);
}
if ((AsciiStrCmp(Signature, "SSDT") == 0) && (len < 0x20000) && DirName != NULL && !IsTableSaved((void*)adr)) {
XStringW FileName = GenerateFileName(FileNamePrefix, SsdtCount, ChildCount, OemTableId);
Status = SaveBufferToDisk((void*)adr, len, DirName, FileName.wc_str());
if (!EFI_ERROR(Status)) {
DBG(" -> %ls", FileName.wc_str());
MarkTableAsSaved((void*)adr);
ChildCount++;
} else {
DBG(" -> %s", efiStrError(Status));
}
}
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 XStringW& FileName, CONST CHAR16 *FileNamePrefix, INTN *SsdtCount)
{
EFI_STATUS Status;
CHAR8 Signature[5];
CHAR8 OemTableId[9];
// Take Signature and OemId for printing
CopyMem(&Signature[0], &TableEntry->Signature, 4);
Signature[4] = 0;
CopyMem(&OemTableId[0], &TableEntry->OemTableId, 8);
OemTableId[8] = 0;
stripTrailingSpaces(OemTableId);
DBG(" %llx: '%s', '%s', Rev: %d, Len: %d", (uintptr_t)TableEntry, Signature, OemTableId, TableEntry->Revision, TableEntry->Length);
//
// Additional checks
//
if (CheckSignature != NULL && AsciiStrCmp(Signature, CheckSignature) != 0) {
DBG(" -> invalid signature, expecting %s\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"";
}
XStringW ReleaseFileName = FileName;
if (ReleaseFileName.isEmpty()) {
// take the name from the signature
if (TableEntry->Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE && SsdtCount != NULL) {
ReleaseFileName = GenerateFileName(FileNamePrefix, *SsdtCount, IGNORE_INDEX, OemTableId);
} else {
ReleaseFileName = SWPrintf("%ls%s.aml", FileNamePrefix, Signature);
}
}
DBG(" -> %ls", ReleaseFileName.wc_str());
// Save it
Status = SaveBufferToDisk(TableEntry, TableEntry->Length, DirName, ReleaseFileName.wc_str());
MarkTableAsSaved(TableEntry);
if (TableEntry->Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE && SsdtCount != NULL) {
DumpChildSsdt(TableEntry, DirName, FileNamePrefix, *SsdtCount);
*SsdtCount += 1;
}
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];
//
// 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: %llx, XFacs: %llx", Fadt->XDsdt, Fadt->XFirmwareCtrl);
if ((Fadt->XDsdt != 0) && (Fadt->XDsdt < 0xFFFFFFF0ull)){
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, L""_XSW, FileNamePrefix, NULL);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(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[0], &Facs->Signature, 4);
Signature[4] = 0;
DBG(" %llx: '%s', Ver: %d, Len: %d", (uintptr_t)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)) {
XStringW FileName = SWPrintf("%lsFACS.aml", FileNamePrefix);
DBG(" -> %ls", FileName.wc_str());
Status = SaveBufferToDisk(Facs, Facs->Length, DirName, FileName.wc_str());
MarkTableAsSaved(Facs);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(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 %llx\n", (uintptr_t)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, CONST 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 %llx to %ls ...\n", (uintptr_t)RsdPtr, DirName);
} else {
DBG("Printing ACPI tables from RSDP %llx ...\n", (uintptr_t)RsdPtr);
}
if (RsdPtr->Signature != EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_POINTER_SIGNATURE) {
DBG(" RsdPrt at %llx has invaid signature 0x%llx - exiting.\n", (uintptr_t)RsdPtr, RsdPtr->Signature);
return;
}
// Take Signature for printing
CHAR8 Signature[9];
CopyMem(&Signature[0], &RsdPtr->Signature, 8);
Signature[8] = 0;
// Take Rsdt and Xsdt
Rsdt = NULL;
Xsdt = NULL;
DBG(" %llx: '%s', Rev: %d", (uintptr_t)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: %llu", 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(" - %s\n", efiStrError(Status));
return;
}
}
DBG("\n");
if (RsdPtr->Revision == 0) {
// Acpi 1.0 - no Xsdt
Rsdt = (RSDT_TABLE*)(UINTN)(RsdPtr->RsdtAddress);
DBG(" (Rsdt: %llx)\n", (UINTN)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: %llx, Rsdt: %llx)\n", (UINTN)Xsdt, (UINTN)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"_XSW, FileNamePrefix, NULL);
if (EFI_ERROR(Status)) {
DBG(" - %s", efiStrError(Status));
Xsdt = NULL;
}
DBG("\n");
}
//
// Save Rsdt
//
if (Rsdt != NULL) {
DBG(" ");
Status = DumpTable((EFI_ACPI_DESCRIPTION_HEADER *)Rsdt, "RSDT", DirName, L"RSDT.aml"_XSW, FileNamePrefix, NULL);
if (EFI_ERROR(Status)) {
DBG(" - %s", efiStrError(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;
}
UINT32 Count = 0;
if (Xsdt) {
UINT64 *Ptr, *EndPtr;
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, L""_XSW, FileNamePrefix, &SsdtCount);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(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, L""_XSW, FileNamePrefix, &SsdtCount);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(Status));
return;
}
DBG("\n");
}
}
} // if Xsdt
if (!Count && 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
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, L""_XSW, FileNamePrefix, &SsdtCount);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(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, L""_XSW, FileNamePrefix, &SsdtCount);
if (EFI_ERROR(Status)) {
DBG(" - %s\n", efiStrError(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;
XStringW AcpiOriginPath = L"ACPI\\origin"_XSW;
XBool 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 %llx\n", (UINTN)RsdPtr);
if (gFirmwareClover) {
// Save it
DumpTables(RsdPtr, AcpiOriginPath.wc_str());
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) { //it may be EFI_SUCCESS but null pointer
DBG("Found UEFI Acpi 2.0 RSDP at %llx\n", (UINTN)RsdPtr);
// if tables already saved, then just print to log
DumpTables(RsdPtr, Saved ? NULL : AcpiOriginPath.wc_str());
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 %llx\n", (UINTN)RsdPtr);
// if tables already saved, then just print to log
DumpTables(RsdPtr, Saved ? NULL : AcpiOriginPath.wc_str());
// Saved = true;
}
SaveBufferToDisk(MemLogStart, GetMemLogLen() - MemLogStartLen, AcpiOriginPath.wc_str(), L"DumpLog.txt");
FreePool(mSavedTables);
}
void SaveOemDsdt(XBool 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;
XStringW OriginDsdt = SWPrintf("ACPI\\origin\\DSDT.aml");
XStringW OriginDsdtFixed = SWPrintf("ACPI\\origin\\DSDT-%x.aml", gSettings.ACPI.DSDT.FixDsdt);
// constexpr LStringW PathPatched = L"\\EFI\\CL OVER\\ACPI\\patched";
// XStringW PathDsdt;
// XStringW AcpiOemPath = SWPrintf("ACPI\\patched");
// PathDsdt.SWPrintf("\\%ls", gSettings.ACPI.DSDT.FixDsdt.wc_str());
if (FileExists(selfOem.getConfigDir(), SWPrintf("ACPI\\patched\\%ls", gSettings.ACPI.DSDT.DsdtName.wc_str()))) {
DBG("SaveOemDsdt: DSDT found in Clover volume OEM folder: \\%ls\\ACPI\\patched\\%ls\n", selfOem.getConfigDirFullPath().wc_str(), gSettings.ACPI.DSDT.DsdtName.wc_str());
Status = egLoadFile(&selfOem.getConfigDir(), SWPrintf("ACPI\\patched\\%ls", gSettings.ACPI.DSDT.DsdtName.wc_str()).wc_str(), &buffer, &DsdtLen);
}
// Jief : Do not write outside OemPath
// if (EFI_ERROR(Status) && FileExists(&self.getSelfRootDir(), SWPrintf("%ls%ls", PathPatched.wc_str(), PathDsdt.wc_str()))) {
// DBG("SaveOemDsdt: DSDT found in Clover volume common folder: %ls%ls\n", PathPatched.wc_str(), PathDsdt.wc_str());
// Status = egLoadFile(&self.getSelfRootDir(), SWPrintf("%ls%ls", PathPatched.wc_str(), PathDsdt.wc_str()).wc_str(), &buffer, &DsdtLen);
// }
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, NullXString8);
DsdtLen = ((EFI_ACPI_DESCRIPTION_HEADER*)buffer)->Length;
OriginDsdt = OriginDsdtFixed;
}
Status = egSaveFile(&selfOem.getConfigDir(), OriginDsdt.wc_str(), buffer, DsdtLen);
// Jief : do not write outside of OemDir
// if (EFI_ERROR(Status)) {
// Status = egSaveFile(NULL, OriginDsdt.wc_str(), buffer, DsdtLen);
// }
if (!EFI_ERROR(Status)) {
MsgLog("DSDT saved to %ls\\%ls\n", selfOem.getConfigDirFullPath().wc_str(), OriginDsdt.wc_str());
} else {
MsgLog("Saving DSDT to %ls\\%ls failed - %s\n", selfOem.getConfigDirFullPath().wc_str(), OriginDsdt.wc_str(), efiStrError(Status));
}
gBS->FreePages(dsdt, Pages);
}
}
XBool LoadPatchedAML(const EFI_FILE& dir, const XStringW& acpiOemPath, CONST CHAR16* PartName, UINTN Pass)
{
// 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.ACPI.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;
}
}
UINT8 *buffer = NULL;
UINTN bufferLen = 0;
EFI_STATUS Status = egLoadFile(&dir, SWPrintf("%ls\\%ls", acpiOemPath.wc_str(), PartName).wc_str(), &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.ACPI.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("... %s\n", efiStrError(Status));
return !EFI_ERROR(Status);
}
#define BVALUE_ATTEMPTED 2 // special value for MenuItem.BValue to avoid excessive log output
void LoadAllPatchedAML(const XStringW& acpiPathUnderOem, UINTN Pass)
{
if (!gSettings.ACPI.AutoMerge && AUTOMERGE_PASS1 == Pass) {
// nothing to do in this case, since AutoMerge=false -> no tables ever merged
return;
}
if ( ACPIPatchedAML.notEmpty() ) {
DbgHeader("ACPIPatchedAML");
if (gSettings.ACPI.AutoMerge) {
DBG("AutoMerge pass %llu\n", Pass);
}
//DBG("Start: Processing Patched AML(s): ");
if (gSettings.ACPI.SortedACPI.size()) {
UINTN Index;
DBG("Sorted\n");
for (Index = 0; Index < gSettings.ACPI.SortedACPI.size(); Index++) {
size_t idx;
for ( idx = 0 ; idx < ACPIPatchedAML.size() ; ++idx) {
ACPI_PATCHED_AML& ACPIPatchedAMLTmp = ACPIPatchedAML[idx];
if ( ACPIPatchedAMLTmp.FileName == gSettings.ACPI.SortedACPI[Index] && ACPIPatchedAMLTmp.MenuItem.BValue) {
if (BVALUE_ATTEMPTED != ACPIPatchedAMLTmp.MenuItem.BValue)
DBG("Disabled: %s, skip\n", ACPIPatchedAMLTmp.FileName.c_str());
ACPIPatchedAMLTmp.MenuItem.BValue = BVALUE_ATTEMPTED;
break;
}
}
if ( idx == ACPIPatchedAML.size() ) { // NULL when not disabled
DBG("Inserting table[%llu]:%s from %ls\\%ls: ", Index, gSettings.ACPI.SortedACPI[Index].c_str(), selfOem.getConfigDirFullPath().wc_str(), acpiPathUnderOem.wc_str());
if (LoadPatchedAML(selfOem.getConfigDir(), acpiPathUnderOem, XStringW(gSettings.ACPI.SortedACPI[Index]).wc_str(), Pass)) {
// avoid inserting table again on second pass
for ( idx = 0 ; idx < ACPIPatchedAML.size() ; ++idx) {
ACPI_PATCHED_AML& temp2 = ACPIPatchedAML[idx];
if ( temp2.FileName == gSettings.ACPI.SortedACPI[Index] ) {
temp2.MenuItem.BValue = BVALUE_ATTEMPTED;
break;
}
}
}
}
}
} else {
DBG("Unsorted\n");
for ( size_t idx = 0 ; idx < ACPIPatchedAML.size() ; ++idx) {
ACPI_PATCHED_AML& ACPIPatchedAMLTmp = ACPIPatchedAML[idx];
if (!ACPIPatchedAMLTmp.MenuItem.BValue) {
DBG("Inserting %s from %ls\\%ls: ", ACPIPatchedAMLTmp.FileName.c_str(), selfOem.getConfigDirFullPath().wc_str(), acpiPathUnderOem.wc_str());
if (LoadPatchedAML(selfOem.getConfigDir(), acpiPathUnderOem, XStringW(ACPIPatchedAMLTmp.FileName).wc_str(), 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.c_str());
ACPIPatchedAMLTmp.MenuItem.BValue = BVALUE_ATTEMPTED;
}
}
}
//DBG("End: Processing Patched AML(s)\n");
}
}
EFI_STATUS PatchACPI(IN REFIT_VOLUME *Volume, const MacOsVersion& 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;
// constexpr LStringW PathPatched = L"\\EFI\\CL OVER\\ACPI\\patched";
// XStringW PathDsdt; // = L"\\DSDT.aml";
// CHAR16* PatchedAPIC = L"\\EFI\\CL OVER\\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;
XBool DsdtLoaded = false;
XBool NeedUpdate = false;
OPER_REGION *tmpRegion;
// XStringW AcpiOemPath = SWPrintf("%ls\\ACPI\\patched", OEMPath.wc_str());
DbgHeader("PatchACPI");
//try to find in SystemTable
for(Index = 0; Index < gST->NumberOfTableEntries; Index++) {
if( gST->ConfigurationTable[Index].VendorGuid == gEfiAcpi20TableGuid ) {
// Acpi 2.0
RsdPointer = (EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER*)gST->ConfigurationTable[Index].VendorTable;
break;
}
else if( 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%llx\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%llx\n", FadtPointer);
}
Xsdt = NULL;
if (RsdPointer->Revision >=2 && (RsdPointer->XsdtAddress < (UINT64)(UINTN)-1)) {
Xsdt = (XSDT_TABLE*)(UINTN)RsdPointer->XsdtAddress;
// DBG("XSDT 0x%llx\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%llx\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 %llx %llx\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;
// DBG("XSDT = 0x%llx\n", uintptr_t(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 %llu = 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, AppleBiosVendor.c_str(), 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.ACPI.smartUPS==true) {
newFadt->PreferredPmProfile = 3;
} else {
newFadt->PreferredPmProfile = gMobile?2:1; //as calculated before
}
if (GlobalConfig.EnableC6 || gSettings.ACPI.SSDT.EnableISS) {
newFadt->CstCnt = 0x85; //as in Mac
}
if (GlobalConfig.EnableC2) newFadt->PLvl2Lat = 0x65;
if (GlobalConfig.C3Latency > 0) {
newFadt->PLvl3Lat = GlobalConfig.C3Latency;
} else if (GlobalConfig.EnableC4) {
newFadt->PLvl3Lat = 0x3E9;
}
if (GlobalConfig.C3Latency == 0) {
GlobalConfig.C3Latency = newFadt->PLvl3Lat;
}
newFadt->IaPcBootArch = 0x3;
if (gSettings.ACPI.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 (gSettings.Boot.SignatureFixup) {
DBG(" SignatureFixup: 0x%X -> 0x%llX\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.ACPI.ResetAddr == 0) && ((oldLength < 0x80) || (newFadt->ResetReg.Address == 0))) {
newFadt->ResetReg.Address = 0x64;
newFadt->ResetValue = 0xFE;
gSettings.ACPI.ResetAddr = 0x64;
gSettings.ACPI.ResetVal = 0xFE;
} else if (gSettings.ACPI.ResetAddr != 0) {
newFadt->ResetReg.Address = gSettings.ACPI.ResetAddr;
newFadt->ResetValue = gSettings.ACPI.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.ACPI.SlpSmiEnable) {
UINT32 *SlpSmiEn = (UINT32*)((UINTN)(newFadt->Pm1aEvtBlk) + 0x30);
UINT32 Value = *SlpSmiEn;
Value &= ~ bit(4);
*SlpSmiEn = Value;
}
}
//Get regions from BIOS DSDT
if ((gSettings.ACPI.DSDT.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;
XStringW acpiPath = SWPrintf("ACPI\\patched\\%ls", gSettings.ACPI.DSDT.DsdtName.wc_str());
if ( selfOem.oemDirExists() ) {
if ( FileExists(&selfOem.getOemDir(), acpiPath) ) {
DBG("DSDT found in Clover volume OEM folder: %ls\\%ls\n", selfOem.getOemFullPath().wc_str(), acpiPath.wc_str());
Status = egLoadFile(&selfOem.getOemDir(), acpiPath.wc_str(), &buffer, &bufferLen);
//REVIEW: memory leak... buffer
}
}
//Slice: the idea was from past
// first priority DSDT.aml from the root of booted volume. It allows to keep different DSDT for different systems
// second priority is DSDT from OEM folder
// third priority is {Clover folder}/ACPI/patched/DSDT*.aml choosen from GUI.
XStringW PathDsdt = SWPrintf("\\%ls", gSettings.ACPI.DSDT.DsdtName.wc_str());
if (EFI_ERROR(Status) && FileExists(Volume->RootDir, PathDsdt)) {
DBG("DSDT found in booted volume\n");
Status = egLoadFile(Volume->RootDir, PathDsdt.wc_str(), &buffer, &bufferLen);
}
// Jief : may I suggest to remove that. Loading from outside of OemPath might be confusing
if ( EFI_ERROR(Status) && FileExists(&self.getCloverDir(), acpiPath) ) {
DBG("DSDT found in Clover volume: %ls\\%ls\n", self.getCloverDirFullPath().wc_str(), acpiPath.wc_str());
Status = egLoadFile(&self.getCloverDir(), acpiPath.wc_str(), &buffer, &bufferLen);
}
//
//apply DSDT loaded from a file into buffer
//else FADT will contain old BIOS DSDT
//
DsdtLoaded = false;
if (!EFI_ERROR(Status)) {
// 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);
//once we copied buffer to other place we can free the buffer
FadtPointer->Dsdt = (UINT32)dsdt;
FadtPointer->XDsdt = dsdt;
FixChecksum(&FadtPointer->Header);
DsdtLoaded = true;
}
}
if(buffer) FreePool(buffer); //the buffer is allocated if egLoadFile() is success. Else the pointer must be nullptr
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);
//Slice: new buffer is greater then origin by 12.5%. It is dirty hack but we live with it
// there will be the sense reallocate buffer if one patch requires increasing the buffer
// this is headache to predict how many new bytes we need.
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); //can't free TableHeader because we are not allocate it
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.ACPI.DSDT.DebugDSDT) {
TableHeader = (EFI_ACPI_DESCRIPTION_HEADER*)(UINTN)FadtPointer->XDsdt;
bufferLen = TableHeader->Length;
DBG("Output DSDT before patch to %ls\\ACPI\\origin\\DSDT-or.aml\n", selfOem.getConfigDirFullPath().wc_str());
Status = egSaveFile(&selfOem.getConfigDir(), L"ACPI\\origin\\DSDT-or.aml", (UINT8*)(UINTN)FadtPointer->XDsdt, bufferLen);
}
//native DSDT or loaded we want to apply autoFix to this
// if (gSettings.ACPI.DSDT.FixDsdt) { //fix even with zero mask because we want to know PCIRootUID and count(?)
DBG("Apply DsdtFixMask=0x%08X\n", gSettings.ACPI.DSDT.FixDsdt);
// DBG(" drop _DSM mask=0x%04hX\n", dropDSM);
FixBiosDsdt((UINT8*)(UINTN)FadtPointer->XDsdt, FadtPointer, OSVersion);
if (gSettings.ACPI.DSDT.DebugDSDT) {
for (Index=0; Index < 60; Index++) {
XStringW DsdtPatchedName = SWPrintf("ACPI\\origin\\DSDT-pa%llu.aml", Index);
if(!FileExists(&selfOem.getConfigDir(), DsdtPatchedName)){
Status = egSaveFile(&selfOem.getConfigDir(), DsdtPatchedName.wc_str(), (UINT8*)(UINTN)FadtPointer->XDsdt, bufferLen);
if (!EFI_ERROR(Status)) {
break;
}
}
}
if (EFI_ERROR(Status)) {
DBG("...saving DSDT failed with status=%s\n", efiStrError(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(L"ACPI\\patched"_XSW, AUTOMERGE_PASS1);
// Drop tables
if (GlobalConfig.ACPIDropTables) {
ACPI_DROP_TABLE *DropTable;
DbgHeader("ACPIDropTables");
for (DropTable = GlobalConfig.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 (GlobalConfig.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(L"ACPI\\patched"_XSW, 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=%llu\n", ApicCPUNum);
//reallocate table
if (gSettings.ACPI.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%02hhX to 0x%02hhX\n", ProcLocalApic->AcpiProcessorId, acpi_cpu_processor_id[Index]);
ProcLocalApic->AcpiProcessorId = acpi_cpu_processor_id[Index];
} else {
DBG("AcpiProcessorId: 0x%02hhX\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(&self.getSelfRootDir(), 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.ACPI.SSDT.Generate.GeneratePStates || gSettings.ACPI.SSDT.Generate.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=%s\n", efiStrError(Status));
}
}
if (gSettings.ACPI.SSDT.Generate.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=%s\n", efiStrError(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;
}
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 (
CONST CHAR16 *PathPatched,
CONST CHAR16 *TableName,
UINT8 **Buffer,
UINTN *BufferLen
)
{
EFI_STATUS Status;
Status = EFI_NOT_FOUND;
// checking \EFI\ACPI\patched dir
XStringW TmpStr = SWPrintf("%ls\\%ls", PathPatched, TableName);
if (FileExists(&self.getCloverDir(), TmpStr)) {
DBG("found %ls\n", TmpStr.wc_str());
Status = egLoadFile(&self.getCloverDir(), TmpStr.wc_str(), Buffer, BufferLen);
}
return Status;
}
/**
* Searches for DSDT in AcpiOemPath or PathPatched dirs and inserts it
* to FadtPointer if found.
*/
EFI_STATUS LoadAndInjectDSDT(CONST 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.ACPI.DSDT.DsdtName.wc_str(), &Buffer, &BufferLen);
if (!EFI_ERROR(Status)) {
// loaded - allocate EfiACPIReclaim
DBG("Loaded DSDT at \\%ls\\%ls\\%ls\n", self.getCloverDirFullPath().wc_str(), PathPatched, gSettings.ACPI.DSDT.DsdtName.wc_str());
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%llX injected to FADT 0x%llx\n", Dsdt, (UINTN)FadtPointer);
}
if(Buffer) 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(CONST CHAR16 *PathPatched,
CONST 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 %ls 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.6s', TabId '%8.8s'", (CHAR8*)&Rsdt->Header.OemId, (CHAR8*)&Rsdt->Header.OemTableId);
CopyMem(&Rsdt->Header.OemId, &TableHeader->OemId, 6);
Rsdt->Header.OemTableId = TableHeader->OemTableId;
DBG(" to OEMid '%6.6s', TabId '%8.8s'\n", (CHAR8*)&Rsdt->Header.OemId, (CHAR8*)&Rsdt->Header.OemTableId);
}
if (Xsdt) {
DBG("SLIC: Xsdt OEMid '%6.6s', TabId '%8.8s'", (CHAR8*)&Xsdt->Header.OemId, (CHAR8*)&Xsdt->Header.OemTableId);
CopyMem(&Xsdt->Header.OemId, &TableHeader->OemId, 6);
Xsdt->Header.OemTableId = TableHeader->OemTableId;
DBG(" to OEMid '%6.6s', TabId '%8.8s'\n", (CHAR8*)&Xsdt->Header.OemId, (CHAR8*)&Xsdt->Header.OemTableId);
}
}
} else {
DBG("Insert return status %s\n", efiStrError(Status));
}
FreePool(Buffer);
} // if table loaded
return Status;
}
/**
* Patches UEFI ACPI tables with tables found in OsSubdir.
*/
EFI_STATUS PatchACPI_OtherOS(CONST CHAR16* OsSubdir, XBool 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;
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%llX\n", (uintptr_t)RsdPointer);
} else {
Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (void **) &RsdPointer);
if (RsdPointer != NULL) {
DBG("Found Acpi 1.0 RSDP 0x%llX\n", (uintptr_t)RsdPointer);
}
}
// if RSDP not found - quit
if (!RsdPointer) {
return Status;
}
//
// 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 0x%llX\n", (UINTN)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 0x%llX\n", (UINTN)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 = 0x%llX\n", (UINTN)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
XStringW PathPatched;
if ( selfOem.oemDirExists() ) {
PathPatched = SWPrintf("%ls\\ACPI\\%ls", selfOem.getOemPathRelToSelfDir().wc_str(), OsSubdir);
if ( !FileExists(&self.getCloverDir(), PathPatched) ) {
PathPatched.setEmpty();
}
}
if ( PathPatched.isEmpty() ) {
PathPatched = SWPrintf("ACPI\\%ls", OsSubdir);
if (!FileExists(&self.getCloverDir(), PathPatched)) {
DBG("Dir '\\%ls\\%ls' not found. No patching will be done.\n", self.getCloverDirFullPath().wc_str(), PathPatched.wc_str());
return EFI_NOT_FOUND;
}
}
//
// Inject DSDT
//
/* Status = */LoadAndInjectDSDT(PathPatched.wc_str(), 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);
}
*/
if (GlobalConfig.ACPIDropTables) {
ACPI_DROP_TABLE *DropTable;
DbgHeader("ACPIDropTables");
for (DropTable = GlobalConfig.ACPIDropTables; DropTable; DropTable = DropTable->Next) {
// only for tables that have OtherOS true
if (DropTable->OtherOS && 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);
}
}
}
//
// find and inject other ACPI tables
//
DirIterOpen(&self.getCloverDir(), PathPatched.wc_str(), &DirIter);
while (DirIterNext(&DirIter, 2, L"*.aml", &DirEntry)) {
if (DirEntry->FileName[0] == L'.') {
continue;
}
if (StrStr(DirEntry->FileName, L"DSDT")) {
continue;
}
LoadAndInjectAcpiTable(PathPatched.wc_str(), DirEntry->FileName);
}
/*Status = */DirIterClose(&DirIter);
// remove NULL entries from RSDT and XSDT
PostCleanupRSDT();
PostCleanupXSDT();
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink