sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QuarkPlatformPkg: Add new package for Galileo boards

Browse Source 
Changes for V4
==============
1) Move delete of QuarkSocPkg\QuarkNorthCluster\Binary\QuarkMicrocode
   from QuarkPlatformPkg commit to QuarkSocPkg commit
2) Fix incorrect license header in PlatformSecLibModStrs.uni

Changes for V3
==============
1) Set PcdResetOnMemoryTypeInformationChange FALSE in QuarkMin.dsc
   This is required because QuarkMin.dsc uses the emulated variable
   driver that does not preserve any non-volatile UEFI variables
   across reset.  If the condition is met where the memory type
   information variable needs to be updated, then the system will reset
   every time the UEFI Shell is run.  By setting this PCD to FALSE,
   then reset action is disabled.
2) Move one binary file to QuarkSocBinPkg
3) Change RMU.bin FILE statements to INF statement in DSC FD region
   to be compatible with PACKAGES_PATH search for QuarkSocBinPkg

Changes for V2
==============
1) Use new generic PCI serial driver PciSioSerialDxe in MdeModulePkg
2) Configure PcdPciSerialParameters for PCI serial driver for Quark
3) Use new MtrrLib API to reduce time to set MTRRs for all DRAM
4) Convert all UNI files to utf-8
5) Replace tabs with spaces and remove trailing spaces
6) Add License.txt

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Michael Kinney <michael.d.kinney@intel.com>
Acked-by: Jordan Justen <jordan.l.justen@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@19287 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
Michael Kinney
2015-12-15 19:23:57 +00:00
committed by mdkinney
parent 9b6bbcdbfd
commit b303605e1b
190 changed files with 39436 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

390
QuarkPlatformPkg/Acpi/DxeSmm/SmmPowerManagement/Ppm.c Normal file
View File

@@ -0,0 +1,390 @@
/** @file
Processor power management initialization code.
Copyright (c) 2013-2015 Intel Corporation.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which 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.
**/
#include "SmmPowerManagement.h"
//
// Global variables
//
extern EFI_ACPI_SDT_PROTOCOL *mAcpiSdt;
extern EFI_ACPI_TABLE_PROTOCOL *mAcpiTable;
extern EFI_GUID gPowerManagementAcpiTableStorageGuid;
/**
This function is the entry of processor power management initialization code.
It initializes the processor's power management features based on the user
configurations and hardware capabilities.
**/
VOID
PpmInit (
VOID
)
{
//
// Processor Power Management Flags
//
mGlobalNvsAreaPtr->Cfgd = PcdGet32(PcdPpmFlags);
//
// Patch and publish power management related acpi tables
//
PpmPatchAndPublishAcpiTables();
}
/**
This function is to patch and publish power management related acpi tables.
**/
VOID
PpmPatchAndPublishAcpiTables (
VOID
)
{
//
// Patch FADT table to enable C2,C3
//
PpmPatchFadtTable();
//
// Load all the power management acpi tables and patch IST table
//
PpmLoadAndPatchPMTables();
}
/**
This function is to patch PLvl2Lat and PLvl3Lat to enable C2, C3 support in OS.
**/
VOID
PpmPatchFadtTable (
VOID
)
{
EFI_STATUS Status;
EFI_ACPI_DESCRIPTION_HEADER *Table;
EFI_ACPI_SDT_HEADER *CurrentTable;
EFI_ACPI_TABLE_VERSION Version;
UINTN Index;
UINTN Handle;
EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer;
//
// Scan all the acpi tables to find FADT 2.0
//
Index = 0;
do {
Status = mAcpiSdt->GetAcpiTable (
Index,
&CurrentTable,
&Version,
&Handle
);
if (Status == EFI_NOT_FOUND) {
break;
}
ASSERT_EFI_ERROR (Status);
Index++;
} while (CurrentTable->Signature != EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE || CurrentTable->Revision != 0x03);
ASSERT (CurrentTable->Signature == EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE);
Table = NULL;
Status = gBS->AllocatePool (EfiBootServicesData, CurrentTable->Length, (VOID **) &Table);
ASSERT (Table != NULL);
CopyMem (Table, CurrentTable, CurrentTable->Length);
FadtPointer = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE*) Table;
//
// Update the ACPI table and recalculate checksum
//
Status = mAcpiTable->UninstallAcpiTable (mAcpiTable, Handle);
if (EFI_ERROR (Status)) {
//
// Should not get an error here ever, but abort if we do.
//
return ;
}
//
// Update the check sum
// It needs to be zeroed before the checksum calculation
//
((EFI_ACPI_SDT_HEADER *)Table)->Checksum = 0;
((EFI_ACPI_SDT_HEADER *)Table)->Checksum =
CalculateCheckSum8 ((VOID *)Table, Table->Length);
//
// Add the table
//
Status = mAcpiTable->InstallAcpiTable (
mAcpiTable,
Table,
Table->Length,
&Handle
);
ASSERT_EFI_ERROR (Status);
gBS->FreePool (Table);
}
VOID
SsdtTableUpdate (
IN OUT EFI_ACPI_DESCRIPTION_HEADER *TableHeader
)
/*++
Routine Description:
Update the SSDT table
Arguments:
Table - The SSDT table to be patched
Returns:
None
--*/
{
UINT8 *CurrPtr;
UINT8 *SsdtPointer;
UINT32 *Signature;
//
// Loop through the ASL looking for values that we must fix up.
//
CurrPtr = (UINT8 *) TableHeader;
for (SsdtPointer = CurrPtr;
SsdtPointer <= (CurrPtr + ((EFI_ACPI_COMMON_HEADER *) CurrPtr)->Length);
SsdtPointer++
)
{
Signature = (UINT32 *) SsdtPointer;
if ((*Signature) == SIGNATURE_32 ('P', 'M', 'B', 'A')) {
switch (*(Signature+1)) {
case (SIGNATURE_32 ('L', 'V', 'L', '0')):
Signature[0] = PcdGet16(PcdPmbaIoBaseAddress);
Signature[1] = 0;
break;
case (SIGNATURE_32 ('L', 'V', 'L', '2')):
Signature[0] = PcdGet16(PcdPmbaIoLVL2);
Signature[1] = 0;
break;
}
}
}
}
EFI_STATUS
LocateSupportProtocol (
IN EFI_GUID *Protocol,
OUT VOID **Instance,
IN UINT32 Type
)
/*++
Routine Description:
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.
Arguments:
Protocol The protocol to find.
Instance Return pointer to the first instance of the protocol
Returns:
EFI_SUCCESS The function completed successfully.
EFI_NOT_FOUND The protocol could not be located.
EFI_OUT_OF_RESOURCES There are not enough resources to find the protocol.
--*/
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN NumberOfHandles;
EFI_FV_FILETYPE FileType;
UINT32 FvStatus;
EFI_FV_FILE_ATTRIBUTES Attributes;
UINTN Size;
UINTN i;
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 (i = 0; i < NumberOfHandles; i++) {
//
// Get the protocol on this handle
// This should not fail because of LocateHandleBuffer
//
Status = gBS->HandleProtocol (
HandleBuffer[i],
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_VOLUME2_PROTOCOL*) (*Instance))->ReadFile (*Instance,
&gPowerManagementAcpiTableStorageGuid,
NULL,
&Size,
&FileType,
&Attributes,
&FvStatus
);
//
// If we found it, then we are done
//
if (Status == EFI_SUCCESS) {
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 is to load all the power management acpi tables and patch IST table.
**/
VOID
PpmLoadAndPatchPMTables (
VOID
)
{
EFI_FIRMWARE_VOLUME2_PROTOCOL *FwVol;
EFI_STATUS Status;
INTN Instance;
EFI_ACPI_COMMON_HEADER *CurrentTable;
UINTN TableHandle;
UINT32 FvStatus;
UINTN Size;
EFI_ACPI_TABLE_VERSION Version;
Status = LocateSupportProtocol (&gEfiFirmwareVolume2ProtocolGuid, (VOID**)&FwVol, 1);
if (EFI_ERROR (Status)) {
return;
}
//
// Read tables from the storage file.
//
Instance = 0;
CurrentTable = NULL;
while (Status == EFI_SUCCESS) {
Status = FwVol->ReadSection (
FwVol,
&gPowerManagementAcpiTableStorageGuid,
EFI_SECTION_RAW,
Instance,
(VOID**)&CurrentTable,
&Size,
&FvStatus
);
if (!EFI_ERROR(Status)) {
Version = EFI_ACPI_TABLE_VERSION_1_0B | EFI_ACPI_TABLE_VERSION_2_0 | EFI_ACPI_TABLE_VERSION_3_0;
if(((EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable)->OemTableId == SIGNATURE_64 ('C', 'p', 'u', '0', 'I', 's', 't', 0)) {
Version = EFI_ACPI_TABLE_VERSION_NONE;
} else if(((EFI_ACPI_DESCRIPTION_HEADER*) CurrentTable)->OemTableId == SIGNATURE_64 ('C', 'p', 'u', '1', 'I', 's', 't', 0)) {
Version = EFI_ACPI_TABLE_VERSION_NONE;
}
SsdtTableUpdate ((EFI_ACPI_DESCRIPTION_HEADER *) CurrentTable);
//
// Update the check sum
// It needs to be zeroed before the checksum calculation
//
((EFI_ACPI_SDT_HEADER *)CurrentTable)->Checksum = 0;
((EFI_ACPI_SDT_HEADER *)CurrentTable)->Checksum = (UINT8)
CalculateCheckSum8 ((VOID *)CurrentTable, CurrentTable->Length);
//
// Add the table
//
TableHandle = 0;
Status = mAcpiTable->InstallAcpiTable (
mAcpiTable,
CurrentTable,
CurrentTable->Length,
&TableHandle
);
ASSERT_EFI_ERROR (Status);
//
// Increment the instance
//
Instance++;
CurrentTable = NULL;
}
}
}

156
QuarkPlatformPkg/Acpi/DxeSmm/SmmPowerManagement/Ppm.h Normal file
View File

@@ -0,0 +1,156 @@
/** @file
Processor power management initialization code.
Copyright (c) 2013-2015 Intel Corporation.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which 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.
**/
#ifndef _PPM_H
#define _PPM_H
//
// Bit definitions of PPMFlags
//
#define PPM_GV3 (1 << 0) // Geyserville 3
#define PPM_TURBO (1 << 1) // Turbo Mode
#define PPM_SUPER_LFM (1 << 2) // N/2 Ratio
#define PPM_C1 (1 << 4) // C1 Capable, Enabled
#define PPM_C2 (1 << 5) // C2 Capable, Enabled
#define PPM_C3 (1 << 6) // C3 Capable, Enabled
#define PPM_C4 (1 << 7) // C4 Capable, Enabled
#define PPM_C5 (1 << 8) // C5/Deep C4 Capable, Enabled
#define PPM_C6 (1 << 9) // C6 Capable, Enabled
#define PPM_C1E (1 << 10) // C1E Enabled
#define PPM_C2E (1 << 11) // C2E Enabled
#define PPM_C3E (1 << 12) // C3E Enabled
#define PPM_C4E (1 << 13) // C4E Enabled
#define PPM_HARD_C4E (1 << 14) // Hard C4E Capable, Enabled
#define PPM_TM1 (1 << 16) // Thermal Monitor 1
#define PPM_TM2 (1 << 17) // Thermal Monitor 2
#define PPM_PHOT (1 << 19) // Bi-directional ProcHot
#define PPM_MWAIT_EXT (1 << 21) // MWAIT extensions supported
#define PPM_CMP (1 << 24) // CMP supported, Enabled
#define PPM_TSTATE (1 << 28) // CPU T states supported
#define PPM_C_STATES (PPM_C1 + PPM_C2 + PPM_C3 + PPM_C4 + PPM_C5 + PPM_C6)
#define PPM_CE_STATES (PPM_C1E + PPM_C2E + PPM_C3E + PPM_C4E + PPM_HARD_C4E)
#define MAX_P_STATES_NUM 12
#define AML_NAME_OP 0x08
#define AML_SCOPE_OP 0x10
#define AML_PACKAGE_OP 0x12
#define AML_METHOD_OP 0x14
#define S3_CPU_REGISTER_TABLE_GUID \
{ \
0xc4ef988d, 0xe5e, 0x4403, { 0xbe, 0xeb, 0xf1, 0xbb, 0x6, 0x79, 0x6e, 0xdf } \
}
#pragma pack(1)
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;
#pragma pack()
typedef struct {
UINT32 Index;
UINT64 Value;
} S3_CPU_REGISTER;
//
// Function prototypes
//
/**
This function is the entry of processor power management initialization code.
It initializes the processor's power management features based on the user
configurations and hardware capablities.
**/
VOID
PpmInit (
VOID
);
/**
This function is to determine the Processor Power Management Flags
based on the hardware capability.
**/
VOID
PpmDetectCapability (
VOID
);
/**
This function is to determine the user configuration mask
**/
VOID
PpmGetUserConfigurationMask (
VOID
);
/**
This function is to patch and publish power management related acpi tables.
**/
VOID
PpmPatchAndPublishAcpiTables (
VOID
);
/**
This function is to patch PLvl2Lat and PLvl3Lat to enable C2, C3 support in OS.
**/
VOID
PpmPatchFadtTable (
VOID
);
/**
This function is to load all the power management acpi tables and patch IST table.
**/
VOID
PpmLoadAndPatchPMTables (
VOID
);
/**
This function is to save cpu registers for s3 resume.
**/
VOID
PpmS3SaveRegisters (
VOID
);
#endif

119
QuarkPlatformPkg/Acpi/DxeSmm/SmmPowerManagement/SmmPowerManagement.c Normal file
View File

@@ -0,0 +1,119 @@
/** @file
This is QNC Smm Power Management driver
Copyright (c) 2013-2015 Intel Corporation.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which 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.
**/
#include "SmmPowerManagement.h"
//
// Global variables
//
EFI_SMM_CPU_PROTOCOL *mSmmCpu = NULL;
EFI_GLOBAL_NVS_AREA *mGlobalNvsAreaPtr = NULL;
EFI_MP_SERVICES_PROTOCOL *mMpService = NULL;
EFI_ACPI_SDT_PROTOCOL *mAcpiSdt = NULL;
EFI_ACPI_TABLE_PROTOCOL *mAcpiTable = NULL;
EFI_GUID mS3CpuRegisterTableGuid = S3_CPU_REGISTER_TABLE_GUID;
EFI_STATUS
EFIAPI
InitializePowerManagement (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Initializes the SMM Handler Driver
Arguments:
ImageHandle -
SystemTable -
Returns:
None
--*/
{
EFI_STATUS Status;
EFI_SMM_SW_DISPATCH2_PROTOCOL *SwDispatch;
EFI_GLOBAL_NVS_AREA_PROTOCOL *GlobalNvsAreaProtocol;
//
// Get SMM CPU protocol
//
Status = gSmst->SmmLocateProtocol (
&gEfiSmmCpuProtocolGuid,
NULL,
(VOID **)&mSmmCpu
);
ASSERT_EFI_ERROR (Status);
//
// Get the Sw dispatch protocol
//
Status = gSmst->SmmLocateProtocol (
&gEfiSmmSwDispatch2ProtocolGuid,
NULL,
(VOID**)&SwDispatch
);
ASSERT_EFI_ERROR (Status);
//
// Get Global NVS Area Protocol
//
Status = gBS->LocateProtocol (&gEfiGlobalNvsAreaProtocolGuid, NULL, (VOID **)&GlobalNvsAreaProtocol);
ASSERT_EFI_ERROR (Status);
mGlobalNvsAreaPtr = GlobalNvsAreaProtocol->Area;
//
// Locate and cache PI AcpiSdt Protocol.
//
Status = gBS->LocateProtocol (
&gEfiAcpiSdtProtocolGuid,
NULL,
(VOID **) &mAcpiSdt
);
ASSERT_EFI_ERROR (Status);
//
// Locate and cache PI AcpiSdt Protocol.
//
Status = gBS->LocateProtocol (
&gEfiAcpiTableProtocolGuid,
NULL,
(VOID **) &mAcpiTable
);
ASSERT_EFI_ERROR (Status);
//
// Get MpService protocol
//
Status = gBS->LocateProtocol (&gEfiMpServiceProtocolGuid, NULL, (VOID **)&mMpService);
ASSERT_EFI_ERROR (Status);
//
// Initialize power management features on processors
//
PpmInit();
return Status;
}

58
QuarkPlatformPkg/Acpi/DxeSmm/SmmPowerManagement/SmmPowerManagement.h Normal file
View File

@@ -0,0 +1,58 @@
/** @file
Header file for QNC Smm Power Management driver
Copyright (c) 2013-2015 Intel Corporation.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which 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.
**/
#ifndef _SMM_POWER_MANAGEMENT_H_
#define _SMM_POWER_MANAGEMENT_H_
#include <PiSmm.h>
#include <IntelQNCDxe.h>
#include <Protocol/AcpiTable.h>
#include <Protocol/SmmCpu.h>
#include <Protocol/SmmSwDispatch2.h>
#include <Protocol/GlobalNvsArea.h>
#include <Protocol/AcpiSystemDescriptionTable.h>
#include <Protocol/FirmwareVolume2.h>
#include <Protocol/MpService.h>
#include <Library/DebugLib.h>
#include <Library/PcdLib.h>
#include <Library/IoLib.h>
#include <Library/PciLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/SmmServicesTableLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/S3BootScriptLib.h>
#include <Library/MemoryAllocationLib.h>
#include <IndustryStandard/Acpi.h>
#include <AcpiCpuData.h>
#include "Ppm.h"
//
// Module global variable
//
extern EFI_SMM_CPU_PROTOCOL *mSmmCpu;
extern EFI_GLOBAL_NVS_AREA *mGlobalNvsAreaPtr;
extern EFI_MP_SERVICES_PROTOCOL *mMpService;
//
// Function prototypes
//
#endif

80
QuarkPlatformPkg/Acpi/DxeSmm/SmmPowerManagement/SmmPowerManagement.inf Normal file
View File

@@ -0,0 +1,80 @@
## @file
# Component description file for SMM Power Management module
#
# This is QNC Smm Power Management driver .
# Copyright (c) 2013-2015 Intel Corporation.
#
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which 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.
#
##
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = SmmPowerManagement
FILE_GUID = 271F1343-20D6-4e14-9B62-3C0297F56F07
MODULE_TYPE = DXE_SMM_DRIVER
VERSION_STRING = 1.0
PI_SPECIFICATION_VERSION = 0x0001000A
ENTRY_POINT = InitializePowerManagement
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64 IPF EBC
#
[Sources]
SmmPowerManagement.c
SmmPowerManagement.h
Ppm.c
Ppm.h
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
UefiCpuPkg/UefiCpuPkg.dec
QuarkSocPkg/QuarkSocPkg.dec
QuarkPlatformPkg/QuarkPlatformPkg.dec
[LibraryClasses]
UefiDriverEntryPoint
DebugLib
PcdLib
IoLib
PciLib
BaseLib
BaseMemoryLib
SmmServicesTableLib
UefiBootServicesTableLib
S3BootScriptLib
MemoryAllocationLib
[Protocols]
gEfiSmmCpuProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiSmmSwDispatch2ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiGlobalNvsAreaProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiFirmwareVolume2ProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiMpServiceProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiAcpiSdtProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiAcpiTableProtocolGuid # PROTOCOL ALWAYS_CONSUMED
[Guids]
gPowerManagementAcpiTableStorageGuid
[Pcd]
gEfiQuarkNcSocIdTokenSpaceGuid.PcdPmbaIoBaseAddress
gEfiQuarkNcSocIdTokenSpaceGuid.PcdPmbaIoLVL2
gQuarkPlatformTokenSpaceGuid.PcdPpmFlags
[Depex]
gEfiSmmCpuProtocolGuid AND
gEfiSmmSwDispatch2ProtocolGuid AND
gEfiGlobalNvsAreaProtocolGuid AND
gEfiAcpiTableProtocolGuid AND
gEfiMpServiceProtocolGuid