/**
Entry point for Acpi platform driver.
@param[in] ImageHandle A handle for the image that is initializing this driver.
@param[in] SystemTable A pointer to the EFI system table.
@retval EFI_SUCCESS Driver initialized successfully.
@retval EFI_LOAD_ERROR Failed to Initialize or has been loaded.
@retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
**/
EFI_STATUS
EFIAPI
AcpiPlatformEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_STATUS AcpiStatus;
EFI_ACPI_SUPPORT_PROTOCOL *AcpiSupport;
EFI_FIRMWARE_VOLUME_PROTOCOL *FwVol;
INTN Instance;
EFI_ACPI_COMMON_HEADER *CurrentTable;
UINTN TableHandle;
UINT32 FvStatus;
UINT32 Size;
EFI_EVENT Event;
EFI_ACPI_TABLE_VERSION TableVersion;
UINTN VarSize;
UINTN SysCfgSize;
EFI_HANDLE Handle;
EFI_PS2_POLICY_PROTOCOL *Ps2Policy;
EFI_PEI_HOB_POINTERS GuidHob;
UINT8 PortData;
EFI_MP_SERVICES_PROTOCOL *MpService;
UINTN MaximumNumberOfCPUs;
UINTN NumberOfEnabledCPUs;
UINT32 Data32;
PCH_STEPPING pchStepping;
mFirstNotify = FALSE;
TableVersion = EFI_ACPI_TABLE_VERSION_2_0;
Instance = 0;
CurrentTable = NULL;
TableHandle = 0;
Data32 = 0;
//
// Update HOB variable for PCI resource information.
// Get the HOB list. If it is not present, then ASSERT.
//
GuidHob.Raw = GetHobList ();
if (GuidHob.Raw != NULL) {
if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {
mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);
}
}
//
// Search for the Memory Configuration GUID HOB. If it is not present, then
// there's nothing we can do. It may not exist on the update path.
//
VarSize = sizeof(SYSTEM_CONFIGURATION);
Status = gRT->GetVariable(
L"Setup",
&mSystemConfigurationGuid,
NULL,
&VarSize,
&mSystemConfiguration
);
ASSERT_EFI_ERROR (Status);
//
// Find the AcpiSupport protocol.
//
Status = LocateSupportProtocol (&gEfiAcpiSupportProtocolGuid, (VOID **) &AcpiSupport, 0);
ASSERT_EFI_ERROR (Status);
//
// Locate the firmware volume protocol.
//
Status = LocateSupportProtocol (&gEfiFirmwareVolumeProtocolGuid, (VOID **) &FwVol, 1);
ASSERT_EFI_ERROR (Status);
//
// Read the current system configuration variable store.
//
SysCfgSize = sizeof(SYSTEM_CONFIGURATION);
Status = gRT->GetVariable (
L"Setup",
&gEfiNormalSetupGuid,
NULL,
&SysCfgSize,
&mSystemConfig
);
Status = EFI_SUCCESS;
Instance = 0;
//
// TBD: Need re-design based on the ValleyTrail platform.
//
Status = gBS->LocateProtocol (
&gEfiMpServiceProtocolGuid,
NULL,
(VOID **) &MpService
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Determine the number of processors.
//
MpService->GetNumberOfProcessors (
MpService,
&MaximumNumberOfCPUs,
&NumberOfEnabledCPUs
);
//
// Allocate and initialize the NVS area for SMM and ASL communication.
//
Status = gBS->AllocatePool (
EfiACPIMemoryNVS,
sizeof (EFI_GLOBAL_NVS_AREA),
(void **)&mGlobalNvsArea.Area
);
ASSERT_EFI_ERROR (Status);
gBS->SetMem (
mGlobalNvsArea.Area,
sizeof (EFI_GLOBAL_NVS_AREA),
0
);
DEBUG((EFI_D_ERROR, "mGlobalNvsArea.Area is at 0x%X\n", mGlobalNvsArea.Area));
//
// Update global NVS area for ASL and SMM init code to use.
//
mGlobalNvsArea.Area->ApicEnable = 1;
mGlobalNvsArea.Area->EmaEnable = 0;
mGlobalNvsArea.Area->NumberOfBatteries = 1;
mGlobalNvsArea.Area->BatteryCapacity0 = 100;
mGlobalNvsArea.Area->BatteryStatus0 = 84;
mGlobalNvsArea.Area->OnboardCom = 1;
mGlobalNvsArea.Area->IdeMode = 0;
mGlobalNvsArea.Area->PowerState = 0;
mGlobalNvsArea.Area->LogicalProcessorCount = (UINT8)NumberOfEnabledCPUs;
mGlobalNvsArea.Area->PassiveThermalTripPoint = mSystemConfiguration.PassiveThermalTripPoint;
mGlobalNvsArea.Area->PassiveTc1Value = mSystemConfiguration.PassiveTc1Value;
mGlobalNvsArea.Area->PassiveTc2Value = mSystemConfiguration.PassiveTc2Value;
mGlobalNvsArea.Area->PassiveTspValue = mSystemConfiguration.PassiveTspValue;
mGlobalNvsArea.Area->CriticalThermalTripPoint = mSystemConfiguration.CriticalThermalTripPoint;
mGlobalNvsArea.Area->IgdPanelType = mSystemConfiguration.IgdFlatPanel;
mGlobalNvsArea.Area->IgdPanelScaling = mSystemConfiguration.PanelScaling;
mGlobalNvsArea.Area->IgdSciSmiMode = 0;
mGlobalNvsArea.Area->IgdTvFormat = 0;
mGlobalNvsArea.Area->IgdTvMinor = 0;
mGlobalNvsArea.Area->IgdSscConfig = 1;
mGlobalNvsArea.Area->IgdBiaConfig = mSystemConfiguration.IgdLcdIBia;
mGlobalNvsArea.Area->IgdBlcConfig = mSystemConfiguration.IgdLcdIGmchBlc;
mGlobalNvsArea.Area->IgdDvmtMemSize = mSystemConfiguration.IgdDvmt50TotalAlloc;
mGlobalNvsArea.Area->IgdPAVP = mSystemConfiguration.PavpMode;
mGlobalNvsArea.Area->AlsEnable = mSystemConfiguration.AlsEnable;
mGlobalNvsArea.Area->BacklightControlSupport = 2;
mGlobalNvsArea.Area->BrightnessPercentage = 100;
mGlobalNvsArea.Area->IgdState = 1;
mGlobalNvsArea.Area->LidState = 1;
mGlobalNvsArea.Area->DeviceId1 = 0x80000100 ;
mGlobalNvsArea.Area->DeviceId2 = 0x80000400 ;
mGlobalNvsArea.Area->DeviceId3 = 0x80000200 ;
mGlobalNvsArea.Area->DeviceId4 = 0x04;
mGlobalNvsArea.Area->DeviceId5 = 0x05;
mGlobalNvsArea.Area->NumberOfValidDeviceId = 4 ;
mGlobalNvsArea.Area->CurrentDeviceList = 0x0F ;
mGlobalNvsArea.Area->PreviousDeviceList = 0x0F ;
mGlobalNvsArea.Area->UartSelection = mSystemConfiguration.UartInterface;
mGlobalNvsArea.Area->PcuUart1Enable = mSystemConfiguration.PcuUart1;
mGlobalNvsArea.Area->NativePCIESupport = 1;
//
// Update BootMode: 0:ACPI mode; 1:PCI mode
//
mGlobalNvsArea.Area->LpssSccMode = mSystemConfiguration.LpssPciModeEnabled;
if (mSystemConfiguration.LpssMipiHsi == 0) {
mGlobalNvsArea.Area->MipiHsiAddr = 0;
mGlobalNvsArea.Area->MipiHsiLen = 0;
mGlobalNvsArea.Area->MipiHsi1Addr = 0;
mGlobalNvsArea.Area->MipiHsi1Len = 0;
}
//
// Platform Flavor
//
mGlobalNvsArea.Area->PlatformFlavor = mPlatformInfo->PlatformFlavor;
//
// Update the Platform id
//
mGlobalNvsArea.Area->BoardID = mPlatformInfo->BoardId;
//
// Update the Board Revision
//
mGlobalNvsArea.Area->FabID = mPlatformInfo->BoardRev;
//
// Update SOC Stepping
//
mGlobalNvsArea.Area->SocStepping = (UINT8)(PchStepping());
mGlobalNvsArea.Area->OtgMode = mSystemConfiguration.PchUsbOtg;
pchStepping = PchStepping();
if (mSystemConfiguration.UsbAutoMode == 1) {
//
// Auto mode is enabled.
//
if (PchA0 == pchStepping) {
//
// For A0, EHCI is enabled as default.
//
mSystemConfiguration.PchUsb20 = 1;
mSystemConfiguration.PchUsb30Mode = 0;
mSystemConfiguration.UsbXhciSupport = 0;
DEBUG ((EFI_D_INFO, "EHCI is enabled as default. SOC 0x%x\n", pchStepping));
} else {
//
// For A1 and later, XHCI is enabled as default.
//
mSystemConfiguration.PchUsb20 = 0;
mSystemConfiguration.PchUsb30Mode = 1;
mSystemConfiguration.UsbXhciSupport = 1;
DEBUG ((EFI_D_INFO, "XHCI is enabled as default. SOC 0x%x\n", pchStepping));
}
}
mGlobalNvsArea.Area->XhciMode = mSystemConfiguration.PchUsb30Mode;
mGlobalNvsArea.Area->Stepping = mPlatformInfo->IchRevision;
//
// Override invalid Pre-Boot Driver and XhciMode combination.
//
if ((mSystemConfiguration.UsbXhciSupport == 0) && (mSystemConfiguration.PchUsb30Mode == 3)) {
mGlobalNvsArea.Area->XhciMode = 2;
}
if ((mSystemConfiguration.UsbXhciSupport == 1) && (mSystemConfiguration.PchUsb30Mode == 2)) {
mGlobalNvsArea.Area->XhciMode = 3;
}
DEBUG ((EFI_D_ERROR, "ACPI NVS XHCI:0x%x\n", mGlobalNvsArea.Area->XhciMode));
mGlobalNvsArea.Area->PmicEnable = GLOBAL_NVS_DEVICE_DISABLE;
mGlobalNvsArea.Area->BatteryChargingSolution = GLOBAL_NVS_DEVICE_DISABLE;
mGlobalNvsArea.Area->ISPDevSel = mSystemConfiguration.ISPDevSel;
mGlobalNvsArea.Area->LpeEnable = mSystemConfiguration.Lpe;
if (mSystemConfiguration.ISPEn == 0) {
mGlobalNvsArea.Area->ISPDevSel = GLOBAL_NVS_DEVICE_DISABLE;
}
mGlobalNvsArea.Area->WittEnable = mSystemConfiguration.WittEnable;
mGlobalNvsArea.Area->UtsEnable = mSystemConfiguration.UtsEnable;
mGlobalNvsArea.Area->SarEnable = mSystemConfiguration.SAR1;
mGlobalNvsArea.Area->ReservedO = 1;
SettingI2CTouchAddress();
mGlobalNvsArea.Area->IdleReserve= mSystemConfiguration.IdleReserve;
//
// Read BMBOUND and store it in GlobalNVS to pass into ASL.
//
// BUGBUG: code was moved into silicon reference code.
//
if (mSystemConfiguration.eMMCBootMode== 1) {
//
// Auto detect mode.
//
DEBUG ((EFI_D_ERROR, "Auto detect mode------------start\n"));
//
// Silicon Steppings.
//
switch (PchStepping()) {
case PchA0: // A0/A1
case PchA1:
DEBUG ((EFI_D_ERROR, "SOC A0/A1: eMMC 4.41 Configuration\n"));
mSystemConfiguration.LpsseMMCEnabled = 1;
mSystemConfiguration.LpsseMMC45Enabled = 0;
break;
case PchB0: // B0 and later.
default:
DEBUG ((EFI_D_ERROR, "SOC B0 and later: eMMC 4.5 Configuration\n"));
mSystemConfiguration.LpsseMMCEnabled = 0;
mSystemConfiguration.LpsseMMC45Enabled = 1;
break;
}
} else if (mSystemConfiguration.eMMCBootMode == 2) {
//
// eMMC 4.41
//
DEBUG ((EFI_D_ERROR, "Force to eMMC 4.41 Configuration\n"));
mSystemConfiguration.LpsseMMCEnabled = 1;
mSystemConfiguration.LpsseMMC45Enabled = 0;
} else if (mSystemConfiguration.eMMCBootMode == 3) {
//
// eMMC 4.5
//
DEBUG ((EFI_D_ERROR, "Force to eMMC 4.5 Configuration\n"));
mSystemConfiguration.LpsseMMCEnabled = 0;
mSystemConfiguration.LpsseMMC45Enabled = 1;
} else {
//
// Disable eMMC controllers.
//
DEBUG ((EFI_D_ERROR, "Disable eMMC controllers\n"));
mSystemConfiguration.LpsseMMCEnabled = 0;
mSystemConfiguration.LpsseMMC45Enabled = 0;
}
mGlobalNvsArea.Area->emmcVersion = 0;
if (mSystemConfiguration.LpsseMMCEnabled) {
DEBUG ((EFI_D_ERROR, "mGlobalNvsArea.Area->emmcVersion = 0\n"));
mGlobalNvsArea.Area->emmcVersion = 0;
}
if (mSystemConfiguration.LpsseMMC45Enabled) {
DEBUG ((EFI_D_ERROR, "mGlobalNvsArea.Area->emmcVersion = 1\n"));
mGlobalNvsArea.Area->emmcVersion = 1;
}
mGlobalNvsArea.Area->SdCardRemovable = mSystemConfiguration.SdCardRemovable;
//
// Microsoft IOT
//
if ((mSystemConfiguration.LpssHsuart0FlowControlEnabled == 1) && \
(mSystemConfiguration.LpssPwm0Enabled == 0) && \
(mSystemConfiguration.LpssPwm1Enabled == 0)) {
mGlobalNvsArea.Area->MicrosoftIoT = GLOBAL_NVS_DEVICE_ENABLE;
DEBUG ((EFI_D_ERROR, "JP1 is set to be MSFT IOT configuration.\n"));
} else {
mGlobalNvsArea.Area->MicrosoftIoT = GLOBAL_NVS_DEVICE_DISABLE;
DEBUG ((EFI_D_ERROR, "JP1 is not set to be MSFT IOT configuration.\n"));
}
//
// SIO related option.
//
Status = gBS->LocateProtocol (&gEfiCpuIoProtocolGuid, NULL, (void **)&mCpuIo);
ASSERT_EFI_ERROR (Status);
mGlobalNvsArea.Area->WPCN381U = GLOBAL_NVS_DEVICE_DISABLE;
mGlobalNvsArea.Area->DockedSioPresent = GLOBAL_NVS_DEVICE_DISABLE;
if (mGlobalNvsArea.Area->DockedSioPresent != GLOBAL_NVS_DEVICE_ENABLE) {
//
// Check ID for SIO WPCN381U.
//
Status = mCpuIo->Io.Read (
mCpuIo,
EfiCpuIoWidthUint8,
WPCN381U_CONFIG_INDEX,
1,
&PortData
);
ASSERT_EFI_ERROR (Status);
if (PortData != 0xFF) {
PortData = 0x20;
Status = mCpuIo->Io.Write (
mCpuIo,
EfiCpuIoWidthUint8,
WPCN381U_CONFIG_INDEX,
1,
&PortData
);
ASSERT_EFI_ERROR (Status);
Status = mCpuIo->Io.Read (
mCpuIo,
EfiCpuIoWidthUint8,
WPCN381U_CONFIG_DATA,
1,
&PortData
);
ASSERT_EFI_ERROR (Status);
if ((PortData == WPCN381U_CHIP_ID) || (PortData == WDCP376_CHIP_ID)) {
mGlobalNvsArea.Area->WPCN381U = GLOBAL_NVS_DEVICE_ENABLE;
mGlobalNvsArea.Area->OnboardCom = GLOBAL_NVS_DEVICE_ENABLE;
mGlobalNvsArea.Area->OnboardComCir = GLOBAL_NVS_DEVICE_DISABLE;
}
}
}
//
// Get Ps2 policy to set. Will be use if present.
//
Status = gBS->LocateProtocol (
&gEfiPs2PolicyProtocolGuid,
NULL,
(VOID **)&Ps2Policy
);
if (!EFI_ERROR (Status)) {
Status = Ps2Policy->Ps2InitHardware (ImageHandle);
}
mGlobalNvsArea.Area->SDIOMode = mSystemConfiguration.LpssSdioMode;
Handle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&Handle,
&gEfiGlobalNvsAreaProtocolGuid,
&mGlobalNvsArea,
NULL
);
//
// Read tables from the storage file.
//
while (!EFI_ERROR (Status)) {
CurrentTable = NULL;
Status = FwVol->ReadSection (
FwVol,
&gEfiAcpiTableStorageGuid,
EFI_SECTION_RAW,
Instance,
(VOID **) &CurrentTable,
(UINTN *) &Size,
&FvStatus
);
if (!EFI_ERROR (Status)) {
//
// Allow platform specific code to reject the table or update it.
//
AcpiStatus = AcpiPlatformHooksIsActiveTable (CurrentTable);
if (!EFI_ERROR (AcpiStatus)) {
//
// Perform any table specific updates.
//
AcpiStatus = PlatformUpdateTables (CurrentTable);
if (!EFI_ERROR (AcpiStatus)) {
//
// Add the table.
//
TableHandle = 0;
AcpiStatus = AcpiSupport->SetAcpiTable (
AcpiSupport,
CurrentTable,
TRUE,
TableVersion,
&TableHandle
);
ASSERT_EFI_ERROR (AcpiStatus);
}
}
//
// Increment the instance.
//
Instance++;
}
}
Status = EfiCreateEventReadyToBootEx (
TPL_NOTIFY,
OnReadyToBoot,
NULL,
&Event
);
//
// Finished.
//
return EFI_SUCCESS;
}
EFI_STATUS
GetRawImage (
IN EFI_GUID *NameGuid,
IN OUT VOID **Buffer,
IN OUT UINTN *Size
)
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN HandleCount;
UINTN Index;
EFI_FIRMWARE_VOLUME_PROTOCOL *Fv;
UINT32 AuthenticationStatus;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolumeProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status) || HandleCount == 0) {
return EFI_NOT_FOUND;
}
//
// Find desired image in all Fvs
//
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol(
HandleBuffer[Index],
&gEfiFirmwareVolumeProtocolGuid,
(VOID **) &Fv
);
if ( EFI_ERROR ( Status ) ) {
return EFI_LOAD_ERROR;
}
//
// Try a raw file
//
*Buffer = NULL;
*Size = 0;
Status = Fv->ReadSection (
Fv,
NameGuid,
EFI_SECTION_RAW,
0,
Buffer,
Size,
&AuthenticationStatus
);
if ( !EFI_ERROR ( Status )) {
break;
}
}
if ( Index >= HandleCount ) {
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
VOID
EFIAPI
FchAcpiReadyToBootInit (
IN EFI_EVENT Event,
IN VOID *Context
)
{
UINTN Index;
INTN Instance;
UINTN Size;
UINTN NumberOfHandles;
UINTN TableHandle;
UINTN TableSize;
UINT32 FvStatus;
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
EFI_HANDLE Handle;
EFI_FV_FILETYPE FileType;
EFI_FV_FILE_ATTRIBUTES Attributes;
EFI_ACPI_COMMON_HEADER *CurrentTable;
EFI_ACPI_DESCRIPTION_HEADER *FchAcpiBlockPtr = NULL;
EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
FCH_ACPI_PROTOCOL *FchAcpiProtocol;
EFI_FIRMWARE_VOLUME_PROTOCOL *FwVol = NULL;
Status = gBS->LocateProtocol (
&gEfiAcpiTableProtocolGuid,
NULL,
&AcpiTableProtocol
);
if (EFI_ERROR (Status)) {
return;
}
Status = gBS->LocateProtocol (
&gFchAcpiProtocolGuid,
NULL,
&FchAcpiProtocol
);
if (EFI_ERROR (Status)) {
return;
}
FvStatus = 0;
//
// Locate protocol.
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolumeProtocolGuid,
NULL,
&NumberOfHandles,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return;
}
//
// Looking for FV with FCH ACPI Data Block file
//
for (Index = 0; Index < NumberOfHandles; Index++) {
//
// Get the protocol on this handle
// This should not fail because of LocateHandleBuffer
//
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiFirmwareVolumeProtocolGuid,
(VOID**) &FwVol
);
ASSERT_EFI_ERROR (Status);
//
// See if it has the ACPI storage file
//
Size = 0;
FvStatus = 0;
Status = FwVol->ReadFile (
FwVol,
&gAmdFchAcpiGuid,
NULL,
&Size,
&FileType,
&Attributes,
&FvStatus
);
//
// If we found it, then we are done
//
if (Status == EFI_SUCCESS) {
break;
}
}
//
// Read tables from the storage file.
//
Instance = 0;
CurrentTable = NULL;
while (Status == EFI_SUCCESS) {
Status = FwVol->ReadSection (
FwVol,
&gAmdFchAcpiGuid,
EFI_SECTION_RAW,
Instance,
&CurrentTable,
&Size,
&FvStatus
);
if (!EFI_ERROR (Status)) {
//
// Check the table ID to modify the table
//
if (((EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable)->OemTableId == EFI_SIGNATURE_64 ('F', 'C', 'H', 'A', 'C', 'P', 'I', 0)) {
FchAcpiBlockPtr = (EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable;
Status = FchUpdateAcpiDataTable (FchAcpiProtocol, &FchAcpiBlockPtr);
TableHandle = 0;
TableSize = FchAcpiBlockPtr->Length;
//
// Install ACPI table
//
Status = AcpiTableProtocol->InstallAcpiTable (
AcpiTableProtocol,
FchAcpiBlockPtr,
TableSize,
&TableHandle
);
//
// Free memory allocated by ReadSection
//
gBS->FreePool (FchAcpiBlockPtr);
if (EFI_ERROR (Status)) {
return;
}
}
//
// Increment the instance
//
Instance++;
CurrentTable = NULL;
}
}
//
// Our exit status is determined by the success of the previous operations
// If the protocol was found, Instance already points to it.
//
//
// Free any allocated buffers
//
gBS->FreePool (HandleBuffer);
Handle = NULL;
Status = gBS->InstallProtocolInterface (
&Handle,
&gFchAcpiTableInstallGuid,
EFI_NATIVE_INTERFACE,
NULL
);
if (EFI_ERROR (Status)) {
return;
}
}
VOID
EFIAPI
FchD3ColdAcpiInstallNotify (
IN EFI_EVENT Event,
IN VOID *Context
)
{
UINTN Index;
INTN Instance;
UINTN Size;
UINTN NumberOfHandles;
UINTN TableHandle;
UINTN TableSize;
UINT32 FvStatus;
BOOLEAN HwReducedAcpi;
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
EFI_FV_FILETYPE FileType;
EFI_FV_FILE_ATTRIBUTES Attributes;
EFI_ACPI_COMMON_HEADER *CurrentTable;
EFI_ACPI_DESCRIPTION_HEADER *FchD3ColdAcpiBlockPtr = NULL;
EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
FCH_ACPI_PROTOCOL *FchAcpiProtocol;
FCH_INIT_PROTOCOL *FchInitProtocol;
EFI_FIRMWARE_VOLUME_PROTOCOL *FwVol = NULL;
EFI_ACPI_SUPPORT_PROTOCOL *AcpiSupport = NULL;
EFI_ACPI_DESCRIPTION_HEADER *Table;
EFI_ACPI_TABLE_VERSION Version;
EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *Fadt;
Status = gBS->LocateProtocol (
&gEfiAcpiTableProtocolGuid,
NULL,
&AcpiTableProtocol
);
if (EFI_ERROR (Status)) {
return;
}
Status = gBS->LocateProtocol (
&gFchAcpiProtocolGuid,
NULL,
&FchAcpiProtocol
);
if (EFI_ERROR (Status)) {
return;
}
Status = gBS->LocateProtocol (
&gFchInitProtocolGuid,
NULL,
&FchInitProtocol
);
if (EFI_ERROR (Status)) {
return;
}
HwReducedAcpi = FchInitProtocol->FchPolicy.Misc.FchCsSupport.FchCsHwReduced;
FvStatus = 0;
//
// Locate protocol.
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolumeProtocolGuid,
NULL,
&NumberOfHandles,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return;
}
//
// Looking for FV with FCH ACPI Data Block file
//
for (Index = 0; Index < NumberOfHandles; Index++) {
//
// Get the protocol on this handle
// This should not fail because of LocateHandleBuffer
//
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiFirmwareVolumeProtocolGuid,
(VOID**) &FwVol
);
ASSERT_EFI_ERROR (Status);
//
// See if it has the ACPI storage file
//
Size = 0;
FvStatus = 0;
Status = FwVol->ReadFile (
FwVol,
&gAmdFchD3ColdAcpiGuid,
NULL,
&Size,
&FileType,
&Attributes,
&FvStatus
);
//
// If we found it, then we are done
//
if (Status == EFI_SUCCESS) {
break;
}
}
//
// Read tables from the storage file.
//
Instance = 0;
CurrentTable = NULL;
while (Status == EFI_SUCCESS) {
Status = FwVol->ReadSection (
FwVol,
&gAmdFchD3ColdAcpiGuid,
EFI_SECTION_RAW,
Instance,
&CurrentTable,
&Size,
&FvStatus
);
if (!EFI_ERROR (Status)) {
//
// Check the table ID to modify the table
//
if (((EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable)->OemTableId == EFI_SIGNATURE_64 ('F', 'C', 'H', 'C', 'S', 'D', '3', 0)) {
FchD3ColdAcpiBlockPtr = (EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable;
Status = FchD3ColdUpdateAcpiTable (FchAcpiProtocol, &FchD3ColdAcpiBlockPtr);
TableHandle = 0;
TableSize = FchD3ColdAcpiBlockPtr->Length;
//
// Install ACPI table
//
Status = AcpiTableProtocol->InstallAcpiTable (
AcpiTableProtocol,
FchD3ColdAcpiBlockPtr,
TableSize,
&TableHandle
);
//
// Free memory allocated by ReadSection
//
gBS->FreePool (CurrentTable);
if (EFI_ERROR (Status)) {
return;
}
}
//
// Increment the instance
//
Instance++;
CurrentTable = NULL;
}
}
//
// Our exit status is determined by the success of the previous operations
// If the protocol was found, Instance already points to it.
//
//
// Free any allocated buffers
//
gBS->FreePool (HandleBuffer);
//set FACP
Status = gBS->LocateProtocol (
&gEfiAcpiSupportGuid,
NULL,
&AcpiSupport
);
if (EFI_ERROR (Status)) {
return;
}
// modify FADT to add HW_REDUCED_ACPI and LOW_POWER_S0_IDLE_CAPABLE flag
//
// Search FADT table
//
Index = 0;
TableHandle = 0;
do {
Table = NULL;
Status = AcpiSupport->GetAcpiTable (
AcpiSupport,
Index,
&Table,
&Version,
&TableHandle
);
if (EFI_ERROR (Status)) {
break;
}
//
// Check Signture and update FADT table
//
if ((Table->Signature == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE) && (Table->Revision == 0x05 )) {
Fadt = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *)Table;
Fadt->Flags |= LOW_POWER_S0_IDLE_CAPABLE;
if (HwReducedAcpi) {
Fadt->Flags |= HW_REDUCED_ACPI;
}
Status = AcpiSupport->SetAcpiTable (
AcpiSupport,
Table,
TRUE,
(EFI_ACPI_TABLE_VERSION_1_0B | EFI_ACPI_TABLE_VERSION_2_0 | EFI_ACPI_TABLE_VERSION_3_0 | EFI_ACPI_TABLE_VERSION_4_0 | EFI_ACPI_TABLE_VERSION_5_0),
&TableHandle
);
}
gBS->FreePool (Table);
Index++;
} while (TRUE);
}
/**
Get VBT data.
@param[in] VbtFileBuffer Pointer to VBT data buffer.
@retval EFI_SUCCESS VBT data was returned.
@retval EFI_NOT_FOUND VBT data not found.
@exception EFI_UNSUPPORTED Invalid signature in VBT data.
**/
EFI_STATUS
GetIntegratedIntelVbtPtr (
OUT VBIOS_VBT_STRUCTURE **VbtFileBuffer
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS VbtAddress = 0;
UINT32 VbtSize = 0;
UINTN FvProtocolCount;
EFI_HANDLE *FvHandles;
EFI_FIRMWARE_VOLUME_PROTOCOL *Fv;
UINTN Index;
UINT32 AuthenticationStatus;
UINT8 *Buffer;
UINTN VbtBufferSize = 0;
Buffer = 0;
FvHandles = NULL;
*VbtFileBuffer = NULL;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolumeProtocolGuid,
NULL,
&FvProtocolCount,
&FvHandles
);
if (!EFI_ERROR (Status)) {
for (Index = 0; Index < FvProtocolCount; Index++) {
Status = gBS->HandleProtocol (
FvHandles[Index],
&gEfiFirmwareVolumeProtocolGuid,
(VOID **) &Fv
);
VbtBufferSize = 0;
Status = Fv->ReadSection (
Fv,
&gBmpImageGuid,
EFI_SECTION_RAW,
0,
(void **)&Buffer,
&VbtBufferSize,
&AuthenticationStatus
);
if (!EFI_ERROR (Status)) {
VbtAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
VbtSize = (UINT32)VbtBufferSize;
Status = EFI_SUCCESS;
break;
}
}
} else {
Status = EFI_NOT_FOUND;
}
if (FvHandles != NULL) {
FreePool(FvHandles);
FvHandles = NULL;
}
//
// Check VBT signature
//
*VbtFileBuffer = (VBIOS_VBT_STRUCTURE *) (UINTN) VbtAddress;
if (*VbtFileBuffer != NULL) {
if ((*((UINT32 *) ((*VbtFileBuffer)->HeaderSignature))) != VBT_SIGNATURE) {
if (*VbtFileBuffer != NULL) {
*VbtFileBuffer = NULL;
}
return EFI_UNSUPPORTED;
}
//
// Check VBT size
//
if ((*VbtFileBuffer)->HeaderVbtSize > VbtBufferSize) {
(*VbtFileBuffer)->HeaderVbtSize = (UINT16) VbtBufferSize;
}
}
return EFI_SUCCESS;
}
CHAR16 *
GetImageName (
EFI_LOADED_IMAGE_PROTOCOL *Image
)
/*++
Routine Description:
Get the image name
Arguments:
Image - Image to search
Returns:
Pointer into the image name if the image name is found,
Otherwise a pointer to NULL.
--*/
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevPath;
EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;
VOID *Buffer;
UINTN BufferSize;
UINT32 AuthenticationStatus;
EFI_GUID *NameGuid;
EFI_FIRMWARE_VOLUME_PROTOCOL *FV;
EFI_FIRMWARE_VOLUME2_PROTOCOL *FV2;
FV = NULL;
FV2 = NULL;
Buffer = NULL;
BufferSize = 0;
if (Image->FilePath == NULL) {
return NULL;
}
DevPath = BdsLibUnpackDevicePath (Image->FilePath);
if (DevPath == NULL) {
return NULL;
}
DevPathNode = DevPath;
while (!IsDevicePathEnd (DevPathNode)) {
//
// Find the Fv File path
//
NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevPathNode);
if (NameGuid != NULL) {
FvFilePath = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevPathNode;
Status = gBS->HandleProtocol (
Image->DeviceHandle,
&gEfiFirmwareVolumeProtocolGuid,
&FV
);
if (!EFI_ERROR (Status)) {
Status = FV->ReadSection (
FV,
&FvFilePath->NameGuid,
EFI_SECTION_USER_INTERFACE,
0,
&Buffer,
&BufferSize,
&AuthenticationStatus
);
if (!EFI_ERROR (Status)) {
break;
}
Buffer = NULL;
} else {
Status = gBS->HandleProtocol (
Image->DeviceHandle,
&gEfiFirmwareVolume2ProtocolGuid,
&FV2
);
if (!EFI_ERROR (Status)) {
Status = FV2->ReadSection (
FV2,
&FvFilePath->NameGuid,
EFI_SECTION_USER_INTERFACE,
0,
&Buffer,
&BufferSize,
&AuthenticationStatus
);
if (!EFI_ERROR (Status)) {
break;
}
Buffer = NULL;
}
}
}
//
// Next device path node
//
DevPathNode = NextDevicePathNode (DevPathNode);
}
gBS->FreePool (DevPath);
return Buffer;
}
