From 3cbfba02fef9dae07a041fdbf2e89611d72d6f90 Mon Sep 17 00:00:00 2001 From: David Wei Date: Mon, 12 Jan 2015 09:37:20 +0000 Subject: Upload BSD-licensed Vlv2TbltDevicePkg and Vlv2DeviceRefCodePkg to https://svn.code.sf.net/p/edk2/code/trunk/edk2/, which are for MinnowBoard MAX open source project. Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: David Wei Reviewed-by: Mike Wu Reviewed-by: Hot Tian git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@16599 6f19259b-4bc3-4df7-8a09-765794883524 --- Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c | 1307 ++++++++++++++++++++ Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.h | 224 ++++ Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.inf | 90 ++ Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.c | 500 ++++++++ Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.h | 132 ++ .../AcpiPlatform/AcpiPlatformHooksLib.h | 96 ++ Vlv2TbltDevicePkg/AcpiPlatform/Osfr.h | 61 + 7 files changed, 2410 insertions(+) create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.h create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.inf create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.c create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.h create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooksLib.h create mode 100644 Vlv2TbltDevicePkg/AcpiPlatform/Osfr.h (limited to 'Vlv2TbltDevicePkg/AcpiPlatform') diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c new file mode 100644 index 000000000..824f23777 --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c @@ -0,0 +1,1307 @@ +/** @file + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + + This program and the accompanying materials are licensed and made available under + + the terms and conditions of the BSD License that accompanies this distribution. + + The full text of the license may be found at + + http://opensource.org/licenses/bsd-license.php. + + + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + + + + + +Module Name: + + AcpiPlatform.c + +Abstract: + + ACPI Platform Driver + + +--*/ + +#include +#include +#include +#include "AcpiPlatform.h" +#include "AcpiPlatformHooks.h" +#include "AcpiPlatformHooksLib.h" +#include "Platform.h" +#include +#include +#include "Osfr.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +CHAR16 EfiPlatformCpuInfoVariable[] = L"PlatformCpuInfo"; +CHAR16 gACPIOSFRModelStringVariableName[] = ACPI_OSFR_MODEL_STRING_VARIABLE_NAME; +CHAR16 gACPIOSFRRefDataBlockVariableName[] = ACPI_OSFR_REF_DATA_BLOCK_VARIABLE_NAME; +CHAR16 gACPIOSFRMfgStringVariableName[] = ACPI_OSFR_MFG_STRING_VARIABLE_NAME; + +EFI_CPU_IO_PROTOCOL *mCpuIo; +#ifndef __GNUC__ +#pragma optimize("", off) +#endif +BOOLEAN mFirstNotify; +EFI_PLATFORM_INFO_HOB *mPlatformInfo; +EFI_GUID mSystemConfigurationGuid = SYSTEM_CONFIGURATION_GUID; +SYSTEM_CONFIGURATION mSystemConfiguration; +SYSTEM_CONFIGURATION mSystemConfig; + +UINT8 mSmbusRsvdAddresses[] = PLATFORM_SMBUS_RSVD_ADDRESSES; +UINT8 mNumberSmbusAddress = sizeof( mSmbusRsvdAddresses ) / sizeof( mSmbusRsvdAddresses[0] ); + +/** + Locate the first instance of a protocol. If the protocol requested is an + FV protocol, then it will return the first FV that contains the ACPI table + storage file. + + @param[in] Protocol The protocol to find. + @param[in] Instance Return pointer to the first instance of the protocol. + @param[in] Type The type of protocol to locate. + + @retval EFI_SUCCESS The function completed successfully. + @retval EFI_NOT_FOUND The protocol could not be located. + @retval EFI_OUT_OF_RESOURCES There are not enough resources to find the protocol. + +**/ +EFI_STATUS +LocateSupportProtocol ( + IN EFI_GUID *Protocol, + OUT VOID **Instance, + IN UINT32 Type + ) +{ + EFI_STATUS Status; + EFI_HANDLE *HandleBuffer; + UINTN NumberOfHandles; + EFI_FV_FILETYPE FileType; + UINT32 FvStatus; + EFI_FV_FILE_ATTRIBUTES Attributes; + UINTN Size; + UINTN Index; + + FvStatus = 0; + + // + // Locate protocol. + // + Status = gBS->LocateHandleBuffer ( + ByProtocol, + Protocol, + NULL, + &NumberOfHandles, + &HandleBuffer + ); + if (EFI_ERROR (Status)) { + // + // Defined errors at this time are not found and out of resources. + // + return Status; + } + + // + // Looking for FV with ACPI storage 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], + Protocol, + Instance + ); + ASSERT (!EFI_ERROR (Status)); + + if (!Type) { + // + // Not looking for the FV protocol, so find the first instance of the + // protocol. There should not be any errors because our handle buffer + // should always contain at least one or LocateHandleBuffer would have + // returned not found. + // + break; + } + + // + // See if it has the ACPI storage file. + // + Status = ((EFI_FIRMWARE_VOLUME_PROTOCOL *) (*Instance))->ReadFile ( + *Instance, + &gEfiAcpiTableStorageGuid, + NULL, + &Size, + &FileType, + &Attributes, + &FvStatus + ); + + // + // If we found it, then we are done. + // + if (!EFI_ERROR (Status)) { + break; + } + } + + // + // 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); + + return Status; +} + +/** + This function will update any runtime platform specific information. + This currently includes: + Setting OEM table values, ID, table ID, creator ID and creator revision. + Enabling the proper processor entries in the APIC tables. + + @param[in] Table The table to update. + + @retval EFI_SUCCESS The function completed successfully. + +**/ +EFI_STATUS +PlatformUpdateTables ( + IN OUT EFI_ACPI_COMMON_HEADER *Table + ) +{ + EFI_ACPI_DESCRIPTION_HEADER *TableHeader; + UINT8 *CurrPtr; + UINT8 *EndPtr; + ACPI_APIC_STRUCTURE_PTR *ApicPtr; + UINT8 CurrProcessor; + EFI_STATUS Status; + EFI_MP_SERVICES_PROTOCOL *MpService; + UINTN MaximumNumberOfCPUs; + UINTN NumberOfEnabledCPUs; + UINTN BufferSize; + ACPI_APIC_STRUCTURE_PTR *ProcessorLocalApicEntry; + UINTN BspIndex; + EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE *AsfEntry; + EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER *HpetTbl; + UINT64 OemIdValue; + UINT8 Index; + EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *Facp; + EFI_ACPI_OSFR_TABLE *OsfrTable; + EFI_ACPI_OSFR_OCUR_OBJECT *pOcurObject; + EFI_ACPI_OSFR_OCUR_OBJECT OcurObject = {{0xB46F133D, 0x235F, 0x4634, 0x9F, 0x03, 0xB1, 0xC0, 0x1C, 0x54, 0x78, 0x5B}, 0, 0, 0, 0, 0}; + CHAR16 *OcurMfgStringBuffer = NULL; + CHAR16 *OcurModelStringBuffer = NULL; + UINT8 *OcurRefDataBlockBuffer = NULL; + UINTN OcurMfgStringBufferSize; + UINTN OcurModelStringBufferSize; + UINTN OcurRefDataBlockBufferSize; +#if defined (IDCC2_SUPPORTED) && IDCC2_SUPPORTED + EFI_ACPI_ASPT_TABLE *pSpttTable; +#endif + UINT16 NumberOfHpets; + UINT16 HpetCapIdValue; + UINT32 HpetBlockID; + UINTN LocalApicCounter; + EFI_PROCESSOR_INFORMATION ProcessorInfoBuffer; + UINT8 TempVal; + EFI_ACPI_3_0_IO_APIC_STRUCTURE *IOApicType; + EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *APICTableHeader; + + CurrPtr = NULL; + EndPtr = NULL; + ApicPtr = NULL; + LocalApicCounter = 0; + CurrProcessor = 0; + ProcessorLocalApicEntry = NULL; + + + if (Table->Signature != EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) { + TableHeader = (EFI_ACPI_DESCRIPTION_HEADER *) Table; + // + // Update the OEMID. + // + OemIdValue = mPlatformInfo->AcpiOemId; + + *(UINT32 *)(TableHeader->OemId) = (UINT32)OemIdValue; + *(UINT16 *)(TableHeader->OemId + 4) = *(UINT16*)(((UINT8 *)&OemIdValue) + 4); + + if ((Table->Signature != EFI_ACPI_2_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE)) { + // + // Update the OEM Table ID. + // + TableHeader->OemTableId = mPlatformInfo->AcpiOemTableId; + } + + // + // Update the OEM Table ID. + // + TableHeader->OemRevision = EFI_ACPI_OEM_REVISION; + + // + // Update the creator ID. + // + TableHeader->CreatorId = EFI_ACPI_CREATOR_ID; + + // + // Update the creator revision. + // + TableHeader->CreatorRevision = EFI_ACPI_CREATOR_REVISION; + } + + // + // Complete this function. + // + // + // Locate the MP services protocol. + // + // + // Find the MP Protocol. This is an MP platform, so MP protocol must be + // there. + // + Status = gBS->LocateProtocol ( + &gEfiMpServiceProtocolGuid, + NULL, + (VOID **) &MpService + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Determine the number of processors. + // + MpService->GetNumberOfProcessors ( + MpService, + &MaximumNumberOfCPUs, + &NumberOfEnabledCPUs + ); + + ASSERT (MaximumNumberOfCPUs <= MAX_CPU_NUM && NumberOfEnabledCPUs >= 1); + + + // + // Assign a invalid intial value for update. + // + // + // Update the processors in the APIC table. + // + switch (Table->Signature) { + case EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE_SIGNATURE: + // + // Update the table if ASF is enabled. Otherwise, return error so caller will not install. + // + if (mSystemConfig.Asf == 1) { + return EFI_UNSUPPORTED; + } + AsfEntry = (EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE *) Table; + TempVal = (mNumberSmbusAddress < ASF_ADDR_DEVICE_ARRAY_LENGTH)? mNumberSmbusAddress : ASF_ADDR_DEVICE_ARRAY_LENGTH; + for (Index = 0; Index < TempVal; Index++) { + AsfEntry->AsfAddr.FixedSmbusAddresses[Index] = mSmbusRsvdAddresses[Index]; + } + break; + + case EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE: + + Status = MpService->WhoAmI ( + MpService, + &BspIndex + ); + + // + // PCAT_COMPAT Set to 1 indicate 8259 vectors should be disabled. + // + APICTableHeader = (EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)Table; + APICTableHeader->Flags |= EFI_ACPI_3_0_PCAT_COMPAT; + + CurrPtr = (UINT8 *) &((EFI_ACPI_DESCRIPTION_HEADER *) Table)[1]; + CurrPtr = CurrPtr + 8; + + // + // Size of Local APIC Address & Flag. + // + EndPtr = (UINT8 *) Table; + EndPtr = EndPtr + Table->Length; + while (CurrPtr < EndPtr) { + ApicPtr = (ACPI_APIC_STRUCTURE_PTR *) CurrPtr; + switch (ApicPtr->AcpiApicCommon.Type) { + case EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC: + // + // ESS override + // Fix for Ordering of MADT to be maintained as it is in MADT table. + // + // Update processor enabled or disabled and keep the local APIC + // order in MADT intact. + // + // Sanity check to make sure proc-id is not arbitrary. + // + DEBUG ((EFI_D_ERROR, "ApicPtr->AcpiLocalApic.AcpiProcessorId = %x, MaximumNumberOfCPUs = %x\n", \ + ApicPtr->AcpiLocalApic.AcpiProcessorId, MaximumNumberOfCPUs)); + if(ApicPtr->AcpiLocalApic.AcpiProcessorId > MaximumNumberOfCPUs) { + ApicPtr->AcpiLocalApic.AcpiProcessorId = (UINT8)MaximumNumberOfCPUs; + } + + BufferSize = 0; + ApicPtr->AcpiLocalApic.Flags = 0; + + for (CurrProcessor = 0; CurrProcessor < MaximumNumberOfCPUs; CurrProcessor++) { + Status = MpService->GetProcessorInfo ( + MpService, + CurrProcessor, + &ProcessorInfoBuffer + ); + + if (Status == EFI_SUCCESS && ProcessorInfoBuffer.ProcessorId == ApicPtr->AcpiLocalApic.ApicId) { + // + // Check to see whether or not a processor (or thread) is enabled. + // + if ((BspIndex == CurrProcessor) || ((ProcessorInfoBuffer.StatusFlag & PROCESSOR_ENABLED_BIT) != 0)) { + // + // Go on and check if Hyper Threading is enabled. If HT not enabled + // hide this thread from OS by not setting the flag to 1. This is the + // software way to disable Hyper Threading. Basically we just hide it + // from the OS. + // + ApicPtr->AcpiLocalApic.Flags = EFI_ACPI_1_0_LOCAL_APIC_ENABLED; + + + if(ProcessorInfoBuffer.Location.Thread != 0) { + ApicPtr->AcpiLocalApic.Flags = 0; + } + + AppendCpuMapTableEntry (&(ApicPtr->AcpiLocalApic)); + } + break; + } + } + + // + // If no APIC-ID match, the cpu may not be populated. + // + break; + + case EFI_ACPI_3_0_IO_APIC: + + IOApicType = (EFI_ACPI_3_0_IO_APIC_STRUCTURE *)CurrPtr; + IOApicType->IoApicId = 0x02; + // + // IO APIC entries can be patched here. + // + break; + } + + CurrPtr = CurrPtr + ApicPtr->AcpiApicCommon.Length; + } + break; + + case EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE: + + Facp = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *) Table; + Facp->Flags &= (UINT32)(~(3<<2)); + + break; + + case EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE: + // + // Patch the memory resource. + // + PatchDsdtTable ((EFI_ACPI_DESCRIPTION_HEADER *) Table); + break; + + case EFI_ACPI_3_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE: + // + // Gv3 support + // + // TBD: Need re-design based on the ValleyTrail platform. + // + break; + + case EFI_ACPI_3_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE: + // + // Adjust HPET Table to correct the Base Address. + // + // Enable HPET always as Hpet.asi always indicates that Hpet is enabled. + // + MmioOr8 (R_PCH_PCH_HPET + R_PCH_PCH_HPET_GCFG, B_PCH_PCH_HPET_GCFG_EN); + + + HpetTbl = (EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER *) Table; + HpetTbl->BaseAddressLower32Bit.Address = HPET_BASE_ADDRESS; + HpetTbl->EventTimerBlockId = *((UINT32*)(UINTN)HPET_BASE_ADDRESS); + + HpetCapIdValue = *(UINT16 *)(UINTN)(HPET_BASE_ADDRESS); + NumberOfHpets = HpetCapIdValue & B_PCH_PCH_HPET_GCID_NT; // Bits [8:12] contains the number of Hpets + HpetBlockID = EFI_ACPI_EVENT_TIMER_BLOCK_ID; + + if((NumberOfHpets) && (NumberOfHpets & B_PCH_PCH_HPET_GCID_NT)) { + HpetBlockID |= (NumberOfHpets); + } + HpetTbl->EventTimerBlockId = HpetBlockID; + + break; + + case EFI_ACPI_3_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE: + // + // Update MCFG base and end bus number. + // + ((EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE *) Table)->Segment[0].BaseAddress + = mPlatformInfo->PciData.PciExpressBase; + ((EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE *) Table)->Segment[0].EndBusNumber + = (UINT8)RShiftU64 (mPlatformInfo->PciData.PciExpressSize, 20) - 1; + break; + + + case EFI_ACPI_OSFR_TABLE_SIGNATURE: + // + // Get size of OSFR variable. + // + OcurMfgStringBufferSize = 0; + Status = gRT->GetVariable ( + gACPIOSFRMfgStringVariableName, + &gACPIOSFRMfgStringVariableGuid, + NULL, + &OcurMfgStringBufferSize, + NULL + ); + if (Status != EFI_BUFFER_TOO_SMALL) { + // + // Variable must not be present on the system. + // + return EFI_UNSUPPORTED; + } + + // + // Allocate memory for variable data. + // + OcurMfgStringBuffer = AllocatePool (OcurMfgStringBufferSize); + Status = gRT->GetVariable ( + gACPIOSFRMfgStringVariableName, + &gACPIOSFRMfgStringVariableGuid, + NULL, + &OcurMfgStringBufferSize, + OcurMfgStringBuffer + ); + if (!EFI_ERROR (Status)) { + OcurModelStringBufferSize = 0; + Status = gRT->GetVariable ( + gACPIOSFRModelStringVariableName, + &gACPIOSFRModelStringVariableGuid, + NULL, + &OcurModelStringBufferSize, + NULL + ); + if (Status != EFI_BUFFER_TOO_SMALL) { + // + // Variable must not be present on the system. + // + return EFI_UNSUPPORTED; + } + + // + // Allocate memory for variable data. + // + OcurModelStringBuffer = AllocatePool (OcurModelStringBufferSize); + Status = gRT->GetVariable ( + gACPIOSFRModelStringVariableName, + &gACPIOSFRModelStringVariableGuid, + NULL, + &OcurModelStringBufferSize, + OcurModelStringBuffer + ); + if (!EFI_ERROR (Status)) { + OcurRefDataBlockBufferSize = 0; + Status = gRT->GetVariable ( + gACPIOSFRRefDataBlockVariableName, + &gACPIOSFRRefDataBlockVariableGuid, + NULL, + &OcurRefDataBlockBufferSize, + NULL + ); + if (Status == EFI_BUFFER_TOO_SMALL) { + // + // Allocate memory for variable data. + // + OcurRefDataBlockBuffer = AllocatePool (OcurRefDataBlockBufferSize); + Status = gRT->GetVariable ( + gACPIOSFRRefDataBlockVariableName, + &gACPIOSFRRefDataBlockVariableGuid, + NULL, + &OcurRefDataBlockBufferSize, + OcurRefDataBlockBuffer + ); + } + OsfrTable = (EFI_ACPI_OSFR_TABLE *) Table; + // + // Currently only one object is defined: OCUR_OSFR_TABLE. + // + OsfrTable->ObjectCount = 1; + // + // Initialize table length to fixed portion of the ACPI OSFR table. + // + OsfrTable->Header.Length = sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION); + *(UINT32 *)((UINTN) OsfrTable + sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION)) = \ + (UINT32) (sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION) + sizeof (UINT32)); + pOcurObject = (EFI_ACPI_OSFR_OCUR_OBJECT *)((UINTN) OsfrTable + sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION) + \ + sizeof (UINT32)); + CopyMem (pOcurObject, &OcurObject, sizeof (EFI_ACPI_OSFR_OCUR_OBJECT)); + pOcurObject->ManufacturerNameStringOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \ + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT)); + pOcurObject->ModelNameStringOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \ + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize); + if (OcurRefDataBlockBufferSize > 0) { + pOcurObject->MicrosoftReferenceOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \ + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize + OcurModelStringBufferSize); + } + CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT)), OcurMfgStringBuffer, \ + OcurMfgStringBufferSize); + CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize), \ + OcurModelStringBuffer, OcurModelStringBufferSize); + if (OcurRefDataBlockBufferSize > 0) { + CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize + \ + OcurModelStringBufferSize),OcurRefDataBlockBuffer, OcurRefDataBlockBufferSize); + } + OsfrTable->Header.Length += (UINT32)(OcurMfgStringBufferSize + OcurModelStringBufferSize + OcurRefDataBlockBufferSize); + OsfrTable->Header.Length += sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + sizeof (UINT32); + } + } + gBS->FreePool (OcurMfgStringBuffer); + gBS->FreePool (OcurModelStringBuffer); + gBS->FreePool (OcurRefDataBlockBuffer); + break; + default: + break; + } + + // + // + // Update the hardware signature in the FACS structure. + // + // + // Locate the SPCR table and update based on current settings. + // The user may change CR settings via setup or other methods. + // The SPCR table must match. + // + return EFI_SUCCESS; +} + +/** + +Routine Description: + + GC_TODO: Add function description. + +Arguments: + + Event - GC_TODO: add argument description + Context - GC_TODO: add argument description + +Returns: + + GC_TODO: add return values + +**/ +STATIC +VOID +EFIAPI +OnReadyToBoot ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + EFI_STATUS Status; + EFI_ACPI_TABLE_VERSION TableVersion; + EFI_ACPI_SUPPORT_PROTOCOL *AcpiSupport; + EFI_ACPI_S3_SAVE_PROTOCOL *AcpiS3Save; + SYSTEM_CONFIGURATION SetupVarBuffer; + UINTN VariableSize; + EFI_PLATFORM_CPU_INFO *PlatformCpuInfoPtr = NULL; + EFI_PLATFORM_CPU_INFO PlatformCpuInfo; + EFI_PEI_HOB_POINTERS GuidHob; + + if (mFirstNotify) { + return; + } + + mFirstNotify = TRUE; + + // + // To avoid compiler warning of "C4701: potentially uninitialized local variable 'PlatformCpuInfo' used". + // + PlatformCpuInfo.CpuVersion.FullCpuId = 0; + + // + // Get Platform CPU Info HOB. + // + PlatformCpuInfoPtr = NULL; + ZeroMem (&PlatformCpuInfo, sizeof(EFI_PLATFORM_CPU_INFO)); + VariableSize = sizeof(EFI_PLATFORM_CPU_INFO); + Status = gRT->GetVariable( + EfiPlatformCpuInfoVariable, + &gEfiVlv2VariableGuid, + NULL, + &VariableSize, + PlatformCpuInfoPtr + ); + if (EFI_ERROR(Status)) { + GuidHob.Raw = GetHobList (); + if (GuidHob.Raw != NULL) { + if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformCpuInfoGuid, GuidHob.Raw)) != NULL) { + PlatformCpuInfoPtr = GET_GUID_HOB_DATA (GuidHob.Guid); + } + } + } + + if ((PlatformCpuInfoPtr != NULL)) { + CopyMem(&PlatformCpuInfo, PlatformCpuInfoPtr, sizeof(EFI_PLATFORM_CPU_INFO)); + } + + // + // Update the ACPI parameter blocks finally. + // + VariableSize = sizeof (SYSTEM_CONFIGURATION); + Status = gRT->GetVariable ( + L"Setup", + &mSystemConfigurationGuid, + NULL, + &VariableSize, + &SetupVarBuffer + ); + ASSERT_EFI_ERROR (Status); + + // + // Find the AcpiSupport protocol. + // + Status = LocateSupportProtocol (&gEfiAcpiSupportProtocolGuid, (VOID **) &AcpiSupport, 0); + ASSERT_EFI_ERROR (Status); + + TableVersion = EFI_ACPI_TABLE_VERSION_2_0; + + // + // Publish ACPI 1.0 or 2.0 Tables. + // + Status = AcpiSupport->PublishTables ( + AcpiSupport, + TableVersion + ); + ASSERT_EFI_ERROR (Status); + + // + // S3 script save. + // + Status = gBS->LocateProtocol (&gEfiAcpiS3SaveProtocolGuid, NULL, (VOID **) &AcpiS3Save); + if (!EFI_ERROR (Status)) { + AcpiS3Save->S3Save (AcpiS3Save, NULL); + } + +} + +VOID +PR1FSASetting ( + IN VOID + ) +{ + // + // for FSA on PR1. + // + if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD && mPlatformInfo->BoardRev >= PR1) { + DEBUG((EFI_D_ERROR, "Set FSA status = 1 for FFRD PR1\n")); + mGlobalNvsArea.Area->FsaStatus = mSystemConfiguration.PchFSAOn; + } + if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD8) { + DEBUG((EFI_D_ERROR, "Set FSA status = 1 for FFRD8\n")); + mGlobalNvsArea.Area->FsaStatus = mSystemConfiguration.PchFSAOn; + } + +} + +/** + 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; +} + +UINT8 +ReadCmosBank1Byte ( + IN UINT8 Index + ) +{ + UINT8 Data; + + IoWrite8(0x72, Index); + Data = IoRead8 (0x73); + return Data; +} + +VOID +WriteCmosBank1Byte ( + IN UINT8 Index, + IN UINT8 Data + ) +{ + IoWrite8 (0x72, Index); + IoWrite8 (0x73, Data); +} + + + +VOID +SettingI2CTouchAddress ( + IN VOID + ) +{ + if (mSystemConfiguration.I2CTouchAd == 0) { + // + // If setup menu select auto set I2C Touch Address base on board id. + // + if (mPlatformInfo->BoardId == BOARD_ID_BL_RVP || + mPlatformInfo->BoardId == BOARD_ID_BL_STHI || + mPlatformInfo->BoardId == BOARD_ID_BL_RVP_DDR3L ) { + // + //RVP + // + mGlobalNvsArea.Area->I2CTouchAddress = 0x4B; + } else if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD) { + // + //FFRD + // + mGlobalNvsArea.Area->I2CTouchAddress = 0x4A; + } else if (mPlatformInfo->BoardId == BOARD_ID_BB_RVP) { + mGlobalNvsArea.Area->I2CTouchAddress = 0x4C; + } else if (mPlatformInfo->BoardId == BOARD_ID_CVH) { + mGlobalNvsArea.Area->I2CTouchAddress = 0x4C; + } else if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD8) { + // + //FFRD8 uses 0x4A. + // + mGlobalNvsArea.Area->I2CTouchAddress = 0x4A; + } + } else { + mGlobalNvsArea.Area->I2CTouchAddress = mSystemConfiguration.I2CTouchAd; + } + DEBUG((EFI_D_ERROR, "GlobalNvsArea.Area->I2CTouchAddress: [%02x]\n", mGlobalNvsArea.Area->I2CTouchAddress)); +} + + diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.h b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.h new file mode 100644 index 000000000..fbc927281 --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.h @@ -0,0 +1,224 @@ +/*++ + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + This program and the accompanying materials are licensed and made available under + the terms and conditions of the BSD License that accompanies this distribution. + The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + + +Module Name: + + AcpiPlatform.h + +Abstract: + + This is an implementation of the ACPI platform driver. Requirements for + this driver are defined in the Tiano ACPI External Product Specification, + revision 0.3.6. + + +--*/ + +#ifndef _ACPI_PLATFORM_H_ +#define _ACPI_PLATFORM_H_ + +// +// Statements that include other header files. +// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +// +// Global variables. +// +EFI_GLOBAL_NVS_AREA_PROTOCOL mGlobalNvsArea; + +// +// ACPI table information used to initialize tables. +#define EFI_ACPI_OEM_REVISION 0x00000003 +#define EFI_ACPI_CREATOR_ID SIGNATURE_32 ('V', 'L', 'V', '2') +#define EFI_ACPI_CREATOR_REVISION 0x0100000D + +#define WPCN381U_CONFIG_INDEX 0x2E +#define WPCN381U_CONFIG_DATA 0x2F +#define WPCN381U_CHIP_ID 0xF4 +#define WDCP376_CHIP_ID 0xF1 + +#define MOBILE_PLATFORM 1 +#define DESKTOP_PLATFORM 2 + +// +// Define macros to build data structure signatures from characters. +// +#ifndef EFI_SIGNATURE_16 +#define EFI_SIGNATURE_16(A, B) ((A) | (B << 8)) +#endif +#ifndef EFI_SIGNATURE_32 +#define EFI_SIGNATURE_32(A, B, C, D) (EFI_SIGNATURE_16 (A, B) | (EFI_SIGNATURE_16 (C, D) << 16)) +#endif +#ifndef EFI_SIGNATURE_64 +#define EFI_SIGNATURE_64(A, B, C, D, E, F, G, H) \ + (EFI_SIGNATURE_32 (A, B, C, D) | ((UINT64) (EFI_SIGNATURE_32 (E, F, G, H)) << 32)) +#endif + + +#define GV3_SSDT_OEM_TABLE_IDBASE 0x4000 + +// +// Private Driver Data. +// +// +// Define Union of IO APIC & Local APIC structure. +// +typedef union { + EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE AcpiLocalApic; + EFI_ACPI_2_0_IO_APIC_STRUCTURE AcpiIoApic; + struct { + UINT8 Type; + UINT8 Length; + } AcpiApicCommon; +} ACPI_APIC_STRUCTURE_PTR; + +// +// Protocol private structure definition. +// + +/** + Entry point of the ACPI platform driver. + + @param[in] ImageHandle EFI_HANDLE: A handle for the image that is initializing this driver. + @param[in] SystemTable EFI_SYSTEM_TABLE: 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 +InstallAcpiPlatform ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +/** + Get Acpi Table Version. + + @param[in] ImageHandle EFI_HANDLE: A handle for the image that is initializing this driver. + @param[in] SystemTable EFI_SYSTEM_TABLE: 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_ACPI_TABLE_VERSION +GetAcpiTableVersion ( + VOID + ); + +/** + The funtion returns Oem specific information of Acpi Platform. + + @param[in] OemId OemId returned. + @param[in] OemTableId OemTableId returned. + @param[in] OemRevision OemRevision returned. + + @retval EFI_STATUS Status of function execution. + +**/ +EFI_STATUS +AcpiPlatformGetOemFields ( + OUT UINT8 *OemId, + OUT UINT64 *OemTableId, + OUT UINT32 *OemRevision + ); + +/** + The function returns Acpi table version. + + @param[in] + + @retval EFI_ACPI_TABLE_VERSION Acpi table version encoded as a UINT32. + +**/ +EFI_ACPI_TABLE_VERSION +AcpiPlatformGetAcpiSetting ( + VOID + ); + +/** + 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 + ); + +UINT8 +ReadCmosBank1Byte ( + IN UINT8 Index + ); + +VOID +WriteCmosBank1Byte ( + IN UINT8 Index, + IN UINT8 Data + ); + +VOID +SelectNFCDevice ( + IN VOID + ); + +VOID +SettingI2CTouchAddress ( + IN VOID + ); + +extern +EFI_STATUS +EFIAPI +IsctDxeEntryPoint ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +#endif diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.inf b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.inf new file mode 100644 index 000000000..24fa913b3 --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.inf @@ -0,0 +1,90 @@ +# +# +# Copyright (c) 1999 - 2014, Intel Corporation. All rights reserved +# +# This program and the accompanying materials are licensed and made available under +# the terms and conditions of the BSD License that accompanies this distribution. +# The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php. +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# +# +# +# Module Name: +# +# AcpiPlatformBB.inf +# +# Abstract: +# +# + + + +[defines] + INF_VERSION = 0x00010005 + BASE_NAME = AcpiPlatform + FILE_GUID = F0F6F006-DAB4-44b2-A7A1-0F72EEDCA716 + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + ENTRY_POINT = AcpiPlatformEntryPoint + +[sources.common] + AcpiPlatformHooks.c + AcpiPlatform.c + +[Packages] + Vlv2TbltDevicePkg/PlatformPkg.dec + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + MdeModulePkg/MdeModulePkg.dec + Vlv2DeviceRefCodePkg/Vlv2DeviceRefCodePkg.dec + IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec + Vlv2TbltDevicePkg/PlatformPkg.dec + +[LibraryClasses] + HobLib + UefiRuntimeServicesTableLib + UefiDriverEntryPoint + BaseMemoryLib + DebugLib + HobLib + IoLib + PchPlatformLib + +[Guids] + gACPIOSFRMfgStringVariableGuid + gEfiAcpiTableStorageGuid + gACPIOSFRMfgStringVariableGuid + gEfiBoardFeaturesGuid + gEfiPlatformInfoGuid + gEfiNormalSetupGuid + gACPIOSFRRefDataBlockVariableGuid + gACPIOSFRModelStringVariableGuid + gEfiPlatformCpuInfoGuid + gEfiVlv2VariableGuid + +[Protocols] + gEfiAcpiTableProtocolGuid # PROTOCOL ALWAYS_CONSUMED + gEnhancedSpeedstepProtocolGuid + gEfiPlatformCpuProtocolGuid + gEfiAcpiSupportProtocolGuid + gEfiAcpiS3SaveProtocolGuid + gEfiCpuIoProtocolGuid + gEfiPs2PolicyProtocolGuid + gEfiFirmwareVolume2ProtocolGuid + gEfiMpServiceProtocolGuid + gEfiGlobalNvsAreaProtocolGuid + gEfiTcgProtocolGuid + gEfiFirmwareVolumeProtocolGuid + gIgdOpRegionProtocolGuid + +[Pcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiTableStorageFile + +[Depex] + gEfiAcpiSupportProtocolGuid AND + gEfiMpServiceProtocolGuid AND + gEfiCpuIoProtocolGuid + diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.c b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.c new file mode 100644 index 000000000..348965080 --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.c @@ -0,0 +1,500 @@ +/** @file + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + This program and the accompanying materials are licensed and made available under + the terms and conditions of the BSD License that accompanies this distribution. + The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + + AcpiPlatformHooks.c + +Abstract: + + ACPI Platform Driver Hooks + +--*/ + +// +// Statements that include other files. +// +#include "AcpiPlatform.h" +#include "AcpiPlatformHooks.h" +#include "Platform.h" + +// +// Prototypes of the various hook functions. +// +#include "AcpiPlatformHooksLib.h" + +extern EFI_GLOBAL_NVS_AREA_PROTOCOL mGlobalNvsArea; +extern SYSTEM_CONFIGURATION mSystemConfiguration; + +ENHANCED_SPEEDSTEP_PROTOCOL *mEistProtocol = NULL; + +EFI_CPU_ID_MAP mCpuApicIdAcpiIdMapTable[MAX_CPU_NUM]; + +EFI_STATUS +AppendCpuMapTableEntry ( + IN EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE *AcpiLocalApic + ) +{ + BOOLEAN Added; + UINTN Index; + + for (Index = 0; Index < MAX_CPU_NUM; Index++) { + if ((mCpuApicIdAcpiIdMapTable[Index].ApicId == AcpiLocalApic->ApicId) && mCpuApicIdAcpiIdMapTable[Index].Flags) { + return EFI_SUCCESS; + } + } + + Added = FALSE; + for (Index = 0; Index < MAX_CPU_NUM; Index++) { + if (!mCpuApicIdAcpiIdMapTable[Index].Flags) { + mCpuApicIdAcpiIdMapTable[Index].Flags = 1; + mCpuApicIdAcpiIdMapTable[Index].ApicId = AcpiLocalApic->ApicId; + mCpuApicIdAcpiIdMapTable[Index].AcpiProcessorId = AcpiLocalApic->AcpiProcessorId; + Added = TRUE; + break; + } + } + + ASSERT (Added); + return EFI_SUCCESS; +} + +UINT32 +ProcessorId2ApicId ( + UINT32 AcpiProcessorId + ) +{ + UINTN Index; + + ASSERT (AcpiProcessorId < MAX_CPU_NUM); + for (Index = 0; Index < MAX_CPU_NUM; Index++) { + if (mCpuApicIdAcpiIdMapTable[Index].Flags && (mCpuApicIdAcpiIdMapTable[Index].AcpiProcessorId == AcpiProcessorId)) { + return mCpuApicIdAcpiIdMapTable[Index].ApicId; + } + } + + return (UINT32) -1; +} + +UINT8 +GetProcNumberInPackage ( + IN UINT8 Package + ) +{ + UINTN Index; + UINT8 Number; + + Number = 0; + for (Index = 0; Index < MAX_CPU_NUM; Index++) { + if (mCpuApicIdAcpiIdMapTable[Index].Flags && (((mCpuApicIdAcpiIdMapTable[Index].ApicId >> 0x04) & 0x01) == Package)) { + Number++; + } + } + + return Number; +} + +EFI_STATUS +LocateCpuEistProtocol ( + IN UINT32 CpuIndex, + OUT ENHANCED_SPEEDSTEP_PROTOCOL **EistProtocol + ) +{ + UINTN HandleCount; + EFI_HANDLE *HandleBuffer; + ENHANCED_SPEEDSTEP_PROTOCOL *EistProt; + UINTN Index; + UINT32 ApicId; + EFI_STATUS Status; + + HandleCount = 0; + gBS->LocateHandleBuffer ( + ByProtocol, + &gEnhancedSpeedstepProtocolGuid, + NULL, + &HandleCount, + &HandleBuffer + ); + + Index = 0; + EistProt = NULL; + Status = EFI_NOT_FOUND; + while (Index < HandleCount) { + gBS->HandleProtocol ( + HandleBuffer[Index], + &gEnhancedSpeedstepProtocolGuid, + (VOID **) &EistProt + ); + // + // Adjust the CpuIndex by +1 due to the AcpiProcessorId is 1 based. + // + ApicId = ProcessorId2ApicId (CpuIndex+1); + if (ApicId == (UINT32) -1) { + break; + } + + if (EistProt->ProcApicId == ApicId) { + Status = EFI_SUCCESS; + break; + } + + Index++; + } + + if (HandleBuffer != NULL) { + gBS->FreePool (HandleBuffer); + } + + if (!EFI_ERROR (Status)) { + *EistProtocol = EistProt; + } else { + *EistProtocol = NULL; + } + + return Status; +} + +EFI_STATUS +PlatformHookInit ( + VOID + ) +{ + EFI_STATUS Status; + + Status = gBS->LocateProtocol ( + &gEnhancedSpeedstepProtocolGuid, + NULL, + (VOID **) &mEistProtocol + ); + + ASSERT_EFI_ERROR (Status); + + return Status; +} + +/** + Called for every ACPI table found in the BIOS flash. + Returns whether a table is active or not. Inactive tables + are not published in the ACPI table list. + + This hook can be used to implement optional SSDT tables or + enabling/disabling specific functionality (e.g. SPCR table) + based on a setup switch or platform preference. In case of + optional SSDT tables,the platform flash will include all the + SSDT tables but will return EFI_SUCCESS only for those tables + that need to be published. + + @param[in] *Table Pointer to the active table. + + @retval EFI_SUCCESS if the table is active. + @retval EFI_UNSUPPORTED if the table is not active. + +**/ +EFI_STATUS +AcpiPlatformHooksIsActiveTable ( + IN OUT EFI_ACPI_COMMON_HEADER *Table + ) +{ + EFI_ACPI_DESCRIPTION_HEADER *TableHeader; + + TableHeader = (EFI_ACPI_DESCRIPTION_HEADER *) Table; + + if (TableHeader->Signature == EFI_ACPI_2_0_STATIC_RESOURCE_AFFINITY_TABLE_SIGNATURE) { + + } + + if ((mSystemConfiguration.ENDBG2 == 0) && (CompareMem (&TableHeader->OemTableId, "INTLDBG2", 8) == 0)) { + return EFI_UNSUPPORTED; + } + return EFI_SUCCESS; +} + +/** + Update the GV3 SSDT table. + + @param[in][out] *TableHeader The table to be set. + + @retval EFI_SUCCESS Returns Success. + +**/ +EFI_STATUS +PatchGv3SsdtTable ( + IN OUT EFI_ACPI_DESCRIPTION_HEADER *TableHeader + ) +{ + EFI_STATUS Status; + UINT8 *CurrPtr; + UINT8 *SsdtPointer; + UINT32 Signature; + UINT32 CpuFixes; + UINT32 NpssFixes; + UINT32 SpssFixes; + UINT32 CpuIndex; + UINT32 PackageSize; + UINT32 NewPackageSize; + UINT32 AdjustSize; + UINTN EntryIndex; + UINTN TableIndex; + EFI_ACPI_NAME_COMMAND *PssTable; + EFI_PSS_PACKAGE *PssTableItemPtr; + ENHANCED_SPEEDSTEP_PROTOCOL *EistProt; + EIST_INFORMATION *EistInfo; + EFI_ACPI_CPU_PSS_STATE *PssState; + EFI_ACPI_NAMEPACK_DWORD *NamePtr; + // + // Loop through the ASL looking for values that we must fix up. + // + NpssFixes = 0; + SpssFixes = 0; + CpuFixes = 0; + CpuIndex = 0; + CurrPtr = (UINT8 *) TableHeader; + + EistProt = NULL; + for (SsdtPointer = CurrPtr; SsdtPointer <= (CurrPtr + ((EFI_ACPI_COMMON_HEADER *) CurrPtr)->Length); SsdtPointer++) { + Signature = *(UINT32 *) SsdtPointer; + switch (Signature) { + + case SIGNATURE_32 ('_', 'P', 'R', '_'): + // + // _CPUX ('0' to '0xF') + // + CpuIndex = *(SsdtPointer + 7); + if (CpuIndex >= '0' && CpuIndex <= '9') { + CpuIndex -= '0'; + } else { + if (CpuIndex > '9') { + CpuIndex -= '7'; + } + } + + CpuFixes++; + LocateCpuEistProtocol (CpuIndex, &EistProt); + break; + + case SIGNATURE_32 ('D', 'O', 'M', 'N'): + + NamePtr = ACPI_NAME_COMMAND_FROM_NAMEPACK_STR (SsdtPointer); + if (NamePtr->StartByte != AML_NAME_OP) { + continue; + } + + if (NamePtr->Size != AML_NAME_DWORD_SIZE) { + continue; + } + + NamePtr->Value = 0; + + if (mCpuApicIdAcpiIdMapTable[CpuIndex].Flags) { + NamePtr->Value = (mCpuApicIdAcpiIdMapTable[CpuIndex].ApicId >> 0x04) & 0x01; + } + break; + + case SIGNATURE_32 ('N', 'C', 'P', 'U'): + + NamePtr = ACPI_NAME_COMMAND_FROM_NAMEPACK_STR (SsdtPointer); + if (NamePtr->StartByte != AML_NAME_OP) { + continue; + } + + if (NamePtr->Size != AML_NAME_DWORD_SIZE) { + continue; + } + + NamePtr->Value = 0; + if (mCpuApicIdAcpiIdMapTable[CpuIndex].Flags) { + NamePtr->Value = GetProcNumberInPackage ((mCpuApicIdAcpiIdMapTable[CpuIndex].ApicId >> 0x04) & 0x01); + } + break; + + case SIGNATURE_32 ('N', 'P', 'S', 'S'): + case SIGNATURE_32 ('S', 'P', 'S', 'S'): + if (EistProt == NULL) { + continue; + } + + PssTable = ACPI_NAME_COMMAND_FROM_NAME_STR (SsdtPointer); + if (PssTable->StartByte != AML_NAME_OP) { + continue; + } + + Status = EistProt->GetEistTable (EistProt, &EistInfo, (VOID **) &PssState); + + AdjustSize = PssTable->NumEntries * sizeof (EFI_PSS_PACKAGE); + AdjustSize -= EistInfo->NumStates * sizeof (EFI_PSS_PACKAGE); + PackageSize = (PssTable->Size & 0xF) + ((PssTable->Size & 0xFF00) >> 4); + NewPackageSize = PackageSize - AdjustSize; + PssTable->Size = (UINT16) ((NewPackageSize & 0xF) + ((NewPackageSize & 0x0FF0) << 4)); + + // + // Set most significant two bits of byte zero to 01, meaning two bytes used. + // + PssTable->Size |= 0x40; + + // + // Set unused table to Noop Code. + // + SetMem( (UINT8 *) PssTable + NewPackageSize + AML_NAME_PREFIX_SIZE, AdjustSize, AML_NOOP_OP); + PssTable->NumEntries = (UINT8) EistInfo->NumStates; + PssTableItemPtr = (EFI_PSS_PACKAGE *) ((UINT8 *) PssTable + sizeof (EFI_ACPI_NAME_COMMAND)); + + // + // Update the size. + // + for (TableIndex = 0; TableIndex < EistInfo->NumStates; TableIndex++) { + EntryIndex = EistInfo->NumStates - TableIndex - 1; + PssTableItemPtr->CoreFreq = PssState[EntryIndex].CoreFrequency * PssState[EntryIndex].Control; + PssTableItemPtr->Power = PssState[EntryIndex].Power * 1000; + if (PssTable->NameStr == SIGNATURE_32 ('N', 'P', 'S', 'S')) { + PssTableItemPtr->BMLatency = PssState[EntryIndex].BusMasterLatency; + PssTableItemPtr->TransLatency = PssState[EntryIndex].TransitionLatency; + } else { + // + // This method should be supported by SMM PPM Handler. + // + PssTableItemPtr->BMLatency = PssState[EntryIndex].BusMasterLatency * 2; + PssTableItemPtr->TransLatency = PssState[EntryIndex].TransitionLatency * 10; + } + + PssTableItemPtr->Control = PssState[EntryIndex].Control; + PssTableItemPtr->Status = PssState[EntryIndex].Status; + PssTableItemPtr++; + } + + if (PssTable->NameStr == SIGNATURE_32 ('N', 'P', 'S', 'S')) { + NpssFixes++; + } else { + SpssFixes++; + } + + SsdtPointer = (UINT8 *) PssTable + PackageSize; + break; + } + } + + // + // N fixes together currently. + // + ASSERT (CpuFixes == (UINT32) MAX_CPU_NUM); + ASSERT (SpssFixes == NpssFixes); + ASSERT (CpuFixes >= SpssFixes); + + return EFI_SUCCESS; +} + +/** + Update the DSDT table. + + @param[in][out] *TableHeader The table to be set. + + @retval EFI_SUCCESS Returns EFI_SUCCESS. + +**/ +EFI_STATUS +PatchDsdtTable ( + IN OUT EFI_ACPI_DESCRIPTION_HEADER *TableHeader + ) +{ + + UINT8 *CurrPtr; + UINT8 *DsdtPointer; + UINT32 *Signature; + UINT8 *EndPtr; + UINT8 *Operation; + UINT32 *Address; + UINT16 *Size; + + // + // Fix PCI32 resource "FIX0" -- PSYS system status area + // + CurrPtr = (UINT8*) &((EFI_ACPI_DESCRIPTION_HEADER*) TableHeader)[0]; + EndPtr = (UINT8*) TableHeader; + EndPtr = EndPtr + TableHeader->Length; + while (CurrPtr < (EndPtr-2)) { + // + // Removed the _S3 tag to indicate that we do not support S3. The 4th byte is blank space + // since there are only 3 char "_S3". + // + if (mSystemConfiguration.AcpiSuspendState == 0) { + // + // For iasl compiler version 20061109. + // + if ((CurrPtr[0] == '_') && (CurrPtr[1] == 'S') && (CurrPtr[2] == '3') && (CurrPtr[3] == '_')) { + break; + } + // + // For iasl compiler version 20040527. + // + if ((CurrPtr[0] == '\\') && (CurrPtr[1] == '_') && (CurrPtr[2] == 'S') && (CurrPtr[3] == '3')) { + break; + } + } + CurrPtr++; + } + CurrPtr = (UINT8*) &((EFI_ACPI_DESCRIPTION_HEADER*) TableHeader)[0]; + EndPtr = (UINT8*) TableHeader; + EndPtr = EndPtr + TableHeader->Length; + while (CurrPtr < (EndPtr-2)) { + // + // For mipi dsi port select _DEP. + // + if (mSystemConfiguration.MipiDsi== 1) { + // + // For iasl compiler version 20061109. + // + if ((CurrPtr[0] == 'N') && (CurrPtr[1] == 'D') && (CurrPtr[2] == 'E') && (CurrPtr[3] == 'P')) { + CurrPtr[0] = '_'; + break; + } + + } else { + if ((CurrPtr[0] == 'P') && (CurrPtr[1] == 'D') && (CurrPtr[2] == 'E') && (CurrPtr[3] == 'P')) { + CurrPtr[0] = '_'; + break; + } + + } + CurrPtr++; + } + // + // Loop through the ASL looking for values that we must fix up. + // + CurrPtr = (UINT8 *) TableHeader; + for (DsdtPointer = CurrPtr; DsdtPointer <= (CurrPtr + ((EFI_ACPI_COMMON_HEADER *) CurrPtr)->Length); DsdtPointer++) { + Signature = (UINT32 *) DsdtPointer; + + switch (*Signature) { + // + // GNVS operation region. + // + case (SIGNATURE_32 ('G', 'N', 'V', 'S')): + // + // Conditional match. For Region Objects, the Operator will always be the + // byte immediately before the specific name. Therefore, subtract 1 to check + // the Operator. + // + Operation = DsdtPointer - 1; + if (*Operation == AML_OPREGION_OP) { + Address = (UINT32 *) (DsdtPointer + 6); + *Address = (UINT32) (UINTN) mGlobalNvsArea.Area; + Size = (UINT16 *) (DsdtPointer + 11); + *Size = sizeof (EFI_GLOBAL_NVS_AREA); + } + break; + default: + break; + } + } + return EFI_SUCCESS; +} + diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.h b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.h new file mode 100644 index 000000000..164f45e6a --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooks.h @@ -0,0 +1,132 @@ +/*++ + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + This program and the accompanying materials are licensed and made available under + the terms and conditions of the BSD License that accompanies this distribution. + The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + + AcpiPlatformHooks.h + +Abstract: + + This is an implementation of the ACPI platform driver. Requirements for + this driver are defined in the Tiano ACPI External Product Specification, + revision 0.3.6. + +--*/ + +#ifndef _ACPI_PLATFORM_HOOKS_H_ +#define _ACPI_PLATFORM_HOOKS_H_ + +// +// Statements that include other header files +// + +#include +#include "Platform.h" +#include + +#define AML_NAME_OP 0x08 +#define AML_METHOD_OP 0x14 +#define AML_OPREGION_OP 0x80 +#define AML_PACKAGE_OP 0x12 // Package operator. +#define AML_NAME_PREFIX_SIZE 0x06 +#define AML_NAME_DWORD_SIZE 0x0C + +#pragma pack(1) + +typedef struct { + UINT8 AcpiProcessorId; + UINT8 ApicId; + UINT16 Flags; +} EFI_CPU_ID_MAP; + +typedef struct { + UINT8 StartByte; + UINT32 NameStr; + UINT8 Size; + UINT32 Value; +} EFI_ACPI_NAMEPACK_DWORD; + +typedef struct { + UINT8 StartByte; + UINT32 NameStr; + UINT8 OpCode; + UINT16 Size; // Hardcode to 16bit width because the table we use is fixed size + UINT8 NumEntries; +} EFI_ACPI_NAME_COMMAND; + +typedef struct { + UINT8 PackageOp; + UINT8 PkgLeadByte; + UINT8 NumEntries; + UINT8 DwordPrefix0; + UINT32 CoreFreq; + UINT8 DwordPrefix1; + UINT32 Power; + UINT8 DwordPrefix2; + UINT32 TransLatency; + UINT8 DwordPrefix3; + UINT32 BMLatency; + UINT8 DwordPrefix4; + UINT32 Control; + UINT8 DwordPrefix5; + UINT32 Status; +} EFI_PSS_PACKAGE; + +typedef struct { + UINT8 PackageOp; + UINT8 PkgLeadByte; + UINT8 NumEntries; + UINT8 BytePrefix0; + UINT8 Entries; + UINT8 BytePrefix1; + UINT8 Revision; + UINT8 BytePrefix2; + UINT8 Domain; + UINT8 BytePrefix3; + UINT8 Coordinate; + UINT8 BytePrefix4; + UINT8 ProcNumber; +} EFI_PSD_PACKAGE; + +#pragma pack() + +#define ACPI_NAME_COMMAND_FROM_NAME_STR(a) BASE_CR (a, EFI_ACPI_NAME_COMMAND, NameStr) +#define ACPI_NAME_COMMAND_FROM_NAMEPACK_STR(a) BASE_CR (a, EFI_ACPI_NAMEPACK_DWORD, NameStr) + +EFI_STATUS +PlatformHookInit ( + VOID + ); + + +EFI_STATUS +PatchDsdtTable ( + IN OUT EFI_ACPI_DESCRIPTION_HEADER *TableHeader + ); + +EFI_STATUS +PatchGv3SsdtTable ( + IN OUT EFI_ACPI_DESCRIPTION_HEADER *Table + ); + +EFI_STATUS +PatchErstTable ( + IN OUT EFI_ACPI_DESCRIPTION_HEADER *Table + ); + +EFI_STATUS +AppendCpuMapTableEntry ( + IN EFI_ACPI_2_0_PROCESSOR_LOCAL_APIC_STRUCTURE *AcpiLocalApic + ); + +#endif diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooksLib.h b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooksLib.h new file mode 100644 index 000000000..f6a4b3b4d --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatformHooksLib.h @@ -0,0 +1,96 @@ +/*++ + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + This program and the accompanying materials are licensed and made available under + the terms and conditions of the BSD License that accompanies this distribution. + The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + + AcpiPlatformHooksLib.h + +Abstract: + + This is an implementation of the ACPI platform driver. Requirements for + this driver are defined in the Tiano ACPI External Product Specification, + revision 0.3.6. + +--*/ + +#ifndef _ACPI_PLATFORM_HOOKS_LIB_H_ +#define _ACPI_PLATFORM_HOOKS_LIB_H_ + +// +// Statements that include other header files. +// +#include + +/** + Returns the ACPI table version that the platform wants. + + @param[in] None + + @retval EFI_ACPI_TABLE_VERSION_NONE if ACPI is to be disabled. + @retval EFI_ACPI_TABLE_VERSION_1_0B if 1.0b. + @retval EFI_ACPI_TABLE_VERSION_2_00 if 2.00. +**/ +EFI_ACPI_TABLE_VERSION +AcpiPlatformHooksGetAcpiTableVersion ( + VOID + ); + +/** + Returns the OEMID, OEM Table ID, OEM Revision. + + @param[in] None + + @retval OemId OEM ID string for ACPI tables, maximum 6 ASCII characters. + This is an OEM-supplied string that identifies the OEM. + @retval OemTableId An OEM-supplied string that the OEM uses to identify + the particular data table. This field is particularly useful + when defining a definition block to distinguish definition block + functions. The OEM assigns each dissimilar table a new OEM Table ID. + @retval OemRevision An OEM-supplied revision number for ACPI tables. + Larger numbers are assumed to be newer revisions. + +**/ +EFI_STATUS +AcpiPlatformHooksGetOemFields ( + OUT UINT8 *OemId, + OUT UINT64 *OemTableId, + OUT UINT32 *OemRevision + ); + + /** + Called for every ACPI table found in the BIOS flash. + Returns whether a table is active or not. Inactive tables + are not published in the ACPI table list. This hook can be + used to implement optional SSDT tables or enabling/disabling + specific functionality (e.g. SPCR table) based on a setup + switch or platform preference. In case of optional SSDT tables, + the platform flash will include all the SSDT tables but will + return EFI_SUCCESS only for those tables that need to be + published. + This hook can also be used to update the table data. The header + is updated by the common code. For example, if a platform wants + to use an SSDT table to export some platform settings to the + ACPI code, it needs to update the data inside that SSDT based + on platform preferences in this hook. + + @param[in] None + + @retval EFI_SUCCESS if the table is active. + @retval EFI_UNSUPPORTED if the table is not active. +**/ +EFI_STATUS +AcpiPlatformHooksIsActiveTable ( + IN OUT EFI_ACPI_COMMON_HEADER *Table + ); + +#endif diff --git a/Vlv2TbltDevicePkg/AcpiPlatform/Osfr.h b/Vlv2TbltDevicePkg/AcpiPlatform/Osfr.h new file mode 100644 index 000000000..1bef1afde --- /dev/null +++ b/Vlv2TbltDevicePkg/AcpiPlatform/Osfr.h @@ -0,0 +1,61 @@ +/*++ + + Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.
+ + This program and the accompanying materials are licensed and made available under + the terms and conditions of the BSD License that accompanies this distribution. + The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php. + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + + Osfr.h + +Abstract: + + This file describes the contents of the ACPI OSFR Table. + +--*/ + +#ifndef _OSFR_H +#define _OSFR_H + +// +// Statements that include other files. +// +#include +#include + +#pragma pack (1) + +#define EFI_ACPI_OSFR_TABLE_REVISION 0x1 +//#define EFI_ACPI_OSFR_TABLE_SIGNATURE 'RFSO' +#define EFI_ACPI_OSFR_TABLE_SIGNATURE SIGNATURE_32('O', 'S', 'F', 'R') //'RFSO' + +typedef struct { + EFI_ACPI_DESCRIPTION_HEADER Header; + UINT32 ObjectCount; + UINT32 TableDWORDs [64]; +} EFI_ACPI_OSFR_TABLE; + +typedef struct { + EFI_ACPI_DESCRIPTION_HEADER Header; + UINT32 ObjectCount; +} EFI_ACPI_OSFR_TABLE_FIXED_PORTION; + +typedef struct { + EFI_GUID ObjectUUID; + UINT32 Reserved1; + UINT32 ManufacturerNameStringOffset; + UINT32 ModelNameStringOffset; + UINT32 Reserved2; + UINT32 MicrosoftReferenceOffset; +} EFI_ACPI_OSFR_OCUR_OBJECT; + +#pragma pack () + +#endif -- cgit v1.2.3