Add various ACPI tables for the Mt. Jade platform including: DSDT, SPCR,
DBG2, GTDT, FACP, SSDT, MADT, PPTT, PCCT, SLIT, SRAT, and NFIT.
Cc: Thang Nguyen <thang@os.amperecomputing.com>
Cc: Chuong Tran <chuong@os.amperecomputing.com>
Cc: Phong Vo <phong@os.amperecomputing.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Ard Biesheuvel <ardb+tianocore@kernel.org>
Cc: Nate DeSimone <nathaniel.l.desimone@intel.com>
Signed-off-by: Nhi Pham <nhi@os.amperecomputing.com>
---
Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc | 8 +
Platform/Ampere/JadePkg/Jade.dsc | 23 +
Platform/Ampere/JadePkg/Jade.fdf | 8 +
Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf | 20 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf | 75 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf | 44 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h | 121 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h | 49 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h | 76 +
Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h | 37 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c | 457 ++
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c | 445 ++
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c | 351 ++
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c | 599 +++
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c | 196 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c | 178 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c | 378 ++
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c | 190 +
Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c | 274 +
Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi | 5639 ++++++++++++++++++++
Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi | 5639 ++++++++++++++++++++
Platform/Ampere/JadePkg/AcpiTables/CPU.asi | 127 +
Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl | 575 ++
Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi | 217 +
Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi | 681 +++
Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi | 2078 ++++++++
Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi | 2087 ++++++++
Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi | 1303 +++++
Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi | 1303 +++++
Platform/Ampere/JadePkg/AcpiTables/PMU.asi | 10 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc | 33 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc | 87 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl | 165 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc | 87 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc | 180 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl | 330 ++
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl | 17 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc | 81 +
Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl | 15 +
39 files changed, 24183 insertions(+)
diff --git a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
index 3c47099b8edc..11f50f2f09cd 100755
--- a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
+++ b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
@@ -466,6 +466,14 @@ [PcdsFixedAtBuild.common]
#
gEfiMdeModulePkgTokenSpaceGuid.PcdBootManagerMenuFile|{ 0x21, 0xaa, 0x2c, 0x46, 0x14, 0x76, 0x03, 0x45, 0x83, 0x6e, 0x8a, 0xb6, 0xf4, 0x66, 0x23, 0x31 }
+ #
+ # ACPI table
+ #
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId|"Ampere"
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId|0x2020206172746C41 # Altra
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId|0x2E504D41 # AMP.
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision|0x01000013
+
#
# Enable strict image permissions for all images. (This applies
# only to images that were built with >= 4 KB section alignment.)
diff --git a/Platform/Ampere/JadePkg/Jade.dsc b/Platform/Ampere/JadePkg/Jade.dsc
index 9b9a5d0bad0f..0f9d0adbd34e 100755
--- a/Platform/Ampere/JadePkg/Jade.dsc
+++ b/Platform/Ampere/JadePkg/Jade.dsc
@@ -81,12 +81,24 @@ [LibraryClasses]
#
FailSafeLib|Platform/Ampere/AmperePlatformPkg/Library/FailSafeLib/FailSafeLib.inf
+ #
+ # ACPI Libraries
+ #
+ AcpiLib|EmbeddedPkg/Library/AcpiLib/AcpiLib.inf
+ AcpiHelperLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiHelperLib/AcpiHelperLib.inf
+ AcpiPccLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiPccLib/AcpiPccLib.inf
+
################################################################################
#
# Specific Platform Pcds
#
################################################################################
[PcdsFeatureFlag.common]
+ #
+ # Activate AcpiSdtProtocol
+ #
+ gEfiMdeModulePkgTokenSpaceGuid.PcdInstallAcpiSdtProtocol|TRUE
+
[PcdsFixedAtBuild.common]
!if $(SECURE_BOOT_ENABLE) == TRUE
@@ -108,3 +120,14 @@ [Components.common]
# FailSafe and Watchdog Timer
#
Platform/Ampere/AmperePlatformPkg/Drivers/FailSafeDxe/FailSafeDxe.inf
+
+ #
+ # ACPI
+ #
+ MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf {
+ <PcdsFixedAtBuild>
+ gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2B
+ }
+ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
+ Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
+ Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
diff --git a/Platform/Ampere/JadePkg/Jade.fdf b/Platform/Ampere/JadePkg/Jade.fdf
index 375455086d0b..2c6f9fac76fd 100755
--- a/Platform/Ampere/JadePkg/Jade.fdf
+++ b/Platform/Ampere/JadePkg/Jade.fdf
@@ -289,4 +289,12 @@ [FV.FvMain]
#
!include NetworkPkg/Network.fdf.inc
+ #
+ # ACPI
+ #
+ INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf
+ INF Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
+ INF RuleOverride=ACPITABLE Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
+ INF RuleOverride=ACPITABLE Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
+
!include Platform/Ampere/AmperePlatformPkg/FvRules.fdf.inc
diff --git a/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
new file mode 100644
index 000000000000..1cf632f8a406
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
@@ -0,0 +1,20 @@
+## @file
+#
+# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+#
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+ INF_VERSION = 0x0001001B
+ BASE_NAME = JadeAcpiTables
+ FILE_GUID = 5ADDBC13-8634-480C-9B94-671B7855CDB8
+ MODULE_TYPE = USER_DEFINED
+ VERSION_STRING = 1.0
+
+[Sources]
+ Dsdt.asl
+
+[Packages]
+ MdePkg/MdePkg.dec
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
new file mode 100644
index 000000000000..a1a323eee472
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
@@ -0,0 +1,75 @@
+## @file
+#
+# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+#
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+ INF_VERSION = 0x0001001B
+ BASE_NAME = AcpiPlatformDxe
+ FILE_GUID = CDA4ED56-6960-4092-885D-FEF37D29093E
+ MODULE_TYPE = DXE_DRIVER
+ VERSION_STRING = 1.0
+ ENTRY_POINT = AcpiPlatformDxeInitialize
+
+[Sources.common]
+ AcpiApei.c
+ AcpiApei.h
+ AcpiDsdt.c
+ AcpiMadt.c
+ AcpiNfit.c
+ AcpiPcct.c
+ AcpiPptt.c
+ AcpiPlatform.h
+ AcpiPlatformDxe.c
+ AcpiSlit.c
+ AcpiSrat.c
+
+[Packages]
+ ArmPkg/ArmPkg.dec
+ ArmPlatformPkg/ArmPlatformPkg.dec
+ EmbeddedPkg/EmbeddedPkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+ MdePkg/MdePkg.dec
+ Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
+ Silicon/Ampere/AmpereSiliconPkg/AmpereSiliconPkg.dec
+
+[LibraryClasses]
+ AcpiHelperLib
+ AcpiLib
+ AcpiPccLib
+ AmpereCpuLib
+ BaseLib
+ DebugLib
+ FlashLib
+ UefiBootServicesTableLib
+ UefiDriverEntryPoint
+ UefiLib
+ UefiRuntimeServicesTableLib
+
+[Pcd]
+ gArmPlatformTokenSpaceGuid.PcdCoreCount
+ gArmPlatformTokenSpaceGuid.PcdClusterCount
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision
+ gAmpereTokenSpaceGuid.PcdPmproDbBaseReg
+ gAmpereTokenSpaceGuid.PcdSmproDbBaseReg
+
+[Guids]
+ gArmMpCoreInfoGuid
+ gEfiAcpiTableGuid
+ gEfiEventReadyToBootGuid
+ gPlatformHobGuid
+
+[Protocols]
+ gEfiAcpiTableProtocolGuid ## ALWAYS_CONSUMED
+ gEfiAcpiSdtProtocolGuid
+ gEfiPciRootBridgeIoProtocolGuid
+
+[Depex]
+ gEfiAcpiTableProtocolGuid
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
new file mode 100644
index 000000000000..acc4092c650d
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
@@ -0,0 +1,44 @@
+## @file
+#
+# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+#
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+##
+
+[Defines]
+ INF_VERSION = 0x0001001B
+ BASE_NAME = AcpiCommonTables
+ FILE_GUID = CEFA2AEB-357E-4F48-8066-EA950853056E
+ MODULE_TYPE = USER_DEFINED
+ VERSION_STRING = 1.0
+
+[Sources]
+ Bert.aslc
+ Dbg2.aslc
+ Einj.asl
+ Fadt.aslc
+ Gtdt.aslc
+ Hest.asl
+ Sdei.asl
+ Spcr.aslc
+ Ssdt.asl
+
+[Packages]
+ ArmPkg/ArmPkg.dec
+ ArmPlatformPkg/ArmPlatformPkg.dec
+ EmbeddedPkg/EmbeddedPkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+ MdePkg/MdePkg.dec
+ Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
+
+[FixedPcd]
+ gEfiMdeModulePkgTokenSpaceGuid.PcdSerialRegisterBase ## CONSUMES
+ gArmPlatformTokenSpaceGuid.PL011UartInterrupt ## CONSUMES
+ gArmPlatformTokenSpaceGuid.PcdWatchdogCount ## CONSUMES
+
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision ## CONSUMES
+ gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision ## CONSUMES
+
+ gArmPlatformTokenSpaceGuid.PcdSerialDbgRegisterBase ## CONSUMES
+ gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate ## CONSUMES
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
new file mode 100644
index 000000000000..c207142459ad
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
@@ -0,0 +1,121 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef ACPI_APEI_H_
+#define ACPI_APEI_H_
+
+#include <Base.h>
+#include <IndustryStandard/Acpi63.h>
+#include <Library/AcpiHelperLib.h>
+#include <Library/AmpereCpuLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Platform/Ac01.h>
+#include <Protocol/AcpiTable.h>
+
+#pragma pack(1)
+#define BERT_MSG_SIZE 0x2C
+#define BERT_ERROR_TYPE 0x7F
+#define BERT_UEFI_FAILURE 5
+#define RAS_2P_TYPE 0x03
+#define BERT_DEFAULT_ERROR_SEVERITY 0x1
+#define GENERIC_ERROR_DATA_REVISION 0x300
+
+
+#define PLAT_CRASH_ITERATOR_SIZE 0x398
+#define SMPRO_CRASH_SIZE 0x800
+#define PMPRO_CRASH_SIZE 0x800
+#define HEST_NUM_ENTRIES_PER_SOC 3
+
+#define CURRENT_BERT_VERSION 0x10
+#define BERT_FLASH_OFFSET 0x91B30000ULL
+#define BERT_DDR_OFFSET 0x88230000ULL
+#define BERT_DDR_LENGTH 0x50000
+
+typedef struct {
+ UINT8 Type;
+ UINT8 SubType;
+ UINT16 Instance;
+ CHAR8 Msg[BERT_MSG_SIZE];
+} APEI_BERT_ERROR_DATA;
+
+typedef struct {
+ APEI_BERT_ERROR_DATA Vendor;
+ UINT8 BertRev;
+ UINT8 S0PmproRegisters[PMPRO_CRASH_SIZE];
+ UINT8 S0SmproRegisters[SMPRO_CRASH_SIZE];
+ UINT8 S1PmproRegisters[PMPRO_CRASH_SIZE];
+ UINT8 S1SmproRegisters[SMPRO_CRASH_SIZE];
+ UINT8 AtfDump[PLATFORM_CPU_MAX_NUM_CORES * PLAT_CRASH_ITERATOR_SIZE];
+} APEI_CRASH_DUMP_DATA;
+
+typedef struct {
+ EFI_ACPI_6_3_GENERIC_ERROR_STATUS_STRUCTURE Ges;
+ EFI_ACPI_6_3_GENERIC_ERROR_DATA_ENTRY_STRUCTURE Ged;
+ APEI_CRASH_DUMP_DATA Bed;
+} APEI_CRASH_DUMP_BERT_ERROR;
+#pragma pack()
+
+VOID
+EFIAPI
+CreateDefaultBertData (
+ APEI_BERT_ERROR_DATA *Data
+ );
+
+VOID
+EFIAPI
+WrapBertErrorData (
+ APEI_CRASH_DUMP_BERT_ERROR *WrappedError
+ );
+
+VOID
+EFIAPI
+PullBertSpinorData (
+ APEI_CRASH_DUMP_DATA *BertErrorData
+ );
+
+VOID
+EFIAPI
+AdjustBERTRegionLen (
+ UINT32 Len
+ );
+
+BOOLEAN
+EFIAPI
+IsBertEnabled (
+ VOID
+ );
+
+VOID
+EFIAPI
+WriteDDRBertTable (
+ APEI_CRASH_DUMP_BERT_ERROR *Data
+ );
+
+VOID
+WriteSpinorDefaultBertTable (
+ APEI_CRASH_DUMP_DATA *SpiRefrenceData
+ );
+
+EFI_STATUS
+EFIAPI
+AcpiApeiUpdate (
+ VOID
+ );
+
+EFI_STATUS
+EFIAPI
+AcpiPopulateBert (
+ VOID
+ );
+
+#endif /* ACPI_APEI_H_ */
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
new file mode 100644
index 000000000000..920579281dd5
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
@@ -0,0 +1,49 @@
+/** @file
+
+ Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef ACPI_NFIT_H_
+#define ACPI_NFIT_H_
+
+#include <Platform/Ac01.h>
+
+#define NVDIMM_SK0 0
+#define NVDIMM_SK1 1
+#define NVDIMM_NUM_PER_SK (PLATFORM_NVDIMM_MCU_MAX_PER_SK * PLATFORM_NVDIMM_NUM_MAX_PER_MCU)
+#define ONE_GB (1024 * 1024 * 1024)
+
+enum NvdimmMode {
+ NVDIMM_DISABLED = 0,
+ NVDIMM_NON_HASHED = 1,
+ NVDIMM_HASHED = 2
+};
+
+typedef struct {
+ BOOLEAN Enabled;
+ UINT64 NvdSize;
+ UINT32 DeviceHandle;
+ UINT16 PhysId;
+ UINT8 InterleaveWays;
+ UINT64 RegionOffset;
+ UINT16 VendorId;
+ UINT16 DeviceId;
+ UINT16 RevisionId;
+ UINT16 SubVendorId;
+ UINT16 SubDeviceId;
+ UINT16 SubRevisionId;
+ UINT32 SerialNumber;
+} NVDIMM_INFO;
+
+typedef struct {
+ UINT8 NvdRegionNum;
+ UINT8 NvdRegionId[PLATFORM_NVDIMM_REGION_MAX_PER_SK];
+ UINT8 NvdMode;
+ UINT8 NvdNum;
+ NVDIMM_INFO NvdInfo[NVDIMM_NUM_PER_SK];
+} NVDIMM_DATA;
+
+#endif
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
new file mode 100644
index 000000000000..ce4d9b8440b8
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
@@ -0,0 +1,76 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef ACPI_PLATFORM_H_
+#define ACPI_PLATFORM_H_
+
+#include <Uefi.h>
+
+#include <AcpiHeader.h>
+#include <Guid/EventGroup.h>
+#include <Guid/PlatformInfoHobGuid.h>
+#include <IndustryStandard/Acpi63.h>
+#include <Library/ArmLib/ArmLibPrivate.h>
+#include <Library/AcpiHelperLib.h>
+#include <Library/AcpiLib.h>
+#include <Library/AmpereCpuLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/HobLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+#include <Library/PrintLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Platform/Ac01.h>
+#include <PlatformInfoHob.h>
+#include <Protocol/AcpiTable.h>
+
+EFI_STATUS
+AcpiPatchDsdtTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallMadtTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallNfitTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiPcctInit (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallPcctTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallPpttTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallSlitTable (
+ VOID
+ );
+
+EFI_STATUS
+AcpiInstallSratTable (
+ VOID
+ );
+
+#endif /* ACPI_PLATFORM_H_ */
diff --git a/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
new file mode 100644
index 000000000000..d604b712d8c8
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
@@ -0,0 +1,37 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef ACPI_HEADER_H_
+#define ACPI_HEADER_H_
+
+#include <IndustryStandard/Acpi.h>
+
+//
+// ACPI table information used to initialize tables.
+//
+#define EFI_ACPI_OEM_ID {'A','m','p','e','r','e'}
+#define EFI_ACPI_OEM_TABLE_ID SIGNATURE_64('A','l','t','r','a',' ',' ',' ')
+#define EFI_ACPI_OEM_REVISION FixedPcdGet32 (PcdAcpiDefaultOemRevision)
+#define EFI_ACPI_CREATOR_ID SIGNATURE_32('A','M','P','.')
+#define EFI_ACPI_CREATOR_REVISION FixedPcdGet32 (PcdAcpiDefaultCreatorRevision)
+
+// A macro to initialise the common header part of EFI ACPI tables as defined by
+// EFI_ACPI_DESCRIPTION_HEADER structure.
+#define __ACPI_HEADER(Signature, Type, Revision) { \
+ Signature, /* UINT32 Signature */ \
+ sizeof (Type), /* UINT32 Length */ \
+ Revision, /* UINT8 Revision */ \
+ 0, /* UINT8 Checksum */ \
+ EFI_ACPI_OEM_ID, /* UINT8 OemId[6] */ \
+ EFI_ACPI_OEM_TABLE_ID, /* UINT64 OemTableId */ \
+ EFI_ACPI_OEM_REVISION, /* UINT32 OemRevision */ \
+ EFI_ACPI_CREATOR_ID, /* UINT32 CreatorId */ \
+ EFI_ACPI_CREATOR_REVISION /* UINT32 CreatorRevision */ \
+ }
+
+#endif /* ACPI_HEADER_H_ */
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
new file mode 100644
index 000000000000..fa188c7776db
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
@@ -0,0 +1,457 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Uefi.h>
+
+#include <Library/AcpiHelperLib.h>
+#include <Library/FlashLib.h>
+#include <Library/NVParamLib.h>
+#include <NVParamDef.h>
+
+#include "AcpiApei.h"
+
+UINT8 AMPERE_GUID[16] = {0x8d, 0x89, 0xed, 0xe8, 0x16, 0xdf, 0xcc, 0x43, 0x8e, 0xcc, 0x54, 0xf0, 0x60, 0xef, 0x15, 0x7f};
+CHAR8 DEFAULT_BERT_REBOOT_MSG[BERT_MSG_SIZE] = "Unknown reboot reason";
+
+STATIC VOID
+AcpiApeiUninstallTable (
+ UINT32 Signature
+ )
+{
+ EFI_STATUS Status;
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol;
+ EFI_ACPI_SDT_HEADER *Table;
+ EFI_ACPI_TABLE_VERSION TableVersion;
+ UINTN TableKey;
+ UINTN Idx;
+
+ /*
+ * Get access to ACPI tables
+ */
+ Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **)&AcpiTableProtocol);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table protocol\n", __FUNCTION__, __LINE__));
+ return;
+ }
+
+ Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table support protocol\n", __FUNCTION__, __LINE__));
+ return;
+ }
+
+ /*
+ * Search for ACPI Table Signature
+ */
+ for (Idx = 0; ; Idx++) {
+ Status = AcpiTableSdtProtocol->GetAcpiTable (Idx, &Table, &TableVersion, &TableKey);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "%a:%d: Unable to get ACPI table index %d \n", __FUNCTION__, __LINE__, Idx));
+ return;
+ } else if (Table->Signature == Signature) {
+ break;
+ }
+ }
+
+ /*
+ * Uninstall ACPI Table
+ */
+ Status = AcpiTableProtocol->UninstallAcpiTable (AcpiTableProtocol, TableKey);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "%a:%d: Unable to uninstall table\n", __FUNCTION__, __LINE__));
+ }
+}
+
+VOID
+AdjustBERTRegionLen (
+ UINT32 Len
+ )
+{
+ UINT32 Signature = EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE;
+ EFI_STATUS Status;
+ EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
+ EFI_ACPI_TABLE_VERSION TableVersion;
+ UINTN TableKey;
+ UINTN Idx;
+ EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER *Table;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiSdtProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableSdtProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
+ return;
+ }
+
+ /*
+ * Search for ACPI Table Signature
+ */
+ for (Idx = 0; ; Idx++) {
+ Status = AcpiTableSdtProtocol->GetAcpiTable (
+ Idx,
+ (EFI_ACPI_SDT_HEADER **)&Table,
+ &TableVersion,
+ &TableKey
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "APEI: Unable to get ACPI table index:%d\n", Idx));
+ return;
+ } else if (Table->Header.Signature == Signature) {
+ break;
+ }
+ }
+
+ /*
+ * Adjust Boot Error Region Length
+ */
+ Table->BootErrorRegionLength = Len;
+
+ AcpiTableChecksum ((UINT8 *)Table, Table->Header.Length);
+}
+
+/*
+ * Retrieve Bert data from SPI NOR
+ */
+VOID
+PullBertSpinorData (
+ APEI_CRASH_DUMP_DATA *BertErrorData
+ )
+{
+ UINTN Length;
+
+ Length = sizeof (*BertErrorData);
+
+ FlashReadCommand (
+ (UINT8 *)BERT_FLASH_OFFSET,
+ (UINT8 *)BertErrorData,
+ &Length
+ );
+}
+
+/*
+ * wrap raw bert error data
+ *
+ * @param IN BertErrorData Bert Error record to be wrapped
+ * @param OUT WrappedError Generic error data for OS to consume.
+ */
+VOID
+WrapBertErrorData (
+ APEI_CRASH_DUMP_BERT_ERROR *WrappedError
+ )
+{
+ UINT32 CrashSize;
+
+ CrashSize = PLAT_CRASH_ITERATOR_SIZE *
+ GetNumberOfSupportedSockets () *
+ GetMaximumNumberOfCores ();
+ CrashSize += 2 * (SMPRO_CRASH_SIZE + PMPRO_CRASH_SIZE);
+ CrashSize += sizeof (WrappedError->Bed.Vendor) + sizeof (WrappedError->Bed.BertRev);
+
+ WrappedError->Ges.BlockStatus.ErrorDataEntryCount = 1;
+ WrappedError->Ges.BlockStatus.UncorrectableErrorValid = 1;
+ WrappedError->Ged.ErrorSeverity = BERT_DEFAULT_ERROR_SEVERITY;
+ WrappedError->Ged.Revision = GENERIC_ERROR_DATA_REVISION;
+
+ if (WrappedError->Bed.Vendor.Type == RAS_2P_TYPE ||
+ (WrappedError->Bed.Vendor.Type == BERT_ERROR_TYPE &&
+ (WrappedError->Bed.Vendor.SubType == 0 ||
+ WrappedError->Bed.Vendor.SubType == BERT_UEFI_FAILURE)))
+ {
+ WrappedError->Ged.ErrorDataLength = sizeof (WrappedError->Bed.Vendor) +
+ sizeof (WrappedError->Bed.BertRev);
+ WrappedError->Ges.DataLength = sizeof (WrappedError->Bed.Vendor) +
+ sizeof (WrappedError->Bed.BertRev) +
+ sizeof (WrappedError->Ged);
+ AdjustBERTRegionLen (
+ sizeof (WrappedError->Bed.Vendor) +
+ sizeof (WrappedError->Bed.BertRev) +
+ sizeof (WrappedError->Ged) +
+ sizeof (WrappedError->Ges)
+ );
+ } else {
+ WrappedError->Ged.ErrorDataLength = CrashSize;
+ WrappedError->Ges.DataLength = CrashSize + sizeof (WrappedError->Ged);
+ AdjustBERTRegionLen (
+ CrashSize +
+ sizeof (WrappedError->Ged) +
+ sizeof (WrappedError->Ges)
+ );
+ }
+ CopyMem (
+ WrappedError->Ged.SectionType,
+ AMPERE_GUID,
+ sizeof (AMPERE_GUID)
+ );
+}
+
+
+/*
+ * create default bert error
+ * Msg: Unknown reboot reason
+ */
+VOID
+CreateDefaultBertData (
+ APEI_BERT_ERROR_DATA *Data
+ )
+{
+ Data->Type = BERT_ERROR_TYPE;
+ AsciiStrCpyS (
+ Data->Msg,
+ BERT_MSG_SIZE,
+ DEFAULT_BERT_REBOOT_MSG
+ );
+}
+
+/*
+ * Ensures BertErrorData In SPINOR matches
+ * the record produced by CreateDefaultBertData.
+ * @param Bed Crash dump Data
+ */
+VOID
+WriteSpinorDefaultBertTable (
+ APEI_CRASH_DUMP_DATA *Bed
+ )
+{
+ UINT8 BertRev;
+ UINTN Length;
+ UINT64 Offset;
+ UINT32 MsgDiff;
+ APEI_BERT_ERROR_DATA DefaultData = {0};
+
+ CreateDefaultBertData (&DefaultData);
+ if ((Bed->Vendor.Type != DefaultData.Type)) {
+ Offset = BERT_FLASH_OFFSET +
+ OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
+ OFFSET_OF (APEI_BERT_ERROR_DATA, Type);
+ Length = sizeof (DefaultData.Type);
+ FlashEraseCommand ((UINT8 *)Offset, Length);
+ FlashProgramCommand (
+ (UINT8 *)Offset,
+ (UINT8 *)&(DefaultData.Type),
+ &Length
+ );
+ }
+
+ if ((Bed->Vendor.SubType != DefaultData.SubType)) {
+ Offset = BERT_FLASH_OFFSET +
+ OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
+ OFFSET_OF (APEI_BERT_ERROR_DATA, SubType);
+ Length = sizeof (DefaultData.SubType);
+ FlashEraseCommand ((UINT8 *)Offset, Length);
+ FlashProgramCommand (
+ (UINT8 *)Offset,
+ (UINT8 *)&(DefaultData.SubType),
+ &Length
+ );
+ }
+
+ if ((Bed->Vendor.Instance != DefaultData.Instance)) {
+ Offset = BERT_FLASH_OFFSET +
+ OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
+ OFFSET_OF (APEI_BERT_ERROR_DATA, Instance);
+ Length = sizeof (DefaultData.Instance);
+ FlashEraseCommand ((UINT8 *)Offset, Length);
+ FlashProgramCommand (
+ (UINT8 *)Offset,
+ (UINT8 *)&(DefaultData.Instance),
+ &Length
+ );
+ }
+
+ MsgDiff = AsciiStrnCmp (Bed->Vendor.Msg, DefaultData.Msg, BERT_MSG_SIZE);
+ if (MsgDiff != 0) {
+ Offset = BERT_FLASH_OFFSET +
+ OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
+ OFFSET_OF (APEI_BERT_ERROR_DATA, Msg);
+ Length = sizeof (DefaultData.Msg);
+ FlashEraseCommand ((UINT8 *)Offset, Length);
+ FlashProgramCommand (
+ (UINT8 *)Offset,
+ (UINT8 *)&(DefaultData.Msg),
+ &Length
+ );
+ }
+
+ if (Bed->BertRev != CURRENT_BERT_VERSION) {
+ Offset = BERT_FLASH_OFFSET + OFFSET_OF (APEI_CRASH_DUMP_DATA, BertRev);
+ Length = sizeof (Bed->BertRev);
+ BertRev = CURRENT_BERT_VERSION;
+ FlashEraseCommand ((UINT8 *)Offset, Length);
+ FlashProgramCommand ((UINT8 *)Offset, (UINT8 *)&BertRev, &Length);
+ }
+
+}
+
+/*
+ * Checks Status of NV_SI_RAS_BERT_ENABLED
+ * Returns TRUE if enabled and FALSE if disabled
+ */
+BOOLEAN
+IsBertEnabled (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Value;
+
+ Status = NVParamGet (
+ NV_SI_RAS_BERT_ENABLED,
+ NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
+ &Value
+ );
+ if (EFI_ERROR (Status)) {
+ // BERT is enabled by default
+ return TRUE;
+ }
+
+ return (Value != 0) ? TRUE : FALSE;
+}
+
+/*
+ * Write bert table to DDR
+ */
+VOID
+WriteDDRBertTable (
+ APEI_CRASH_DUMP_BERT_ERROR *Data
+ )
+{
+ VOID *Blk = (VOID *)BERT_DDR_OFFSET;
+
+ /*
+ * writing sizeof data to ddr produces alignment error
+ * this is a temporary workaround
+ */
+ CopyMem (Blk, Data, BERT_DDR_LENGTH);
+}
+
+/*
+ * Update Bert Table
+ */
+EFI_STATUS
+AcpiPopulateBert (
+ VOID
+ )
+{
+ APEI_CRASH_DUMP_BERT_ERROR *DDRError;
+
+ DDRError =
+ (APEI_CRASH_DUMP_BERT_ERROR *)
+ AllocateZeroPool (sizeof (APEI_CRASH_DUMP_BERT_ERROR));
+
+ if (DDRError == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ if (IsBertEnabled ()) {
+ PullBertSpinorData (&(DDRError->Bed));
+ if ((DDRError->Bed.BertRev == CURRENT_BERT_VERSION)) {
+ WrapBertErrorData (DDRError);
+ WriteDDRBertTable (DDRError);
+ }
+ WriteSpinorDefaultBertTable (&(DDRError->Bed));
+ }
+
+ FreePool (DDRError);
+ return EFI_SUCCESS;
+}
+
+/*
+ * Checks Status of NV_SI_RAS_SDEI_ENABLED
+ * Returns TRUE if enabled and FALSE if disabled or error occurred
+ */
+BOOLEAN
+IsSdeiEnabled (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Value;
+
+ Status = NVParamGet (
+ NV_SI_RAS_SDEI_ENABLED,
+ NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
+ &Value
+ );
+ if (EFI_ERROR (Status)) {
+ // SDEI is disabled by default
+ return FALSE;
+ }
+
+ return (Value != 0) ? TRUE : FALSE;
+}
+
+STATIC
+VOID
+AcpiApeiHestUpdateTable1P (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
+ EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_HEADER *HestTablePointer;
+ EFI_ACPI_TABLE_VERSION TableVersion;
+ UINTN TableKey;
+ UINTN Idx;
+
+ Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
+ return;
+ }
+
+ /*
+ * Search for ACPI Table Signature
+ */
+ for (Idx = 0; ; Idx++) {
+ Status = AcpiTableSdtProtocol->GetAcpiTable (
+ Idx,
+ (EFI_ACPI_SDT_HEADER **)&HestTablePointer,
+ &TableVersion,
+ &TableKey
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "APEI: Unable to get HEST table"));
+ return;
+ } else if (HestTablePointer->Header.Signature ==
+ EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE)
+ {
+ break;
+ }
+ }
+
+ HestTablePointer->ErrorSourceCount -= HEST_NUM_ENTRIES_PER_SOC;
+ HestTablePointer->Header.Length -=
+ (HEST_NUM_ENTRIES_PER_SOC *
+ sizeof (EFI_ACPI_6_3_GENERIC_HARDWARE_ERROR_SOURCE_VERSION_2_STRUCTURE));
+
+ AcpiTableChecksum ((UINT8 *)HestTablePointer, HestTablePointer->Header.Length);
+}
+
+/*
+ * Update APEI
+ *
+ */
+EFI_STATUS
+EFIAPI
+AcpiApeiUpdate (
+ VOID
+ )
+{
+ if (!IsSlaveSocketActive ()) {
+ AcpiApeiHestUpdateTable1P ();
+ }
+
+ if (!IsSdeiEnabled ()) {
+ AcpiApeiUninstallTable (EFI_ACPI_6_3_SOFTWARE_DELEGATED_EXCEPTIONS_INTERFACE_TABLE_SIGNATURE);
+ }
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
new file mode 100644
index 000000000000..7881044104e4
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
@@ -0,0 +1,445 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Protocol/PciRootBridgeIo.h>
+#include <Library/NVParamLib.h>
+#include <NVParamDef.h>
+
+#include "AcpiNfit.h"
+#include "AcpiPlatform.h"
+
+#define PCIE_DEVICE_CONTROL_OFFSET 0x078
+#define PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN 0x08
+#define PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN 0x04
+#define PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN 0x02
+#define PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN 0x01
+
+#define PCIE_ROOT_ERR_CMD_OFFSET 0x12C
+#define PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN 0x4
+#define PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN 0x2
+#define PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN 0x1
+
+#define PCIE_MAX_DEVICE_PER_ROOT_PORT 8
+
+STATIC VOID
+AcpiPatchCmn600 (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINTN Index;
+
+ for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.CMN%1X._STA", Index);
+ if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
+ } else {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+}
+
+STATIC VOID
+AcpiPatchDmc620 (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINTN Index, Index1;
+ PLATFORM_INFO_HOB *PlatformHob;
+ UINT32 McuMask;
+ VOID *Hob;
+
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL) {
+ return;
+ }
+
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
+ McuMask = PlatformHob->DramInfo.McuMask[Index];
+ for (Index1 = 0; Index1 < sizeof (McuMask) * 8; Index1++) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.MC%1X%1X._STA", Index, Index1);
+ if (McuMask & (0x1 << Index1)) {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
+ } else {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+ }
+}
+
+STATIC VOID
+AcpiPatchNvdimm (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINTN NvdRegionNumSK0, NvdRegionNumSK1, NvdRegionNum, Count;
+ PLATFORM_INFO_HOB *PlatformHob;
+ VOID *Hob;
+
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL) {
+ return;
+ }
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ NvdRegionNumSK0 = 0;
+ NvdRegionNumSK1 = 0;
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ if (PlatformHob->DramInfo.NvdRegion[Count] > 0) {
+ if (PlatformHob->DramInfo.Socket[Count] == 0) {
+ NvdRegionNumSK0++;
+ } else {
+ NvdRegionNumSK1++;
+ }
+ }
+ }
+ NvdRegionNum = NvdRegionNumSK0 + NvdRegionNumSK1;
+
+ /* Disable NVDIMM Root Device */
+ if (NvdRegionNum == 0) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ /* Update NVDIMM Device _STA for SK0 */
+ if (NvdRegionNumSK0 == 0) {
+ /* Disable NVD1/2 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ } else if (NvdRegionNumSK0 == 1) {
+ if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK0] == NVDIMM_NON_HASHED) {
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
+ PlatformHob->DramInfo.Socket[Count] == 0)
+ {
+ if (PlatformHob->DramInfo.Base[Count] ==
+ PLATFORM_NVDIMM_SK0_NHASHED_REGION0)
+ {
+ /* Disable NVD2 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ } else if (PlatformHob->DramInfo.Base[Count] ==
+ PLATFORM_NVDIMM_SK0_NHASHED_REGION1)
+ {
+ /* Disable NVD1 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+ }
+ }
+ }
+ /* Update NVDIMM Device _STA for SK1 */
+ if (NvdRegionNumSK1 == 0) {
+ /* Disable NVD3/4 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ } else if (NvdRegionNumSK1 == 1) {
+ if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK1] == NVDIMM_NON_HASHED) {
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
+ PlatformHob->DramInfo.Socket[Count] == 1)
+ {
+ if (PlatformHob->DramInfo.Base[Count] ==
+ PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
+ {
+ /* Disable NVD4 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ } else if (PlatformHob->DramInfo.Base[Count] ==
+ PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
+ {
+ /* Disable NVD3 */
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+ }
+ }
+ }
+}
+
+STATIC VOID
+AcpiPatchHwmon (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINT8 Index;
+
+ // PCC Hardware Monitor Devices
+ for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index);
+ if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
+ } else {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+
+ // Ampere Altra SoC Hardware Monitor Devices
+ for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index + 2);
+ if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
+ } else {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+}
+
+STATIC VOID
+AcpiPatchDsu (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINTN Index;
+
+ for (Index = 0; Index < PLATFORM_CPU_MAX_NUM_CORES; Index += PLATFORM_CPU_NUM_CORES_PER_CPM) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.DU%2X._STA", Index / PLATFORM_CPU_NUM_CORES_PER_CPM);
+ if (IsCpuEnabled (Index)) {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
+ } else {
+ AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
+ }
+ }
+}
+
+VOID
+AcpiPatchPcieNuma (
+ VOID
+ )
+{
+ CHAR8 NodePath[MAX_ACPI_NODE_PATH];
+ UINTN Index;
+ UINTN NumaIdx;
+ UINTN NumPciePort;
+ UINTN NumaAssignment[3][16] = {
+ { 0, 0, 0, 0, 0, 0, 0, 0, // Monolithic Node 0 (S0)
+ 1, 1, 1, 1, 1, 1, 1, 1 }, // Monolithic Node 1 (S1)
+ { 0, 1, 0, 1, 0, 0, 1, 1, // Hemisphere Node 0, 1 (S0)
+ 2, 3, 2, 3, 2, 2, 3, 3 }, // Hemisphere Node 2, 3 (S1)
+ { 0, 2, 1, 3, 1, 1, 3, 3, // Quadrant Node 0, 1, 2, 3 (S0)
+ 4, 6, 5, 7, 5, 5, 7, 7 }, // Quadrant Node 4, 5, 6, 7 (S1)
+ };
+
+ switch (CpuGetSubNumaMode ()) {
+ case SUBNUMA_MODE_MONOLITHIC:
+ NumaIdx = 0;
+ break;
+
+ case SUBNUMA_MODE_HEMISPHERE:
+ NumaIdx = 1;
+ break;
+
+ case SUBNUMA_MODE_QUADRANT:
+ NumaIdx = 2;
+ break;
+
+ default:
+ NumaIdx = 0;
+ break;
+ }
+
+ if (IsSlaveSocketActive ()) {
+ NumPciePort = 16; // 16 ports total (8 per socket)
+ } else {
+ NumPciePort = 8; // 8 ports total
+ }
+
+ for (Index = 0; Index < NumPciePort; Index++) {
+ AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.PCI%X._PXM", Index);
+ AcpiDSDTSetNodeStatusValue (NodePath, NumaAssignment[NumaIdx][Index]);
+ }
+}
+
+EFI_STATUS
+AcpiPatchPcieAerFwFirst (
+ VOID
+ )
+{
+ EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS Address;
+ EFI_ACPI_SDT_PROTOCOL *AcpiTableProtocol;
+ EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
+ EFI_HANDLE *HandleBuffer;
+ UINTN HandleCount;
+ EFI_ACPI_HANDLE TableHandle;
+ EFI_ACPI_HANDLE ChildHandle;
+ EFI_ACPI_DATA_TYPE DataType;
+ UINTN DataSize;
+ CHAR8 ObjectPath[8];
+ EFI_STATUS Status;
+ UINT32 AerFwFirstConfigValue;
+ UINT32 RegData;
+ UINT16 Device;
+ UINT32 Index;
+ UINT8 *Data;
+
+ //
+ // Check if PCIe AER Firmware First should be enabled
+ //
+ Status = NVParamGet (
+ NV_SI_RAS_PCIE_AER_FW_FIRST,
+ NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
+ &AerFwFirstConfigValue
+ );
+ if (EFI_ERROR (Status)) {
+ Status = NVParamGet (
+ NV_SI_RO_BOARD_PCIE_AER_FW_FIRST,
+ NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
+ &AerFwFirstConfigValue
+ );
+ if (EFI_ERROR (Status)) {
+ AerFwFirstConfigValue = 0;
+ }
+ }
+
+ if (AerFwFirstConfigValue == 0) {
+ //
+ // By default, the PCIe AER FW-First (ACPI Object "AERF") is set to 0
+ // in the DSDT table.
+ //
+ return EFI_SUCCESS;
+ }
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiSdtProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Unable to locate ACPI table protocol\n"));
+ return Status;
+ }
+
+ Status = AcpiOpenDSDT (AcpiTableProtocol, &TableHandle);
+ if (EFI_ERROR (Status)) {
+ AcpiTableProtocol->Close (TableHandle);
+ return Status;
+ }
+
+ //
+ // Update Name Object "AERF" (PCIe AER Firmware-First) if it is enabled.
+ //
+ AsciiSPrint (ObjectPath, sizeof (ObjectPath), "\\AERF");
+ Status = AcpiTableProtocol->FindPath (TableHandle, ObjectPath, &ChildHandle);
+ ASSERT_EFI_ERROR (Status);
+ if (!EFI_ERROR (Status)) {
+ Status = AcpiTableProtocol->GetOption (
+ ChildHandle,
+ 0,
+ &DataType,
+ (VOID *)&Data,
+ &DataSize
+ );
+ ASSERT_EFI_ERROR (Status);
+ if (!EFI_ERROR (Status)
+ && Data[0] == AML_NAME_OP
+ && (Data[5] == AML_ZERO_OP || Data[5] == AML_ONE_OP))
+ {
+ Data[5] = 1; // Enable PCIe AER Firmware-First
+ }
+ }
+
+ AcpiTableProtocol->Close (TableHandle);
+ AcpiDSDTUpdateChecksum (AcpiTableProtocol);
+
+ //
+ // For PCIe AER Firmware First, PCIe capability registers need
+ // to be updated to allow Firmware to detect AER errors.
+ //
+
+ HandleCount = 0;
+ HandleBuffer = NULL;
+ PciRootBridgeIo = NULL;
+
+ Status = gBS->LocateHandleBuffer (
+ ByProtocol,
+ &gEfiPciRootBridgeIoProtocolGuid,
+ NULL,
+ &HandleCount,
+ &HandleBuffer
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ //
+ // Loop through each root complex
+ //
+ for (Index = 0; Index < HandleCount; Index++) {
+ Status = gBS->HandleProtocol (
+ HandleBuffer[Index],
+ &gEfiPciRootBridgeIoProtocolGuid,
+ (VOID **)&PciRootBridgeIo
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ //
+ // Loop through each root port
+ //
+ for (Device = 1; Device <= PCIE_MAX_DEVICE_PER_ROOT_PORT; Device++) {
+ Address.Bus = 0;
+ Address.Device = Device;
+ Address.Function = 0;
+ Address.Register = 0;
+
+ Address.ExtendedRegister = PCIE_DEVICE_CONTROL_OFFSET;
+ PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
+
+ if (RegData == 0xFFFFFFFF) {
+ continue;
+ }
+
+ RegData |= PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN
+ | PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN
+ | PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN
+ | PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN;
+
+ PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
+
+ RegData = 0;
+ Address.ExtendedRegister = PCIE_ROOT_ERR_CMD_OFFSET;
+ PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
+
+ RegData |= PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN
+ | PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN
+ | PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN;
+
+ PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
+ }
+ }
+
+ return Status;
+}
+
+EFI_STATUS
+AcpiPatchDsdtTable (
+ VOID
+ )
+{
+ AcpiPatchCmn600 ();
+ AcpiPatchDmc620 ();
+ AcpiPatchDsu ();
+ AcpiPatchHwmon ();
+ AcpiPatchNvdimm ();
+ AcpiPatchPcieNuma ();
+ AcpiPatchPcieAerFwFirst ();
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
new file mode 100644
index 000000000000..1d1643abd299
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
@@ -0,0 +1,351 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "AcpiPlatform.h"
+
+EFI_ACPI_6_3_GIC_ITS_STRUCTURE GicItsTemplate = {
+ EFI_ACPI_6_3_GIC_ITS,
+ sizeof (EFI_ACPI_6_3_GIC_ITS_STRUCTURE),
+ EFI_ACPI_RESERVED_WORD,
+ 0, /* GicItsId */
+ 0, /* PhysicalBaseAddress */
+ 0, /* Reserved2 */
+};
+
+EFI_ACPI_6_3_GICR_STRUCTURE GicRTemplate = {
+ EFI_ACPI_6_3_GICR,
+ sizeof (EFI_ACPI_6_3_GICR_STRUCTURE),
+ EFI_ACPI_RESERVED_WORD,
+ GICR_MASTER_BASE_REG, /* DiscoveryRangeBaseAddress */
+ 0x1000000, /* DiscoveryRangeLength */
+};
+
+EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE GicDTemplate = {
+ EFI_ACPI_6_3_GICD,
+ sizeof (EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE),
+ EFI_ACPI_RESERVED_WORD,
+ 0, /* GicDistHwId */
+ GICD_BASE_REG, /* GicDistBase */
+ 0, /* GicDistVector */
+ 0x3, /* GicVersion */
+ {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}
+};
+
+EFI_ACPI_6_3_GIC_STRUCTURE GiccTemplate = {
+ EFI_ACPI_6_3_GIC,
+ sizeof (EFI_ACPI_6_3_GIC_STRUCTURE),
+ EFI_ACPI_RESERVED_WORD,
+ 0, /* GicId */
+ 0, /* AcpiCpuUid */
+ 0, /* Flags */
+ 0,
+ 23, /* PmuIrq */
+ 0,
+ 0,
+ 0,
+ 0,
+ 25, /* GsivId */
+ 0, /* GicRBase */
+ 0, /* Mpidr */
+ 0, /* ProcessorPowerEfficiencyClass */
+ 0, /* Reserved2 */
+ 21, /* SPE irq */
+};
+
+EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER MADTTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE,
+ 0, /* need fill in */
+ EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION
+ ),
+};
+
+UINT32 Ac01CoreOrderMonolithic[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
+ 36, 52, 40, 56, 32, 48, 44, 60,
+ 20, 68, 24, 72, 16, 64, 28, 76,
+ 4, 8, 0, 12, 38, 54, 42, 58,
+ 34, 50, 46, 62, 22, 70, 26, 74,
+ 18, 66, 30, 78, 6, 10, 2, 14,
+ 37, 53, 41, 57, 33, 49, 45, 61,
+ 21, 69, 25, 73, 17, 65, 29, 77,
+ 5, 9, 1, 13, 39, 55, 43, 59,
+ 35, 51, 47, 63, 23, 71, 27, 75,
+ 19, 67, 31, 79, 7, 11, 3, 15,
+};
+
+UINT32 Ac01CoreOrderHemisphere[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
+ 32, 48, 16, 64, 36, 52, 0, 20,
+ 68, 4, 34, 50, 18, 66, 38, 54,
+ 2, 22, 70, 6, 33, 49, 17, 65,
+ 37, 53, 1, 21, 69, 5, 35, 51,
+ 19, 67, 39, 55, 3, 23, 71, 7,
+ 44, 60, 28, 76, 40, 56, 12, 24,
+ 72, 8, 46, 62, 30, 78, 42, 58,
+ 14, 26, 74, 10, 45, 61, 29, 77,
+ 41, 57, 13, 25, 73, 9, 47, 63,
+ 31, 79, 43, 59, 15, 27, 75, 11,
+};
+
+UINT32 Ac01CoreOrderQuadrant[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
+ 16, 32, 0, 20, 4, 18, 34, 2,
+ 22, 6, 17, 33, 1, 21, 5, 19,
+ 35, 3, 23, 7, 48, 64, 52, 68,
+ 36, 50, 66, 54, 70, 38, 49, 65,
+ 53, 69, 37, 51, 67, 55, 71, 39,
+ 28, 44, 12, 24, 8, 30, 46, 14,
+ 26, 10, 29, 45, 13, 25, 9, 31,
+ 47, 15, 27, 11, 60, 76, 56, 72,
+ 40, 62, 78, 58, 74, 42, 61, 77,
+ 57, 73, 41, 63, 79, 59, 75, 43,
+};
+
+EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *MadtTablePointer;
+
+UINT32 *
+CpuGetCoreOrder (
+ VOID
+ )
+{
+ UINT8 SubNumaMode;
+
+ SubNumaMode = CpuGetSubNumaMode ();
+ switch (SubNumaMode) {
+ case SUBNUMA_MODE_MONOLITHIC:
+ return (UINT32 *)&Ac01CoreOrderMonolithic;
+
+ case SUBNUMA_MODE_HEMISPHERE:
+ return (UINT32 *)&Ac01CoreOrderHemisphere;
+
+ case SUBNUMA_MODE_QUADRANT:
+ return (UINT32 *)&Ac01CoreOrderQuadrant;
+
+ default:
+ // Should never reach here
+ ASSERT (FALSE);
+ return NULL;
+ }
+
+ return NULL;
+}
+
+UINT32
+AcpiInstallMadtProcessorNode (
+ VOID *EntryPointer,
+ UINT32 CpuId
+ )
+{
+ EFI_ACPI_6_3_GIC_STRUCTURE *MadtProcessorEntryPointer = EntryPointer;
+ UINT32 SocketId;
+ UINT32 ClusterId;
+ UINTN Size;
+
+ Size = sizeof (GiccTemplate);
+ CopyMem (MadtProcessorEntryPointer, &GiccTemplate, Size);
+
+ SocketId = SOCKET_ID (CpuId);
+ ClusterId = CLUSTER_ID (CpuId);
+
+ //
+ // GICv2 compatibility mode is not supported.
+ // Hence, set GIC's CPU Interface Number to 0.
+ //
+ MadtProcessorEntryPointer->CPUInterfaceNumber = 0;
+ MadtProcessorEntryPointer->AcpiProcessorUid =
+ (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
+ (ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM);
+ MadtProcessorEntryPointer->Flags = 1;
+ MadtProcessorEntryPointer->MPIDR =
+ (((ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM)) << 8);
+ MadtProcessorEntryPointer->MPIDR += (((UINT64)SocketId) << 32);
+
+ return Size;
+}
+
+UINT32
+AcpiInstallMadtGicD (
+ VOID *EntryPointer
+ )
+{
+ EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE *GicDEntryPointer = EntryPointer;
+ UINTN Size;
+
+ Size = sizeof (GicDTemplate);
+ CopyMem (GicDEntryPointer, &GicDTemplate, Size);
+
+ return Size;
+}
+
+UINT32
+AcpiInstallMadtGicR (
+ VOID *EntryPointer,
+ UINT32 SocketId
+ )
+{
+ EFI_ACPI_6_3_GICR_STRUCTURE *GicREntryPointer = EntryPointer;
+ UINTN Size;
+
+ /*
+ * If the Slave socket is not present, discard the Slave socket
+ * GIC redistributor region
+ */
+ if (SocketId == 1 && !IsSlaveSocketActive ()) {
+ return 0;
+ }
+
+ Size = sizeof (GicRTemplate);
+ CopyMem (GicREntryPointer, &GicRTemplate, Size);
+
+ if (SocketId == 1) {
+ GicREntryPointer->DiscoveryRangeBaseAddress = GICR_SLAVE_BASE_REG;
+ }
+
+ return Size;
+}
+
+UINT32
+AcpiInstallMadtGicIts (
+ VOID *EntryPointer,
+ UINT32 Index
+ )
+{
+ EFI_ACPI_6_3_GIC_ITS_STRUCTURE *GicItsEntryPointer = EntryPointer;
+ UINTN Size, Offset;
+ UINT64 GicBase = GICD_BASE_REG;
+ UINT32 ItsId = Index;
+
+ if (Index > SOCKET0_LAST_RC) { /* Socket 1, Index: 8-15 */
+ GicBase = GICD_SLAVE_BASE_REG;
+ Index -= (SOCKET0_LAST_RC + 1); /* Socket 1, Index:8 -> RCA0 */
+ }
+ Size = sizeof (GicItsTemplate);
+ CopyMem (GicItsEntryPointer, &GicItsTemplate, Size);
+ Offset = 0x40000 + Index * 0x20000;
+ GicItsEntryPointer->GicItsId = ItsId;
+ GicItsEntryPointer->PhysicalBaseAddress = Offset + GicBase;
+
+ return Size;
+}
+
+/*
+ * Install MADT table.
+ */
+EFI_STATUS
+AcpiInstallMadtTable (
+ VOID
+ )
+{
+ EFI_ACPI_6_3_GIC_STRUCTURE *GiccEntryPointer = NULL;
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ UINTN MadtTableKey = 0;
+ INTN Index;
+ EFI_STATUS Status;
+ UINTN Size;
+ UINT32 *CoreOrder;
+ UINT32 SktMaxCoreNum;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Size = sizeof (MADTTableHeaderTemplate) +
+ (PLATFORM_CPU_MAX_NUM_CORES * sizeof (GiccTemplate)) +
+ sizeof (GicDTemplate) +
+ (PLATFORM_CPU_MAX_SOCKET * sizeof (GicRTemplate)) +
+ ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsTemplate));
+ if (IsSlaveSocketActive ()) {
+ Size += ((SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsTemplate));
+ } else if (!IsSlaveSocketPresent ()) {
+ Size += 2 * sizeof (GicItsTemplate); /* RCA0/1 */
+ }
+
+ MadtTablePointer =
+ (EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)AllocateZeroPool (Size);
+ if (MadtTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ GiccEntryPointer =
+ (EFI_ACPI_6_3_GIC_STRUCTURE *)((UINT64)MadtTablePointer +
+ sizeof (MADTTableHeaderTemplate));
+
+ /* Install Gic interface for each processor */
+ Size = 0;
+ CoreOrder = CpuGetCoreOrder ();
+ ASSERT (CoreOrder != NULL);
+ SktMaxCoreNum = PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM;
+ for (Index = 0; Index < SktMaxCoreNum; Index++) {
+ if (IsCpuEnabled (CoreOrder[Index])) {
+ Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index]);
+ }
+ }
+
+ for (Index = 0; Index < SktMaxCoreNum; Index++) {
+ if (IsCpuEnabled (CoreOrder[Index] + SktMaxCoreNum)) {
+ Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index] + SktMaxCoreNum);
+ }
+ }
+
+ /* Install Gic Distributor */
+ Size += AcpiInstallMadtGicD ((VOID *)((UINT64)GiccEntryPointer + Size));
+
+ /* Install Gic Redistributor */
+ for (Index = 0; Index < PLATFORM_CPU_MAX_SOCKET; Index++) {
+ Size += AcpiInstallMadtGicR ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
+ }
+
+ /* Install Gic ITS */
+ if (!IsSlaveSocketPresent ()) {
+ for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
+ Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
+ }
+ }
+ for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
+ Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
+ }
+ if (IsSlaveSocketActive ()) {
+ for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
+ Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
+ }
+ }
+ CopyMem (
+ MadtTablePointer,
+ &MADTTableHeaderTemplate,
+ sizeof (MADTTableHeaderTemplate)
+ );
+
+ Size += sizeof (MADTTableHeaderTemplate);
+ MadtTablePointer->Header.Length = Size;
+ CopyMem (
+ MadtTablePointer->Header.OemId,
+ PcdGetPtr (PcdAcpiDefaultOemId),
+ sizeof (MadtTablePointer->Header.OemId)
+ );
+
+ AcpiTableChecksum (
+ (UINT8 *)MadtTablePointer,
+ MadtTablePointer->Header.Length
+ );
+
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)MadtTablePointer,
+ MadtTablePointer->Header.Length,
+ &MadtTableKey
+ );
+ FreePool ((VOID *)MadtTablePointer);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
new file mode 100644
index 000000000000..d13ac3514e11
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
@@ -0,0 +1,599 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "AcpiNfit.h"
+#include "AcpiPlatform.h"
+
+EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE NfitSPATemplate = {
+ EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE,
+ sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE),
+ 0, // The uniue index - need to be filled.
+ 0, // The flags - need to be filled.
+ 0, // Reserved.
+ 0, // Proximity domain - need to be filled.
+ EFI_ACPI_6_3_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION, // PM range type.
+ 0, // Start address - need to be filled.
+ 0, // Size - need to be filled.
+ EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB |
+ EFI_MEMORY_WP | EFI_MEMORY_UCE, // attribute - need to be filled.
+};
+
+EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE NvdimmControlRegionTemplate = {
+ EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE_TYPE,
+ sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE),
+ 0, // The unique index - need to be filled.
+ 0, // The vendor id - need to be filled.
+ 0, // The device id - need to be filled.
+ 0, // The revision - need to be filled.
+ 0, // The subsystem nvdimm id - need to be filled.
+ 0, // The subsystem nvdimm device id - need to be filled.
+ 0, // The subsystem revision - need to be filled.
+ 0, // The valid field.
+ 0, // The manufacturing location - not valid.
+ 0, // The manufacturing date - not valid.
+ {0}, // Reserved.
+ 0, // The serial number - need to be filled.
+ 0, // The region format interface code - dummy value.
+ 0, // The number of block control windows.
+ 0, // The size of block control windows.
+ 0, // The Command Register Offset in Block Control Window.
+ 0, // The Size of Command Register in Block Control Windows.
+ 0, // The Status Register Offset in Block Control Window.
+ 0, // Size of Status Register in Block Control Windows.
+ 0, // The NVDIMM Control Region Flag.
+ {0}, // Reserved.
+};
+
+EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE NvdimmRegionMappingTemplate = {
+ EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE_TYPE,
+ sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE),
+ {0}, // _ADR of the NVDIMM device - need to be filled.
+ 0, // Dimm smbios handle index - need to be filled.
+ 0, // The unique region index - need to be filled.
+ 0, // The SPA range index - need to be filled.
+ 0, // The control region index - need to be filled.
+ 0, // The region size - need to be filled.
+ 0, // The region offset - need to be filled.
+ 0, // The region base - need to be filled.
+ 0, // The interleave structure index - need to be filled.
+ 0, // The interleave ways - need to be filled.
+ 0, // NVDIMM flags - need to be filled.
+ 0, // Reserved.
+};
+
+EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE NFITTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE,
+ 0, /* need fill in */
+ EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION
+ ),
+ 0x00000000, // Reserved
+};
+
+NVDIMM_DATA NvdData[PLATFORM_CPU_MAX_SOCKET] = { 0 };
+
+EFI_STATUS
+AcpiNvdInfoInit (
+ IN OUT NVDIMM_INFO *NvdInfoPtr,
+ IN UINTN NvdId
+ )
+{
+ PLATFORM_INFO_HOB *PlatformHob;
+ VOID *Hob;
+
+ /* Get the Platform HOB */
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL || NvdInfoPtr == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ NvdInfoPtr->Enabled = TRUE;
+ NvdInfoPtr->PhysId = NvdId;
+ NvdInfoPtr->NvdSize = PlatformHob->DimmList.Dimm[NvdId].Info.DimmSize * ONE_GB;
+ NvdInfoPtr->VendorId =
+ *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[320]);
+ NvdInfoPtr->DeviceId =
+ *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[192]);
+ NvdInfoPtr->RevisionId =
+ (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[349];
+ NvdInfoPtr->SubVendorId =
+ *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[194]);
+ NvdInfoPtr->SubDeviceId =
+ *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[196]);
+ NvdInfoPtr->SubRevisionId =
+ (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[198];
+ NvdInfoPtr->SerialNumber =
+ *((UINT32 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[325]);
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+AcpiNvdDataInit (
+ IN UINTN Socket
+ )
+{
+ PLATFORM_INFO_HOB *PlatformHob;
+ NVDIMM_INFO *NvdInfo;
+ UINTN Count;
+ VOID *Hob;
+ UINTN NvdRegionNum, RegionId;
+
+ /* Get the Platform HOB */
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ NvdRegionNum = 0;
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ if (PlatformHob->DramInfo.NvdRegion[Count] != 0
+ && (PlatformHob->DramInfo.Socket[Count] == Socket))
+ {
+ NvdData[Socket].NvdRegionId[NvdRegionNum] = Count;
+ NvdRegionNum++;
+ }
+ }
+ if (NvdRegionNum == 0) {
+ return EFI_SUCCESS;
+ }
+
+ NvdData[Socket].NvdRegionNum = NvdRegionNum;
+ NvdData[Socket].NvdMode = PlatformHob->DramInfo.NvdimmMode[Socket];
+ if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
+ NvdInfo = &NvdData[Socket].NvdInfo[NVDIMM_SK0];
+ NvdInfo->DeviceHandle =
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
+ PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
+ NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
+ NvdInfo->RegionOffset = 0;
+ AcpiNvdInfoInit (
+ NvdInfo,
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
+ PLATFORM_NVDIMM_NVD3_DIMM_ID
+ );
+
+ NvdInfo = &NvdData[Socket].NvdInfo[1];
+ NvdInfo->DeviceHandle =
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
+ PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
+ NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
+ NvdInfo->RegionOffset = PLATFORM_NVDIMM_HASHED_REGION_OFFSET;
+ AcpiNvdInfoInit (
+ NvdInfo,
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
+ PLATFORM_NVDIMM_NVD4_DIMM_ID
+ );
+
+ /* Update NvdNum */
+ NvdData[Socket].NvdNum = 0;
+ for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
+ if (NvdData[Socket].NvdInfo[Count].Enabled) {
+ NvdData[Socket].NvdNum++;
+ }
+ }
+ return EFI_SUCCESS;
+ }
+ /* NVDIMM_NON_HASHED */
+ NvdData[Socket].NvdNum = 0;
+ for (Count = 0; Count < NvdData[Socket].NvdRegionNum; Count++) {
+ RegionId = NvdData[Socket].NvdRegionId[Count];
+ if (PlatformHob->DramInfo.Base[RegionId] ==
+ PLATFORM_NVDIMM_SK0_NHASHED_REGION0 ||
+ PlatformHob->DramInfo.Base[RegionId] ==
+ PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
+ {
+ NvdInfo = &NvdData[Socket].NvdInfo[0];
+ NvdInfo->DeviceHandle =
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
+ PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
+ NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
+ NvdInfo->RegionOffset = 0;
+ AcpiNvdInfoInit (
+ NvdInfo,
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
+ PLATFORM_NVDIMM_NVD3_DIMM_ID
+ );
+
+ } else if (PlatformHob->DramInfo.Base[RegionId] ==
+ PLATFORM_NVDIMM_SK0_NHASHED_REGION1 ||
+ PlatformHob->DramInfo.Base[RegionId] ==
+ PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
+ {
+ NvdInfo = &NvdData[Socket].NvdInfo[1];
+ NvdInfo->DeviceHandle =
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
+ PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
+ NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
+ NvdInfo->RegionOffset = 0;
+ AcpiNvdInfoInit (
+ NvdInfo,
+ (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
+ PLATFORM_NVDIMM_NVD4_DIMM_ID
+ );
+ }
+ }
+ /* Update NvdNum */
+ NvdData[Socket].NvdNum = 0;
+ for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
+ if (NvdData[Socket].NvdInfo[Count].Enabled) {
+ NvdData[Socket].NvdNum++;
+ }
+ }
+ return EFI_SUCCESS;
+}
+
+/*
+ * Fill in SPA structure
+ */
+VOID
+AcpiNfitFillSPA (
+ IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
+ IN UINTN NvdRegionIndex,
+ IN UINT64 NvdRegionBase,
+ IN UINT64 NvdRegionSize
+ )
+{
+ ASSERT (NfitSpaPointer != NULL);
+
+ NfitSpaPointer->Flags = 0;
+ NfitSpaPointer->SPARangeStructureIndex = NvdRegionIndex;
+ NfitSpaPointer->SystemPhysicalAddressRangeBase = NvdRegionBase;
+ NfitSpaPointer->SystemPhysicalAddressRangeLength = NvdRegionSize;
+}
+
+VOID
+NfitFillControlRegion (
+ IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
+ IN NVDIMM_INFO *NvdInfo,
+ IN UINTN NvdControlRegionIndex
+ )
+{
+ ASSERT (
+ NfitControlRegionPointer != NULL
+ && NvdInfo != NULL
+ );
+
+ NfitControlRegionPointer->NVDIMMControlRegionStructureIndex =
+ NvdControlRegionIndex;
+ NfitControlRegionPointer->VendorID = NvdInfo->VendorId;
+ NfitControlRegionPointer->DeviceID = NvdInfo->DeviceId;
+ NfitControlRegionPointer->RevisionID = NvdInfo->RevisionId;
+ NfitControlRegionPointer->SubsystemVendorID = NvdInfo->SubVendorId;
+ NfitControlRegionPointer->SubsystemDeviceID = NvdInfo->SubDeviceId;
+ NfitControlRegionPointer->SubsystemRevisionID = NvdInfo->SubRevisionId;
+ NfitControlRegionPointer->SerialNumber = NvdInfo->SerialNumber;
+}
+
+VOID
+NfitFillRegionMapping (
+ IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer,
+ IN EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
+ IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
+ IN NVDIMM_INFO *NvdInfo,
+ IN UINTN NvdRegionID
+ )
+{
+ ASSERT (
+ NfitRegionMappingPointer != NULL
+ && NfitRegionMappingPointer != NULL
+ && NfitRegionMappingPointer != NULL
+ && NfitRegionMappingPointer != NULL
+ && NvdInfo != NULL
+ );
+
+ NfitRegionMappingPointer->NVDIMMRegionID = NvdRegionID;
+ NfitRegionMappingPointer->NVDIMMPhysicalID = NvdInfo->PhysId;
+ NfitRegionMappingPointer->InterleaveWays = NvdInfo->InterleaveWays;
+ NfitRegionMappingPointer->RegionOffset = NvdInfo->RegionOffset;
+ NfitRegionMappingPointer->NVDIMMRegionSize = NvdInfo->NvdSize;
+ NfitRegionMappingPointer->NFITDeviceHandle.DIMMNumber =
+ NvdInfo->DeviceHandle & 0x0F;
+ NfitRegionMappingPointer->NFITDeviceHandle.MemoryChannelNumber =
+ (NvdInfo->DeviceHandle >> 4) & 0x0F;
+ NfitRegionMappingPointer->NFITDeviceHandle.MemoryControllerID =
+ (NvdInfo->DeviceHandle >> 8) & 0x0F;
+ NfitRegionMappingPointer->NFITDeviceHandle.SocketID =
+ (NvdInfo->DeviceHandle >> 12) & 0x0F;
+ NfitRegionMappingPointer->SPARangeStructureIndex =
+ NfitSpaPointer->SPARangeStructureIndex;
+ NfitRegionMappingPointer->NVDIMMPhysicalAddressRegionBase =
+ NfitSpaPointer->SystemPhysicalAddressRangeBase;
+ NfitRegionMappingPointer->NVDIMMControlRegionStructureIndex =
+ NfitControlRegionPointer->NVDIMMControlRegionStructureIndex;
+}
+
+EFI_STATUS
+AcpiNfitFillTableBySK (
+ IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerStart,
+ IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE **NfitSpaPointerNext,
+ IN UINTN Socket
+ )
+{
+ EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer;
+ EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer;
+ EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer;
+ PLATFORM_INFO_HOB *PlatformHob;
+ VOID *Hob;
+ UINT64 NvdRegionBase,
+ NvdRegionSize;
+ UINTN NvdCount, MaxNvdCount, RegionCount;
+ UINTN RegionId, NvdRegionIndex, NvdIndex;
+
+ /* Get the Platform HOB */
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL
+ || NfitSpaPointerStart == NULL
+ || NfitSpaPointerNext == NULL)
+ {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+ NvdRegionIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdRegionNum;
+ NvdIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdNum;
+ if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
+ /* Table Type 0: SPA Range Structure */
+ NfitSpaPointer = NfitSpaPointerStart;
+ CopyMem (
+ (VOID *)NfitSpaPointer,
+ (VOID *)&NfitSPATemplate,
+ sizeof (NfitSPATemplate)
+ );
+ RegionId = NvdData[Socket].NvdRegionId[0];
+ NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
+ NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
+ NvdRegionIndex++;
+ AcpiNfitFillSPA (
+ NfitSpaPointer,
+ NvdRegionIndex,
+ NvdRegionBase,
+ NvdRegionSize
+ );
+
+ NfitControlRegionPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
+ (NfitSpaPointer + 1);
+ for (NvdCount = 0; NvdCount < NVDIMM_NUM_PER_SK; NvdCount++) {
+ if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
+ continue;
+ }
+ NvdIndex++;
+ /* Table Type 4: NVDIMM Control Region Structure Mark */
+ CopyMem (
+ (VOID *)NfitControlRegionPointer,
+ (VOID *)&NvdimmControlRegionTemplate,
+ sizeof (NvdimmControlRegionTemplate)
+ );
+ NfitFillControlRegion (
+ NfitControlRegionPointer,
+ &NvdData[Socket].NvdInfo[NvdCount],
+ NvdIndex
+ );
+
+ NfitRegionMappingPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
+ (NfitControlRegionPointer + 1);
+
+ /* Table Type 1: NVDIMM Region Mapping Structure */
+ CopyMem (
+ (VOID *)NfitRegionMappingPointer,
+ (VOID *)&NvdimmRegionMappingTemplate,
+ sizeof (NvdimmRegionMappingTemplate)
+ );
+ NfitFillRegionMapping (
+ NfitRegionMappingPointer,
+ NfitControlRegionPointer,
+ NfitSpaPointer,
+ &NvdData[Socket].NvdInfo[NvdCount],
+ NvdIndex - 1
+ );
+
+ NfitControlRegionPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
+ (NfitRegionMappingPointer + 1);
+ }
+ NfitSpaPointer =
+ (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
+ NfitControlRegionPointer;
+ } else { /* NVDIMM_NON_HASHED */
+ NfitSpaPointer = NfitSpaPointerStart;
+ for (RegionCount = 0; RegionCount < NvdData[Socket].NvdRegionNum;
+ RegionCount++)
+ {
+ /* Table Type 0: SPA Range Structure */
+ CopyMem (
+ (VOID *)NfitSpaPointer,
+ (VOID *)&NfitSPATemplate,
+ sizeof (NfitSPATemplate)
+ );
+ RegionId = NvdData[Socket].NvdRegionId[RegionCount];
+ NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
+ NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
+ NvdRegionIndex++;
+ AcpiNfitFillSPA (
+ NfitSpaPointer,
+ NvdRegionIndex,
+ NvdRegionBase,
+ NvdRegionSize
+ );
+
+ NfitControlRegionPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
+ (NfitSpaPointer + 1);
+ NvdCount = ((NvdRegionBase == PLATFORM_NVDIMM_SK0_NHASHED_REGION0) ||
+ (NvdRegionBase == PLATFORM_NVDIMM_SK1_NHASHED_REGION0)) ?
+ 0 : PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
+ MaxNvdCount = NvdCount + PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
+ for (; NvdCount < MaxNvdCount; NvdCount++) {
+ if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
+ continue;
+ }
+ NvdIndex++;
+
+ /* Table Type 4: NVDIMM Control Region Structure Mark */
+ CopyMem (
+ (VOID *)NfitControlRegionPointer,
+ (VOID *)&NvdimmControlRegionTemplate,
+ sizeof (NvdimmControlRegionTemplate)
+ );
+ NfitFillControlRegion (
+ NfitControlRegionPointer,
+ &NvdData[Socket].NvdInfo[NvdCount],
+ NvdIndex
+ );
+
+ NfitRegionMappingPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
+ (NfitControlRegionPointer + 1);
+
+ /* Table Type 1: NVDIMM Region Mapping Structure */
+ CopyMem (
+ (VOID *)NfitRegionMappingPointer,
+ (VOID *)&NvdimmRegionMappingTemplate,
+ sizeof (NvdimmRegionMappingTemplate)
+ );
+ NfitFillRegionMapping (
+ NfitRegionMappingPointer,
+ NfitControlRegionPointer,
+ NfitSpaPointer,
+ &NvdData[Socket].NvdInfo[NvdCount],
+ NvdIndex - 1
+ );
+
+ NfitControlRegionPointer =
+ (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
+ (NfitRegionMappingPointer + 1);
+ }
+ NfitSpaPointer =
+ (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
+ NfitControlRegionPointer;
+ }
+ }
+ /* Update NfitSpaPointerNext */
+ *NfitSpaPointerNext = NfitSpaPointer;
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+AcpiNfitFillTable (
+ IN EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer
+ )
+{
+ EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerNext;
+
+ if (NfitTablePointer == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ NfitSpaPointerNext = (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
+ (NfitTablePointer + 1);
+
+ if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
+ AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK0);
+ }
+
+ if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
+ AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK1);
+ }
+
+ return EFI_SUCCESS;
+}
+
+/*
+ * Install NFIT table.
+ */
+EFI_STATUS
+AcpiInstallNfitTable (
+ VOID
+ )
+{
+ EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer;
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ UINTN NfitTableKey = 0;
+ EFI_STATUS Status;
+ UINTN Size;
+ UINTN NvdRegionNum;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+ Status = AcpiNvdDataInit (NVDIMM_SK0);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+ Status = AcpiNvdDataInit (NVDIMM_SK1);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+ NvdRegionNum = NvdData[NVDIMM_SK0].NvdRegionNum +
+ NvdData[NVDIMM_SK1].NvdRegionNum;
+ if (NvdRegionNum == 0) {
+ return EFI_INVALID_PARAMETER; /* No NVDIMM Region */
+ }
+ Size = sizeof (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE);
+ if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
+ Size +=
+ (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
+ NvdData[NVDIMM_SK0].NvdRegionNum) +
+ (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
+ NvdData[NVDIMM_SK0].NvdNum) +
+ (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
+ NvdData[NVDIMM_SK0].NvdNum);
+ }
+ if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
+ Size +=
+ (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
+ NvdData[NVDIMM_SK1].NvdRegionNum) +
+ (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
+ NvdData[NVDIMM_SK1].NvdNum) +
+ (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
+ NvdData[NVDIMM_SK1].NvdNum);
+ }
+ NfitTablePointer =
+ (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *)AllocateZeroPool (Size);
+ if (NfitTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ CopyMem (
+ (VOID *)NfitTablePointer,
+ (VOID *)&NFITTableHeaderTemplate,
+ sizeof (NFITTableHeaderTemplate)
+ );
+
+ NfitTablePointer->Header.Length = Size;
+
+ Status = AcpiNfitFillTable (NfitTablePointer);
+ if (EFI_ERROR (Status)) {
+ FreePool ((VOID *)NfitTablePointer);
+ return Status;
+ }
+ AcpiTableChecksum (
+ (UINT8 *)NfitTablePointer,
+ NfitTablePointer->Header.Length
+ );
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)NfitTablePointer,
+ NfitTablePointer->Header.Length,
+ &NfitTableKey
+ );
+ if (EFI_ERROR (Status)) {
+ FreePool ((VOID *)NfitTablePointer);
+ }
+ return Status;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
new file mode 100644
index 000000000000..296ae57aada0
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
@@ -0,0 +1,196 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/AcpiPccLib.h>
+#include "AcpiPlatform.h"
+
+EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS PcctSubspaceTemplate = {
+ EFI_ACPI_6_3_PCCT_SUBSPACE_TYPE_2_HW_REDUCED_COMMUNICATIONS,
+ sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS),
+ 0, // PlatformInterrupt
+ 0, // PlatformInterruptFlags
+ 0, // Reserved
+ 0, // BaseAddress
+ 0x100, // AddressLength
+ { 0, 0x20, 0, 0x3, 0x0 }, // DoorbellRegister
+ 0, // DoorbellPreserve
+ 0x53000040, // DoorbellWrite
+ 1, // NominalLatency
+ 1, // MaximumPeriodicAccessRate
+ 1, // MinimumRequestTurnaroundTime
+ { 0, 0x20, 0, 0x3, 0x0 }, // PlatformInterruptAckRegister
+ 0, // PlatformInterruptAckPreserve
+ 0x10001, // PlatformInterruptAckWrite
+};
+
+EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER PcctTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_PLATFORM_COMMUNICATIONS_CHANNEL_TABLE_SIGNATURE,
+ EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER,
+ EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION
+ ),
+ EFI_ACPI_6_3_PCCT_FLAGS_PLATFORM_INTERRUPT,
+};
+
+EFI_STATUS
+AcpiPcctInit (
+ VOID
+ )
+{
+ UINT8 NumberOfSockets;
+ UINT8 Socket;
+ UINT16 Doorbell;
+ UINT16 Subspace;
+
+ NumberOfSockets = GetNumberOfActiveSockets ();
+ Subspace = 0;
+
+ for (Socket = 0; Socket < NumberOfSockets; Socket++) {
+ for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
+ if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
+ continue;
+ }
+ AcpiPccInitSharedMemory (Socket, Doorbell, Subspace);
+ AcpiPccUnmaskDoorbellInterrupt (Socket, Doorbell);
+
+ Subspace++;
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+/**
+ Install PCCT table.
+
+ Each socket has 16 PCC subspaces corresponding to 16 Mailbox/Doorbell channels
+ 0 - 7 : PMpro subspaces
+ 8 - 15 : SMpro subspaces
+
+ Please note that some SMpro/PMpro Doorbell are reserved for private use.
+ The reserved Doorbells are filtered by using the ACPI_PCC_AVAILABLE_DOORBELL_MASK
+ and ACPI_PCC_NUMBER_OF_RESERVED_DOORBELLS macro.
+
+**/
+EFI_STATUS
+AcpiInstallPcctTable (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *PcctTablePointer;
+ EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *PcctEntryPointer;
+ EFI_PHYSICAL_ADDRESS PccSharedMemPointer;
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ UINTN PcctTableKey;
+ UINT8 NumberOfSockets;
+ UINT8 Socket;
+ UINT16 Doorbell;
+ UINT16 Subspace;
+ UINT16 NumberOfSubspaces;
+ UINTN Size;
+ UINTN DoorbellAddress;
+
+ Subspace = 0;
+ NumberOfSockets = GetNumberOfActiveSockets ();
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ NumberOfSubspaces = ACPI_PCC_MAX_SUBPACE_PER_SOCKET * NumberOfSockets;
+
+ AcpiPccAllocateSharedMemory (&PccSharedMemPointer, NumberOfSubspaces);
+ if (PccSharedMemPointer == 0) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
+ NumberOfSubspaces * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
+
+ PcctTablePointer = (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *)AllocateZeroPool (Size);
+ if (PcctTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ PcctEntryPointer = (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *)
+ ((UINT64)PcctTablePointer + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER));
+
+ for (Socket = 0; Socket < NumberOfSockets; Socket++) {
+ for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
+ if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
+ continue;
+ }
+
+ CopyMem (
+ &PcctEntryPointer[Subspace],
+ &PcctSubspaceTemplate,
+ sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS)
+ );
+
+ PcctEntryPointer[Subspace].BaseAddress = (UINT64)PccSharedMemPointer + ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE * Subspace;
+ PcctEntryPointer[Subspace].AddressLength = ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE;
+
+ DoorbellAddress = MailboxGetDoorbellAddress (Socket, Doorbell);
+
+ PcctEntryPointer[Subspace].DoorbellRegister.Address = DoorbellAddress + DB_OUT_REG_OFST;
+ PcctEntryPointer[Subspace].PlatformInterrupt = MailboxGetDoorbellInterruptNumber (Socket, Doorbell);
+ PcctEntryPointer[Subspace].PlatformInterruptAckRegister.Address = DoorbellAddress + DB_STATUS_REG_OFST;
+
+ if (Doorbell == ACPI_PCC_CPPC_DOORBELL_ID) {
+ PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_URGENT_CPPC_MESSAGE;
+ PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_CPPC_NOMINAL_LATENCY_US;
+ PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_CPPC_MIN_REQ_TURNAROUND_TIME_US;
+ } else {
+ PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_TYPICAL_PCC_MESSAGE;
+ PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_NOMINAL_LATENCY_US;
+ PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_MIN_REQ_TURNAROUND_TIME_US;
+ }
+ PcctEntryPointer[Subspace].MaximumPeriodicAccessRate = ACPI_PCC_MAX_PERIODIC_ACCESS_RATE;
+
+ Subspace++;
+ }
+ }
+
+ CopyMem (
+ PcctTablePointer,
+ &PcctTableHeaderTemplate,
+ sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER)
+ );
+
+ //
+ // Recalculate the size
+ //
+ Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
+ Subspace * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
+
+ PcctTablePointer->Header.Length = Size;
+ AcpiTableChecksum (
+ (UINT8 *)PcctTablePointer,
+ PcctTablePointer->Header.Length
+ );
+
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)PcctTablePointer,
+ PcctTablePointer->Header.Length,
+ &PcctTableKey
+ );
+ if (EFI_ERROR (Status)) {
+ AcpiPccFreeSharedMemory ();
+ FreePool ((VOID *)PcctTablePointer);
+ return Status;
+ }
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
new file mode 100644
index 000000000000..3ed3e98d00d2
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
@@ -0,0 +1,178 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "AcpiApei.h"
+#include "AcpiPlatform.h"
+
+STATIC EFI_EVENT mAcpiRegistration = NULL;
+
+/*
+ * This GUID must match the FILE_GUID in AcpiTables.inf of each boards
+ */
+STATIC CONST EFI_GUID mAcpiCommonTableFile = { 0xCEFA2AEB, 0x357E, 0x4F48, { 0x80, 0x66, 0xEA, 0x95, 0x08, 0x53, 0x05, 0x6E } } ;
+STATIC CONST EFI_GUID mJadeAcpiTableFile = { 0x5addbc13, 0x8634, 0x480c, { 0x9b, 0x94, 0x67, 0x1b, 0x78, 0x55, 0xcd, 0xb8 } };
+/**
+ * Callback called when ACPI Protocol is installed
+ */
+STATIC VOID
+AcpiNotificationEvent (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ EFI_STATUS Status;
+ EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp;
+
+ Status = LocateAndInstallAcpiFromFv (&mAcpiCommonTableFile);
+ ASSERT_EFI_ERROR (Status);
+
+ Status = LocateAndInstallAcpiFromFv (&mJadeAcpiTableFile);
+ ASSERT_EFI_ERROR (Status);
+
+ //
+ // Find ACPI table RSD_PTR from the system table.
+ //
+ Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **)&Rsdp);
+ if (EFI_ERROR (Status)) {
+ Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **)&Rsdp);
+ }
+
+ if (!EFI_ERROR (Status) &&
+ Rsdp != NULL &&
+ Rsdp->Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION &&
+ Rsdp->RsdtAddress != 0)
+ {
+ // ARM Platforms must set the RSDT address to NULL
+ Rsdp->RsdtAddress = 0;
+ }
+
+ DEBUG ((DEBUG_INFO, "[%a:%d]-\n", __FUNCTION__, __LINE__));
+}
+
+VOID
+EFIAPI
+InstallAcpiOnReadyToBoot (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ EFI_STATUS Status;
+
+ Status = AcpiInstallMadtTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Installed MADT table\n"));
+ }
+
+ Status = AcpiInstallPpttTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Installed PPTT table\n"));
+ }
+
+ Status = AcpiInstallSlitTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Installed SLIT table\n"));
+ }
+
+ Status = AcpiInstallSratTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Installed SRAT table\n"));
+ }
+
+ Status = AcpiInstallPcctTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Installed PCCT table\n"));
+ }
+
+ Status = AcpiInstallNfitTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Installed NFIT table\n"));
+ }
+
+ Status = AcpiPopulateBert ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "Populate BERT record\n"));
+ }
+
+ //
+ // Close the event, so it will not be signalled again.
+ //
+ gBS->CloseEvent (Event);
+}
+
+VOID
+EFIAPI
+UpdateAcpiOnExitBootServices (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ EFI_STATUS Status;
+
+ Status = AcpiPatchDsdtTable ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "DSDT Table updated!\n"));
+ }
+
+ // Configure ACPI Platform Error Interfaces
+ Status = AcpiApeiUpdate ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "APEI Table updated!\n"));
+ }
+
+ // Configure PCC mailbox base address and unmask interrupt
+ Status = AcpiPcctInit ();
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_INFO, "PCCT Table updated!\n"));
+ }
+
+ //
+ // Close the event, so it will not be signalled again.
+ //
+ gBS->CloseEvent (Event);
+}
+
+EFI_STATUS
+EFIAPI
+AcpiPlatformDxeInitialize (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ EFI_EVENT ReadyToBootEvent;
+ EFI_EVENT ExitBootServicesEvent;
+ EFI_STATUS Status;
+
+ EfiCreateProtocolNotifyEvent (
+ &gEfiAcpiTableProtocolGuid,
+ TPL_CALLBACK,
+ AcpiNotificationEvent,
+ NULL,
+ &mAcpiRegistration
+ );
+
+ Status = gBS->CreateEvent (
+ EVT_SIGNAL_EXIT_BOOT_SERVICES,
+ TPL_CALLBACK,
+ UpdateAcpiOnExitBootServices,
+ NULL,
+ &ExitBootServicesEvent
+ );
+ ASSERT_EFI_ERROR (Status);
+
+ Status = gBS->CreateEventEx (
+ EVT_NOTIFY_SIGNAL,
+ TPL_CALLBACK,
+ InstallAcpiOnReadyToBoot,
+ NULL,
+ &gEfiEventReadyToBootGuid,
+ &ReadyToBootEvent
+ );
+ ASSERT_EFI_ERROR (Status);
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
new file mode 100644
index 000000000000..97adb66beed3
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
@@ -0,0 +1,378 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "AcpiPlatform.h"
+
+EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR PPTTProcessorTemplate = {
+ EFI_ACPI_6_3_PPTT_TYPE_PROCESSOR,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR),
+ { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
+ {0}, /* Flags */
+ 0, /* Parent */
+ 0, /* AcpiProcessorId */
+ 0 /* NumberOfPrivateResources */
+};
+
+EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE PPTTCacheTemplate = {
+ EFI_ACPI_6_3_PPTT_TYPE_CACHE,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE),
+ { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
+ {0}, /* Flags */
+ 0, /* NextLevelOfCache */
+ 0, /* Size */
+ 0, /* NumberOfSets */
+ 0, /* Associativity */
+ {0}, /* Attributes */
+ 0
+};
+
+EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER PPTTTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_STRUCTURE_SIGNATURE,
+ 0, /* need fill in */
+ EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_REVISION
+ ),
+};
+
+STATIC EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *PpttTablePointer;
+STATIC UINT32 PpttClusterOffset[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET];
+STATIC UINT32 PpttSocketOffset[PLATFORM_CPU_MAX_SOCKET];
+STATIC UINT32 PpttRootOffset;
+STATIC UINT32 PpttL1DataCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
+STATIC UINT32 PpttL1InstructionCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
+STATIC UINT32 PpttL2CacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
+STATIC UINT32 PpttSLCCacheOffset[PLATFORM_CPU_MAX_SOCKET];
+
+UINT32
+AcpiPpttProcessorCoreNode (
+ VOID *EntryPointer,
+ UINT32 CpuId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
+ UINT32 *ResPointer;
+ UINTN ClusterIdPerSocket, CoreIdPerCpm, SocketId;
+
+ CopyMem (
+ PpttProcessorEntryPointer,
+ &PPTTProcessorTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
+ );
+
+ ClusterIdPerSocket = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) % PLATFORM_CPU_MAX_CPM;
+ SocketId = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) / PLATFORM_CPU_MAX_CPM;
+ CoreIdPerCpm = CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM;
+ PpttProcessorEntryPointer->Flags.AcpiProcessorIdValid = 1;
+ PpttProcessorEntryPointer->Flags.NodeIsALeaf = 1;
+ PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
+ PpttProcessorEntryPointer->AcpiProcessorId = (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) | (ClusterIdPerSocket << 8) | CoreIdPerCpm;
+ PpttProcessorEntryPointer->Parent = (UINT32)PpttClusterOffset[CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM];
+ PpttProcessorEntryPointer->NumberOfPrivateResources = 2; /* L1I + L1D */
+
+ ResPointer = (UINT32 *)((UINT64)EntryPointer +
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
+ ResPointer[0] = PpttL1InstructionCacheOffset[CpuId];
+ ResPointer[1] = PpttL1DataCacheOffset[CpuId];
+
+ PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32);
+
+ return PpttProcessorEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttClusterNode (
+ VOID *EntryPointer,
+ UINT32 ClusterId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
+
+ PpttClusterOffset[ClusterId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+
+ CopyMem (
+ PpttProcessorEntryPointer,
+ &PPTTProcessorTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
+ );
+
+ PpttProcessorEntryPointer->Parent = (UINT32)PpttSocketOffset[ClusterId / PLATFORM_CPU_MAX_CPM];
+ PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
+
+ return PpttProcessorEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttSocketNode (
+ VOID *EntryPointer,
+ UINT32 SocketId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
+ UINT32 *ResPointer;
+
+ PpttSocketOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+
+ CopyMem (
+ PpttProcessorEntryPointer,
+ &PPTTProcessorTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
+ );
+
+ PpttProcessorEntryPointer->Flags.PhysicalPackage = 1;
+ PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
+ PpttProcessorEntryPointer->Parent = (UINT32)PpttRootOffset;
+
+ PpttProcessorEntryPointer->NumberOfPrivateResources = 1;
+ ResPointer = (UINT32 *)((UINT64)EntryPointer + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
+ ResPointer[0] = PpttSLCCacheOffset[SocketId];
+
+ PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32);
+
+ return PpttProcessorEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttRootNode (
+ VOID *EntryPointer
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
+
+ PpttRootOffset = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+
+ CopyMem (
+ PpttProcessorEntryPointer,
+ &PPTTProcessorTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
+ );
+
+ PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
+
+ return PpttProcessorEntryPointer->Length;
+}
+
+STATIC VOID
+AcpiPpttFillCacheSizeInfo (
+ EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *Node,
+ UINT32 Level
+ )
+{
+ UINT64 CacheCCSIDR;
+ UINT32 CacheLineSize;
+ UINT32 Count;
+
+ CacheCCSIDR = ReadCCSIDR (Level);
+
+ CacheLineSize = 1;
+ Count = CCSIDR_LINE_SIZE (CacheCCSIDR) + 4;
+ while (Count-- > 0) {
+ CacheLineSize *= 2;
+ }
+
+ Node->Flags.LineSizeValid = 1;
+ Node->Flags.NumberOfSetsValid = 1;
+ Node->Flags.AssociativityValid = 1;
+ Node->Flags.SizePropertyValid = 1;
+ Node->Flags.CacheTypeValid = 1;
+ Node->NumberOfSets = CCSIDR_NUMSETS (CacheCCSIDR) + 1;
+ Node->Associativity = CCSIDR_ASSOCIATIVITY (CacheCCSIDR) + 1;
+ Node->LineSize = CacheLineSize;
+ Node->Size = Node->NumberOfSets *
+ Node->Associativity *
+ Node->LineSize;
+}
+
+STATIC UINT32
+AcpiPpttL1DataCacheNode (
+ VOID *EntryPointer,
+ UINT32 CpuId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
+
+ PpttL1DataCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+ CopyMem (
+ PpttCacheEntryPointer,
+ &PPTTCacheTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
+ );
+
+ AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
+ PpttCacheEntryPointer->Attributes.CacheType = 0x0; /* Data Cache */
+ PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
+
+ return PpttCacheEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttL1InstructionCacheNode (
+ VOID *EntryPointer,
+ UINT32 CpuId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
+
+ PpttL1InstructionCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+ CopyMem (
+ PpttCacheEntryPointer,
+ &PPTTCacheTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
+ );
+
+ AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
+ PpttCacheEntryPointer->Attributes.CacheType = 0x1; /* Instruction Cache */
+ PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
+
+ return PpttCacheEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttL2CacheNode (
+ VOID *EntryPointer,
+ UINT32 CpuId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
+
+ PpttL2CacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+ CopyMem (
+ PpttCacheEntryPointer,
+ &PPTTCacheTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
+ );
+
+ AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 2);
+ PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
+ PpttCacheEntryPointer->NextLevelOfCache = 0;
+
+ return PpttCacheEntryPointer->Length;
+}
+
+STATIC UINT32
+AcpiPpttSLCCacheNode (
+ VOID *EntryPointer,
+ UINT32 SocketId
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
+
+ PpttSLCCacheOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
+ CopyMem (
+ PpttCacheEntryPointer,
+ &PPTTCacheTemplate,
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
+ );
+
+ PpttCacheEntryPointer->Flags.LineSizeValid = 1;
+ PpttCacheEntryPointer->Flags.NumberOfSetsValid = 1;
+ PpttCacheEntryPointer->Flags.AssociativityValid = 1;
+ PpttCacheEntryPointer->Flags.SizePropertyValid = 1;
+ PpttCacheEntryPointer->Flags.CacheTypeValid = 1;
+
+ PpttCacheEntryPointer->Size = 0x2000000; /* 32 MB */
+ PpttCacheEntryPointer->NumberOfSets = 0x400; /* 1024 sets per 1MB HN-F */
+
+ PpttCacheEntryPointer->Associativity = 0x10; /* 16-way set-associative */
+ PpttCacheEntryPointer->LineSize = 0x40; /* 64 bytes */
+ PpttCacheEntryPointer->NextLevelOfCache = 0;
+
+ PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
+
+ return PpttCacheEntryPointer->Length;
+}
+
+/*
+ * Install PPTT table.
+ */
+EFI_STATUS
+AcpiInstallPpttTable (
+ VOID
+ )
+{
+ EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = NULL;
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ UINTN PpttTableKey = 0;
+ UINTN Count;
+ EFI_STATUS Status;
+ UINTN Size;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Size = sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER) +
+ sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + /* Root node */
+ (PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* SLC node */
+ (PLATFORM_CPU_MAX_SOCKET * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32))) + /* Socket node */
+ (PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)) + /* Cluster node */
+ (PLATFORM_CPU_MAX_NUM_CORES * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32))) + /* Core node */
+ (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1I node */
+ (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1D node */
+ (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)); /* L2 node */
+
+ PpttTablePointer =
+ (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *)AllocateZeroPool (Size);
+ if (PpttTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ PpttProcessorEntryPointer =
+ (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *)((UINT64)PpttTablePointer +
+ sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER));
+
+ Size = 0;
+ Size += AcpiPpttRootNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size));
+
+ for (Count = 0; Count < PLATFORM_CPU_MAX_SOCKET; Count++) {
+ Size += AcpiPpttSLCCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ Size += AcpiPpttSocketNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ }
+
+ for (Count = 0; Count < PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET; Count++) {
+ Size += AcpiPpttClusterNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ }
+
+ for (Count = 0; Count < PLATFORM_CPU_MAX_NUM_CORES; Count++) {
+ Size += AcpiPpttL2CacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ Size += AcpiPpttL1InstructionCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ Size += AcpiPpttL1DataCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ Size += AcpiPpttProcessorCoreNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
+ }
+
+ CopyMem (
+ PpttTablePointer,
+ &PPTTTableHeaderTemplate,
+ sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER)
+ );
+
+ Size += sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER);
+ PpttTablePointer->Header.Length = Size;
+
+ AcpiTableChecksum (
+ (UINT8 *)PpttTablePointer,
+ PpttTablePointer->Header.Length
+ );
+
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)PpttTablePointer,
+ PpttTablePointer->Header.Length,
+ &PpttTableKey
+ );
+ FreePool ((VOID *)PpttTablePointer);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ return EFI_SUCCESS;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
new file mode 100644
index 000000000000..60acdb9dd5db
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
@@ -0,0 +1,190 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "AcpiPlatform.h"
+
+#define MAX_NODES_PER_SOCKET 4
+#define SELF_DISTANCE 10
+#define REMOTE_DISTANCE 20
+
+EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER SLITTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE,
+ 0, /* need fill in */
+ EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION
+ ),
+ 0,
+};
+
+VOID
+ComputeCoordinatesForNode (
+ UINTN Node,
+ UINTN *X,
+ UINTN *Y
+ )
+{
+ switch (Node) {
+ case 0:
+ *X = 0;
+ *Y = 0;
+ break;
+ case 1:
+ *X = 1;
+ *Y = 0;
+ break;
+ case 2:
+ *X = 0;
+ *Y = 1;
+ break;
+ case 3:
+ *X = 1;
+ *Y = 1;
+ break;
+ default:
+ *X = 0;
+ *Y = 0;
+ break;
+ }
+}
+
+/**
+ Compute the distance between between two nodes on socket.
+**/
+UINT8
+ComputeSlitDistanceOnSocket (
+ UINTN Node1,
+ UINTN Node2
+ )
+{
+ UINTN X1, Y1, X2, Y2;
+ UINTN XDistance, YDistance;
+
+ ComputeCoordinatesForNode (Node1, &X1, &Y1);
+ ComputeCoordinatesForNode (Node2, &X2, &Y2);
+
+ XDistance = ABS ((INTN)(X1 - X2));
+ YDistance = ABS ((INTN)(Y1 - Y2));
+
+ return (UINT8)(XDistance + YDistance + SELF_DISTANCE);
+}
+
+/**
+ Compute the distance between between two nodes on
+ different sockets.
+ Node1 - local socket node number
+ Node2 - remote socket node number
+**/
+UINT8
+ComputeSlitDistanceOnRemoteSocket (
+ UINTN LocalNode,
+ UINTN RemoteNode
+ )
+{
+ UINTN LocalDistance, RemoteDistance;
+
+ //
+ // Mesh forwards traffic between sockets over both CCIX links when going from
+ // one quadrant to another. For example, memory access from Node 0 to Node 4
+ // results in traffic being split between RCA0 and 1. Hence distance is
+ // different only between upper half and lower half of sockets and not
+ // between quadrants. Hemisphere configuration is not impacted as there
+ // is no upper-half.
+ //
+ LocalDistance = 0;
+ RemoteDistance = 0;
+ if (LocalNode >= (MAX_NODES_PER_SOCKET / 2)) {
+ LocalDistance = 1;
+ }
+ if (RemoteNode >= (MAX_NODES_PER_SOCKET / 2)) {
+ RemoteDistance = 1;
+ }
+
+ return (UINT8)(LocalDistance + RemoteDistance + REMOTE_DISTANCE);
+}
+
+UINT8
+ComputeSlitDistance (
+ UINTN Node1,
+ UINTN Node2,
+ UINTN DomainsPerSocket
+ )
+{
+ UINT8 Distance;
+
+ Distance = 0;
+ if ((Node1 / DomainsPerSocket) == (Node2 / DomainsPerSocket)) {
+ Distance = ComputeSlitDistanceOnSocket (
+ Node1 % DomainsPerSocket,
+ Node2 % DomainsPerSocket
+ );
+ } else {
+ Distance = ComputeSlitDistanceOnRemoteSocket (
+ Node1 % DomainsPerSocket,
+ Node2 % DomainsPerSocket
+ );
+ }
+
+ return Distance;
+}
+
+EFI_STATUS
+AcpiInstallSlitTable (
+ VOID
+ )
+{
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ EFI_STATUS Status;
+ UINTN NumDomain, Count, Count1;
+ EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *SlitTablePointer;
+ UINT8 *TmpPtr;
+ UINTN SlitTableKey;
+ UINTN NumDomainPerSocket;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ NumDomainPerSocket = CpuGetNumberOfSubNumaRegion ();
+ NumDomain = NumDomainPerSocket * GetNumberOfActiveSockets ();
+
+ SlitTablePointer = (EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *)
+ AllocateZeroPool (sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain);
+ if (SlitTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ CopyMem ((VOID *)SlitTablePointer, (VOID *)&SLITTableHeaderTemplate, sizeof (SLITTableHeaderTemplate));
+ SlitTablePointer->NumberOfSystemLocalities = NumDomain;
+ TmpPtr = (UINT8 *)SlitTablePointer + sizeof (SLITTableHeaderTemplate);
+ for (Count = 0; Count < NumDomain; Count++) {
+ for (Count1 = 0; Count1 < NumDomain; Count1++, TmpPtr++) {
+ *TmpPtr = ComputeSlitDistance (Count, Count1, NumDomainPerSocket);
+ }
+ }
+
+ SlitTablePointer->Header.Length = sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain;
+
+ AcpiTableChecksum (
+ (UINT8 *)SlitTablePointer,
+ SlitTablePointer->Header.Length
+ );
+
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)SlitTablePointer,
+ SlitTablePointer->Header.Length,
+ &SlitTableKey
+ );
+ FreePool ((VOID *)SlitTablePointer);
+
+ return Status;
+}
diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
new file mode 100644
index 000000000000..5f3b7007623a
--- /dev/null
+++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
@@ -0,0 +1,274 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Guid/ArmMpCoreInfo.h>
+#include "AcpiPlatform.h"
+
+EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER SRATTableHeaderTemplate = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE,
+ 0, /* need fill in */
+ EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION
+ ),
+ 0x00000001,
+ 0x0000000000000000,
+};
+
+EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE GicItsAffinityTemplate = {
+ .Type = EFI_ACPI_6_3_GIC_ITS_AFFINITY,
+ sizeof (EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE),
+ .ProximityDomain = 0, /* ProximityDomain */
+ { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
+ .ItsId = 0,
+};
+
+STATIC
+UINTN
+SratCalculateNumMemoryRegion (
+ VOID
+ )
+{
+ PLATFORM_INFO_HOB *PlatformHob;
+ UINTN Count;
+ UINT64 TmpVal;
+ VOID *Hob;
+ UINTN Result;
+
+ /* Get the Platform HOB */
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL) {
+ return 0;
+ }
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ Result = 0;
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ TmpVal = PlatformHob->DramInfo.Size[Count];
+ if (TmpVal > 0) {
+ Result++;
+ }
+ }
+
+ return Result;
+}
+
+STATIC
+EFI_STATUS
+SratAddMemAffinity (
+ EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *SratMemAffinity
+ )
+{
+ PLATFORM_INFO_HOB *PlatformHob;
+ UINTN Count, NumRegion;
+ UINT64 RegionSize, RegionBase;
+ VOID *Hob;
+ UINTN ProximityDomain;
+
+ /* Get the Platform HOB */
+ Hob = GetFirstGuidHob (&gPlatformHobGuid);
+ if (Hob == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+ PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
+
+ NumRegion = 0;
+
+ for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
+ RegionSize = PlatformHob->DramInfo.Size[Count];
+ RegionBase = PlatformHob->DramInfo.Base[Count];
+ ProximityDomain = PlatformHob->DramInfo.Node[Count];
+ if (RegionSize > 0) {
+ ZeroMem ((VOID *)&SratMemAffinity[NumRegion], sizeof (SratMemAffinity[NumRegion]));
+ SratMemAffinity[NumRegion].Flags = EFI_ACPI_6_3_MEMORY_ENABLED;
+ if (PlatformHob->DramInfo.NvdRegion[Count] != 0) {
+ /* Mark NVDIMM-N region as HOT_PLUGGABLE and NON-VOLATILE */
+ SratMemAffinity[NumRegion].Flags |= EFI_ACPI_6_3_MEMORY_HOT_PLUGGABLE |
+ EFI_ACPI_6_3_MEMORY_NONVOLATILE;
+ }
+ SratMemAffinity[NumRegion].LengthLow =
+ (UINT32)(RegionSize & 0xFFFFFFFF);
+ SratMemAffinity[NumRegion].LengthHigh =
+ (UINT32)((RegionSize & 0xFFFFFFFF00000000ULL) >> 32);
+ SratMemAffinity[NumRegion].AddressBaseLow =
+ (UINT32)(RegionBase & 0xFFFFFFFF);
+ SratMemAffinity[NumRegion].AddressBaseHigh =
+ (UINT32)((RegionBase & 0xFFFFFFFF00000000ULL) >> 32);
+ SratMemAffinity[NumRegion].ProximityDomain = (UINT32)(ProximityDomain);
+ SratMemAffinity[NumRegion].Type = EFI_ACPI_6_3_MEMORY_AFFINITY;
+ SratMemAffinity[NumRegion].Length = sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
+ NumRegion++;
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+STATIC
+EFI_STATUS
+SratAddGiccAffinity (
+ EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *SratGiccAffinity
+ )
+{
+ ARM_PROCESSOR_TABLE *ArmProcessorTable;
+ ARM_CORE_INFO *ArmCoreInfoTable;
+ UINTN Count, NumNode, Idx;
+ UINT32 AcpiProcessorUid;
+ UINT8 Socket;
+ UINT8 Cpm;
+
+ for (Idx = 0; Idx < gST->NumberOfTableEntries; Idx++) {
+ if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Idx].VendorGuid))) {
+ ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Idx].VendorTable;
+ ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
+ break;
+ }
+ }
+
+ if (Idx == gST->NumberOfTableEntries) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ Count = 0;
+ NumNode = 0;
+ while (Count != ArmProcessorTable->NumberOfEntries) {
+ for (Idx = 0; Idx < ArmProcessorTable->NumberOfEntries; Idx++ ) {
+ Socket = ArmCoreInfoTable[Idx].ClusterId;
+ Cpm = (ArmCoreInfoTable[Idx].CoreId >> PLATFORM_CPM_UID_BIT_OFFSET);
+ if (CpuGetSubNumNode (Socket, Cpm) != NumNode) {
+ /* We add nodes based on ProximityDomain order */
+ continue;
+ }
+ AcpiProcessorUid = (ArmCoreInfoTable[Idx].ClusterId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
+ ArmCoreInfoTable[Idx].CoreId;
+ ZeroMem ((VOID *)&SratGiccAffinity[Count], sizeof (SratGiccAffinity[Count]));
+ SratGiccAffinity[Count].AcpiProcessorUid = AcpiProcessorUid;
+ SratGiccAffinity[Count].Flags = 1;
+ SratGiccAffinity[Count].Length = sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
+ SratGiccAffinity[Count].Type = EFI_ACPI_6_3_GICC_AFFINITY;
+ SratGiccAffinity[Count].ProximityDomain = CpuGetSubNumNode (Socket, Cpm);
+ Count++;
+ }
+ NumNode++;
+ }
+
+ return EFI_SUCCESS;
+}
+
+STATIC UINT32
+InstallGicItsAffinity (
+ VOID *EntryPointer,
+ UINT32 Index
+ )
+{
+ EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE *ItsAffinityEntryPointer = EntryPointer;
+ UINTN Size;
+
+ Size = sizeof (GicItsAffinityTemplate);
+ CopyMem (ItsAffinityEntryPointer, &GicItsAffinityTemplate, Size);
+ return Size;
+}
+
+STATIC
+EFI_STATUS
+SratAddGicItsAffinity (
+ VOID *TmpPtr
+ )
+{
+ UINTN Size = 0;
+ UINTN Index;
+
+ /* Install Gic ITSAffinity */
+ if (!IsSlaveSocketPresent ()) {
+ for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
+ GicItsAffinityTemplate.ItsId = Index;
+ GicItsAffinityTemplate.ProximityDomain = 0;
+ Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
+ }
+ }
+
+ for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
+ GicItsAffinityTemplate.ItsId = Index;
+ GicItsAffinityTemplate.ProximityDomain = 0;
+ Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
+ }
+
+ if (IsSlaveSocketActive ()) {
+ for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
+ GicItsAffinityTemplate.ItsId = Index;
+ GicItsAffinityTemplate.ProximityDomain = 1;
+ Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+AcpiInstallSratTable (
+ VOID
+ )
+{
+ EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
+ EFI_STATUS Status;
+ EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *SratTablePointer;
+ UINT8 *TmpPtr;
+ UINTN SratTableKey;
+ UINTN Size;
+
+ Status = gBS->LocateProtocol (
+ &gEfiAcpiTableProtocolGuid,
+ NULL,
+ (VOID **)&AcpiTableProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Size = sizeof (SRATTableHeaderTemplate) +
+ SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE) +
+ GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE) +
+ ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate));
+ if (IsSlaveSocketActive ()) {
+ Size += (SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate);
+ } else if (!IsSlaveSocketPresent ()) {
+ Size += 2 * sizeof (GicItsAffinityTemplate); /* RCA0/1 */
+ }
+
+ SratTablePointer = (EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *)AllocateZeroPool (Size);
+ if (SratTablePointer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ CopyMem ((VOID *)SratTablePointer, (VOID *)&SRATTableHeaderTemplate, sizeof (SRATTableHeaderTemplate));
+
+ TmpPtr = (UINT8 *)SratTablePointer + sizeof (SRATTableHeaderTemplate);
+ Status = SratAddMemAffinity ((EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *)TmpPtr);
+ ASSERT_EFI_ERROR (Status);
+
+ TmpPtr += SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
+ Status = SratAddGiccAffinity ((EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *)TmpPtr);
+ ASSERT_EFI_ERROR (Status);
+
+ TmpPtr += GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
+ SratAddGicItsAffinity ((VOID *)(UINT64)TmpPtr);
+ SratTablePointer->Header.Length = Size;
+
+ AcpiTableChecksum (
+ (UINT8 *)SratTablePointer,
+ SratTablePointer->Header.Length
+ );
+
+ Status = AcpiTableProtocol->InstallAcpiTable (
+ AcpiTableProtocol,
+ (VOID *)SratTablePointer,
+ SratTablePointer->Header.Length,
+ &SratTableKey
+ );
+ FreePool ((VOID *)SratTablePointer);
+
+ return Status;
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
new file mode 100755
index 000000000000..023509412f04
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
@@ -0,0 +1,5639 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Device(C000) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x0)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x000, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x004, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x008, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x010, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x014, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x050, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x054, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x058, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 0, 0xFD, 2}
+ }) // Domain 0
+}
+
+Device(C001) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x080, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x084, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x088, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x090, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x094, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 1, 0xFD, 2}
+ }) // Domain 1
+}
+
+Device(C002) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x100, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x104, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x108, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x110, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x114, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x134, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x150, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x154, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x158, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 2, 0xFD, 2}
+ }) // Domain 2
+}
+
+Device(C003) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x180, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x184, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x188, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x190, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x194, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 3, 0xFD, 2}
+ }) // Domain 3
+}
+
+Device(C004) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x200, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x204, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x208, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x210, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x214, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x234, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x250, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x254, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x258, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 4, 0xFD, 2}
+ }) // Domain 4
+}
+
+Device(C005) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x280, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x284, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x288, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x290, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x294, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 5, 0xFD, 2}
+ }) // Domain 5
+}
+
+Device(C006) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x300, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x304, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x308, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x310, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x314, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x334, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x350, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x354, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x358, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 6, 0xFD, 2}
+ }) // Domain 6
+}
+
+Device(C007) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x380, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x384, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x388, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x390, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x394, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 7, 0xFD, 2}
+ }) // Domain 7
+}
+
+Device(C008) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x400, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x404, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x408, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x410, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x414, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x434, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x450, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x454, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x458, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 8, 0xFD, 2}
+ }) // Domain 8
+}
+
+Device(C009) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x480, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x484, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x488, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x490, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x494, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 9, 0xFD, 2}
+ }) // Domain 9
+}
+
+Device(C010) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x500, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x504, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x508, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x510, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x514, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x534, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x550, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x554, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x558, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 10, 0xFD, 2}
+ }) // Domain 10
+}
+
+Device(C011) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x580, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x584, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x588, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x590, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x594, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 11, 0xFD, 2}
+ }) // Domain 11
+}
+
+Device(C012) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x600, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x604, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x608, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x610, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x614, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x634, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x650, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x654, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x658, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 12, 0xFD, 2}
+ }) // Domain 12
+}
+
+Device(C013) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x680, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x684, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x688, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x690, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x694, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 13, 0xFD, 2}
+ }) // Domain 13
+}
+
+Device(C014) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x700, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x704, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x708, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x710, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x714, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x734, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x750, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x754, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x758, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 14, 0xFD, 2}
+ }) // Domain 14
+}
+
+Device(C015) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x780, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x784, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x788, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x790, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x794, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 15, 0xFD, 2}
+ }) // Domain 15
+}
+
+Device(C016) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x800, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x804, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x808, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x810, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x814, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x834, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x850, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x854, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x858, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 16, 0xFD, 2}
+ }) // Domain 16
+}
+
+Device(C017) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x880, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x884, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x888, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x890, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x894, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 17, 0xFD, 2}
+ }) // Domain 17
+}
+
+Device(C018) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x900, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x904, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x908, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x910, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x914, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x934, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x950, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x954, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x958, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 18, 0xFD, 2}
+ }) // Domain 18
+}
+
+Device(C019) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x980, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x984, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x988, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x990, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x994, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 19, 0xFD, 2}
+ }) // Domain 19
+}
+
+Device(C020) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xa00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 20, 0xFD, 2}
+ }) // Domain 20
+}
+
+Device(C021) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xa01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 21, 0xFD, 2}
+ }) // Domain 21
+}
+
+Device(C022) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xb00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 22, 0xFD, 2}
+ }) // Domain 22
+}
+
+Device(C023) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xb01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 23, 0xFD, 2}
+ }) // Domain 23
+}
+
+Device(C024) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xc00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 24, 0xFD, 2}
+ }) // Domain 24
+}
+
+Device(C025) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xc01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 25, 0xFD, 2}
+ }) // Domain 25
+}
+
+Device(C026) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xd00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 26, 0xFD, 2}
+ }) // Domain 26
+}
+
+Device(C027) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xd01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 27, 0xFD, 2}
+ }) // Domain 27
+}
+
+Device(C028) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xe00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 28, 0xFD, 2}
+ }) // Domain 28
+}
+
+Device(C029) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xe01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 29, 0xFD, 2}
+ }) // Domain 29
+}
+
+Device(C030) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xf00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 30, 0xFD, 2}
+ }) // Domain 30
+}
+
+Device(C031) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0xf01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 31, 0xFD, 2}
+ }) // Domain 31
+}
+
+Device(C032) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 32, 0xFD, 2}
+ }) // Domain 32
+}
+
+Device(C033) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 33, 0xFD, 2}
+ }) // Domain 33
+}
+
+Device(C034) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 34, 0xFD, 2}
+ }) // Domain 34
+}
+
+Device(C035) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 35, 0xFD, 2}
+ }) // Domain 35
+}
+
+Device(C036) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 36, 0xFD, 2}
+ }) // Domain 36
+}
+
+Device(C037) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 37, 0xFD, 2}
+ }) // Domain 37
+}
+
+Device(C038) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 38, 0xFD, 2}
+ }) // Domain 38
+}
+
+Device(C039) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 39, 0xFD, 2}
+ }) // Domain 39
+}
+
+Device(C040) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 40, 0xFD, 2}
+ }) // Domain 40
+}
+
+Device(C041) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 41, 0xFD, 2}
+ }) // Domain 41
+}
+
+Device(C042) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 42, 0xFD, 2}
+ }) // Domain 42
+}
+
+Device(C043) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 43, 0xFD, 2}
+ }) // Domain 43
+}
+
+Device(C044) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 44, 0xFD, 2}
+ }) // Domain 44
+}
+
+Device(C045) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 45, 0xFD, 2}
+ }) // Domain 45
+}
+
+Device(C046) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 46, 0xFD, 2}
+ }) // Domain 46
+}
+
+Device(C047) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 47, 0xFD, 2}
+ }) // Domain 47
+}
+
+Device(C048) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 48, 0xFD, 2}
+ }) // Domain 48
+}
+
+Device(C049) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 49, 0xFD, 2}
+ }) // Domain 49
+}
+
+Device(C050) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 50, 0xFD, 2}
+ }) // Domain 50
+}
+
+Device(C051) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 51, 0xFD, 2}
+ }) // Domain 51
+}
+
+Device(C052) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 52, 0xFD, 2}
+ }) // Domain 52
+}
+
+Device(C053) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 53, 0xFD, 2}
+ }) // Domain 53
+}
+
+Device(C054) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 54, 0xFD, 2}
+ }) // Domain 54
+}
+
+Device(C055) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 55, 0xFD, 2}
+ }) // Domain 5
+}
+
+Device(C056) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 56, 0xFD, 2}
+ }) // Domain 56
+}
+
+Device(C057) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 57, 0xFD, 2}
+ }) // Domain 57
+}
+
+Device(C058) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 58, 0xFD, 2}
+ }) // Domain 58
+}
+
+Device(C059) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 59, 0xFD, 2}
+ }) // Domain 59
+}
+
+Device(C060) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 60, 0xFD, 2}
+ }) // Domain 60
+}
+
+Device(C061) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 61, 0xFD, 2}
+ }) // Domain 61
+}
+
+Device(C062) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 62, 0xFD, 2}
+ }) // Domain 62
+}
+
+Device(C063) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x1f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 63, 0xFD, 2}
+ }) // Domain 63
+}
+
+Device(C064) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 64, 0xFD, 2}
+ }) // Domain 64
+}
+
+Device(C065) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 65, 0xFD, 2}
+ }) // Domain 65
+}
+
+Device(C066) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 66, 0xFD, 2}
+ }) // Domain 66
+}
+
+Device(C067) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 67, 0xFD, 2}
+ }) // Domain 67
+}
+
+Device(C068) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 68, 0xFD, 2}
+ }) // Domain 68
+}
+
+Device(C069) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 69, 0xFD, 2}
+ }) // Domain 69
+}
+
+Device(C070) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 70, 0xFD, 2}
+ }) // Domain 70
+}
+
+Device(C071) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 71, 0xFD, 2}
+ }) // Domain 71
+}
+
+Device(C072) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 72, 0xFD, 2}
+ }) // Domain 72
+}
+
+Device(C073) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 73, 0xFD, 2}
+ }) // Domain 73
+}
+
+Device(C074) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 74, 0xFD, 2}
+ }) // Domain 74
+}
+
+Device(C075) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 75, 0xFD, 2}
+ }) // Domain 75
+}
+
+Device(C076) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 76, 0xFD, 2}
+ }) // Domain 76
+}
+
+Device(C077) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 77, 0xFD, 2}
+ }) // Domain 77
+}
+
+Device(C078) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 78, 0xFD, 2}
+ }) // Domain 78
+}
+
+Device(C079) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 79, 0xFD, 2}
+ }) // Domain 79
+}
+
+Device(C080) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 80, 0xFD, 2}
+ }) // Domain 80
+}
+
+Device(C081) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 81, 0xFD, 2}
+ }) // Domain 81
+}
+
+Device(C082) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 82, 0xFD, 2}
+ }) // Domain 82
+}
+
+Device(C083) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 83, 0xFD, 2}
+ }) // Domain 83
+}
+
+Device(C084) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 84, 0xFD, 2}
+ }) // Domain 84
+}
+
+Device(C085) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 85, 0xFD, 2}
+ }) // Domain 85
+}
+
+Device(C086) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 86, 0xFD, 2}
+ }) // Domain 86
+}
+
+Device(C087) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 87, 0xFD, 2}
+ }) // Domain 87
+}
+
+Device(C088) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 88, 0xFD, 2}
+ }) // Domain 88
+}
+
+Device(C089) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 89, 0xFD, 2}
+ }) // Domain 89
+}
+
+Device(C090) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 90, 0xFD, 2}
+ }) // Domain 90
+}
+
+Device(C091) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 91, 0xFD, 2}
+ }) // Domain 91
+}
+
+Device(C092) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 92, 0xFD, 2}
+ }) // Domain 92
+}
+
+Device(C093) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 93, 0xFD, 2}
+ }) // Domain 93
+}
+
+Device(C094) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 94, 0xFD, 2}
+ }) // Domain 94
+}
+
+Device(C095) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x2f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 95, 0xFD, 2}
+ }) // Domain 95
+}
+
+Device(C096) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 96, 0xFD, 2}
+ }) // Domain 96
+}
+
+Device(C097) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 97, 0xFD, 2}
+ }) // Domain 97
+}
+
+Device(C098) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 98, 0xFD, 2}
+ }) // Domain 98
+}
+
+Device(C099) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 99, 0xFD, 2}
+ }) // Domain 99
+}
+
+Device(C100) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 100, 0xFD, 2}
+ }) // Domain 100
+}
+
+Device(C101) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 101, 0xFD, 2}
+ }) // Domain 101
+}
+
+Device(C102) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 102, 0xFD, 2}
+ }) // Domain 102
+}
+
+Device(C103) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 103, 0xFD, 2}
+ }) // Domain 103
+}
+
+Device(C104) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 104, 0xFD, 2}
+ }) // Domain 104
+}
+
+Device(C105) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 105, 0xFD, 2}
+ }) // Domain 105
+}
+
+Device(C106) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 106, 0xFD, 2}
+ }) // Domain 106
+}
+
+Device(C107) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 107, 0xFD, 2}
+ }) // Domain 107
+}
+
+Device(C108) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 108, 0xFD, 2}
+ }) // Domain 108
+}
+
+Device(C109) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 109, 0xFD, 2}
+ }) // Domain 109
+}
+
+Device(C110) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 110, 0xFD, 2}
+ }) // Domain 110
+}
+
+Device(C111) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 111, 0xFD, 2}
+ }) // Domain 111
+}
+
+Device(C112) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 112, 0xFD, 2}
+ }) // Domain 112
+}
+
+Device(C113) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 113, 0xFD, 2}
+ }) // Domain 113
+}
+
+Device(C114) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 114, 0xFD, 2}
+ }) // Domain 114
+}
+
+Device(C115) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 115, 0xFD, 2}
+ }) // Domain 115
+}
+
+Device(C116) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 116, 0xFD, 2}
+ }) // Domain 116
+}
+
+Device(C117) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 117, 0xFD, 2}
+ }) // Domain 117
+}
+
+Device(C118) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 118, 0xFD, 2}
+ }) // Domain 118
+}
+
+Device(C119) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 119, 0xFD, 2}
+ }) // Domain 119
+}
+
+Device(C120) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 120, 0xFD, 2}
+ }) // Domain 120
+}
+
+Device(C121) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 121, 0xFD, 2}
+ }) // Domain 121
+}
+
+Device(C122) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 122, 0xFD, 2}
+ }) // Domain 122
+}
+
+Device(C123) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 123, 0xFD, 2}
+ }) // Domain 123
+}
+
+Device(C124) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 124, 0xFD, 2}
+ }) // Domain 124
+}
+
+Device(C125) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 125, 0xFD, 2}
+ }) // Domain 125
+}
+
+Device(C126) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 126, 0xFD, 2}
+ }) // Domain 126
+}
+
+Device(C127) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x3f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 127, 0xFD, 2}
+ }) // Domain 127
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
new file mode 100755
index 000000000000..b3cc7a1b00e4
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
@@ -0,0 +1,5639 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Device(C128) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x000, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x004, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x008, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x010, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x014, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x050, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x054, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x058, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 128, 0xFD, 2}
+ }) // Domain 128
+}
+
+Device(C129) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x080, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x084, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x088, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x090, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x094, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 1219, 0xFD, 2}
+ }) // Domain 129
+}
+
+Device(C130) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x100, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x104, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x108, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x110, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x114, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x134, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x150, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x154, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x158, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 130, 0xFD, 2}
+ }) // Domain 130
+}
+
+Device(C131) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x180, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x184, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x188, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x190, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x194, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 131, 0xFD, 2}
+ }) // Domain 131
+}
+
+Device(C132) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x200, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x204, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x208, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x210, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x214, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x234, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x250, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x254, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x258, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 132, 0xFD, 2}
+ }) // Domain 132
+}
+
+Device(C133) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x280, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x284, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x288, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x290, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x294, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 133, 0xFD, 2}
+ }) // Domain 133
+}
+
+Device(C134) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x300, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x304, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x308, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x310, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x314, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x334, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x350, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x354, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x358, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 134, 0xFD, 2}
+ }) // Domain 134
+}
+
+Device(C135) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x380, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x384, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x388, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x390, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x394, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 135, 0xFD, 2}
+ }) // Domain 135
+}
+
+Device(C136) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x400, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x404, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x408, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x410, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x414, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x434, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x450, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x454, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x458, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 136, 0xFD, 2}
+ }) // Domain 136
+}
+
+Device(C137) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x480, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x484, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x488, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x490, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x494, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 137, 0xFD, 2}
+ }) // Domain 137
+}
+
+Device(C138) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x500, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x504, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x508, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x510, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x514, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x534, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x550, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x554, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x558, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 138, 0xFD, 2}
+ }) // Domain 138
+}
+
+Device(C139) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x580, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x584, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x588, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x590, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x594, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 139, 0xFD, 2}
+ }) // Domain 139
+}
+
+Device(C140) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x600, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x604, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x608, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x610, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x614, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x634, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x650, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x654, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x658, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 140, 0xFD, 2}
+ }) // Domain 140
+}
+
+Device(C141) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x680, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x684, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x688, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x690, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x694, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 141, 0xFD, 2}
+ }) // Domain 141
+}
+
+Device(C142) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x700, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x704, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x708, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x710, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x714, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x734, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x750, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x754, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x758, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 142, 0xFD, 2}
+ }) // Domain 142
+}
+
+Device(C143) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x780, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x784, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x788, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x790, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x794, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 143, 0xFD, 2}
+ }) // Domain 143
+}
+
+Device(C144) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x800, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x804, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x808, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x810, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x814, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x834, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x850, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x854, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x858, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 144, 0xFD, 2}
+ }) // Domain 144
+}
+
+Device(C145) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x880, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x884, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x888, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x890, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x894, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 145, 0xFD, 2}
+ }) // Domain 145
+}
+
+Device(C146) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x900, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x904, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x908, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x910, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x914, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x934, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x950, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x954, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x958, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 146, 0xFD, 2}
+ }) // Domain 146
+}
+
+Device(C147) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x980, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x984, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x988, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x990, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x994, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 147, 0xFD, 2}
+ }) // Domain 147
+}
+
+Device(C148) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 148, 0xFD, 2}
+ }) // Domain 148
+}
+
+Device(C149) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 149, 0xFD, 2}
+ }) // Domain 149
+}
+
+Device(C150) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 150, 0xFD, 2}
+ }) // Domain 150
+}
+
+Device(C151) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 151, 0xFD, 2}
+ }) // Domain 151
+}
+
+Device(C152) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 152, 0xFD, 2}
+ }) // Domain 152
+}
+
+Device(C153) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 153, 0xFD, 2}
+ }) // Domain 153
+}
+
+Device(C154) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 154, 0xFD, 2}
+ }) // Domain 154
+}
+
+Device(C155) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 155, 0xFD, 2}
+ }) // Domain 155
+}
+
+Device(C156) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 156, 0xFD, 2}
+ }) // Domain 156
+}
+
+Device(C157) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 157, 0xFD, 2}
+ }) // Domain 157
+}
+
+Device(C158) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 158, 0xFD, 2}
+ }) // Domain 158
+}
+
+Device(C159) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x10f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 159, 0xFD, 2}
+ }) // Domain 159
+}
+
+Device(C160) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 160, 0xFD, 2}
+ }) // Domain 160
+}
+
+Device(C161) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 161, 0xFD, 2}
+ }) // Domain 161
+}
+
+Device(C162) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 162, 0xFD, 2}
+ }) // Domain 162
+}
+
+Device(C163) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 163, 0xFD, 2}
+ }) // Domain 163
+}
+
+Device(C164) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 164, 0xFD, 2}
+ }) // Domain 164
+}
+
+Device(C165) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 165, 0xFD, 2}
+ }) // Domain 165
+}
+
+Device(C166) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 166, 0xFD, 2}
+ }) // Domain 166
+}
+
+Device(C167) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 167, 0xFD, 2}
+ }) // Domain 167
+}
+
+Device(C168) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 168, 0xFD, 2}
+ }) // Domain 168
+}
+
+Device(C169) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 169, 0xFD, 2}
+ }) // Domain 169
+}
+
+Device(C170) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 170, 0xFD, 2}
+ }) // Domain 170
+}
+
+Device(C171) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 171, 0xFD, 2}
+ }) // Domain 171
+}
+
+Device(C172) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 172, 0xFD, 2}
+ }) // Domain 172
+}
+
+Device(C173) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 173, 0xFD, 2}
+ }) // Domain 173
+}
+
+Device(C174) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 174, 0xFD, 2}
+ }) // Domain 174
+}
+
+Device(C175) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 175, 0xFD, 2}
+ }) // Domain 175
+}
+
+Device(C176) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 176, 0xFD, 2}
+ }) // Domain 176
+}
+
+Device(C177) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 177, 0xFD, 2}
+ }) // Domain 177
+}
+
+Device(C178) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 178, 0xFD, 2}
+ }) // Domain 178
+}
+
+Device(C179) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 179, 0xFD, 2}
+ }) // Domain 179
+}
+
+Device(C180) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 180, 0xFD, 2}
+ }) // Domain 180
+}
+
+Device(C181) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 181, 0xFD, 2}
+ }) // Domain 181
+}
+
+Device(C182) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 182, 0xFD, 2}
+ }) // Domain 182
+}
+
+Device(C183) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 183, 0xFD, 2}
+ }) // Domain 183
+}
+
+Device(C184) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 184, 0xFD, 2}
+ }) // Domain 184
+}
+
+Device(C185) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 185, 0xFD, 2}
+ }) // Domain 185
+}
+
+Device(C186) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 186, 0xFD, 2}
+ }) // Domain 186
+}
+
+Device(C187) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 187, 0xFD, 2}
+ }) // Domain 187
+}
+
+Device(C188) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 188, 0xFD, 2}
+ }) // Domain 188
+}
+
+Device(C189) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 189, 0xFD, 2}
+ }) // Domain 189
+}
+
+Device(C190) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 190, 0xFD, 2}
+ }) // Domain 190
+}
+
+Device(C191) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x11f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 191, 0xFD, 2}
+ }) // Domain 191
+}
+
+Device(C192) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 192, 0xFD, 2}
+ }) // Domain 192
+}
+
+Device(C193) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 193, 0xFD, 2}
+ }) // Domain 193
+}
+
+Device(C194) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 194, 0xFD, 2}
+ }) // Domain 194
+}
+
+Device(C195) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 195, 0xFD, 2}
+ }) // Domain 195
+}
+
+Device(C196) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 196, 0xFD, 2}
+ }) // Domain 196
+}
+
+Device(C197) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 197, 0xFD, 2}
+ }) // Domain 197
+}
+
+Device(C198) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 198, 0xFD, 2}
+ }) // Domain 198
+}
+
+Device(C199) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 199, 0xFD, 2}
+ }) // Domain 199
+}
+
+Device(C200) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 200, 0xFD, 2}
+ }) // Domain 200
+}
+
+Device(C201) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 201, 0xFD, 2}
+ }) // Domain 201
+}
+
+Device(C202) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 202, 0xFD, 2}
+ }) // Domain 202
+}
+
+Device(C203) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 203, 0xFD, 2}
+ }) // Domain 203
+}
+
+Device(C204) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 204, 0xFD, 2}
+ }) // Domain 204
+}
+
+Device(C205) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 205, 0xFD, 2}
+ }) // Domain 205
+}
+
+Device(C206) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 206, 0xFD, 2}
+ }) // Domain 206
+}
+
+Device(C207) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 207, 0xFD, 2}
+ }) // Domain 207
+}
+
+Device(C208) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 208, 0xFD, 2}
+ }) // Domain 208
+}
+
+Device(C209) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 209, 0xFD, 2}
+ }) // Domain 209
+}
+
+Device(C210) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 210, 0xFD, 2}
+ }) // Domain 210
+}
+
+Device(C211) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 211, 0xFD, 2}
+ }) // Domain 211
+}
+
+Device(C212) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 212, 0xFD, 2}
+ }) // Domain 212
+}
+
+Device(C213) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 213, 0xFD, 2}
+ }) // Domain 213
+}
+
+Device(C214) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 214, 0xFD, 2}
+ }) // Domain 214
+}
+
+Device(C215) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 215, 0xFD, 2}
+ }) // Domain 215
+}
+
+Device(C216) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 216, 0xFD, 2}
+ }) // Domain 216
+}
+
+Device(C217) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 217, 0xFD, 2}
+ }) // Domain 217
+}
+
+Device(C218) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 218, 0xFD, 2}
+ }) // Domain 218
+}
+
+Device(C219) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 219, 0xFD, 2}
+ }) // Domain 219
+}
+
+Device(C220) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 220, 0xFD, 2}
+ }) // Domain 220
+}
+
+Device(C221) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 221, 0xFD, 2}
+ }) // Domain 221
+}
+
+Device(C222) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 222, 0xFD, 2}
+ }) // Domain 222
+}
+
+Device(C223) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x12f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 17)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 17)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 17)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 17)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 17)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 17)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 17)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 17)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 17)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 17)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 17)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 223, 0xFD, 2}
+ }) // Domain 223
+}
+
+Device(C224) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13000)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 224, 0xFD, 2}
+ }) // Domain 224
+}
+
+Device(C225) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13001)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 225, 0xFD, 2}
+ }) // Domain 225
+}
+
+Device(C226) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13100)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 226, 0xFD, 2}
+ }) // Domain 226
+}
+
+Device(C227) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13101)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 227, 0xFD, 2}
+ }) // Domain 227
+}
+
+Device(C228) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13200)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 228, 0xFD, 2}
+ }) // Domain 228
+}
+
+Device(C229) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13201)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 229, 0xFD, 2}
+ }) // Domain 229
+}
+
+Device(C230) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13300)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 230, 0xFD, 2}
+ }) // Domain 230
+}
+
+Device(C231) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13301)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 231, 0xFD, 2}
+ }) // Domain 231
+}
+
+Device(C232) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13400)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 232, 0xFD, 2}
+ }) // Domain 232
+}
+
+Device(C233) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13401)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 233, 0xFD, 2}
+ }) // Domain 233
+}
+
+Device(C234) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13500)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 234, 0xFD, 2}
+ }) // Domain 234
+}
+
+Device(C235) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13501)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 235, 0xFD, 2}
+ }) // Domain 235
+}
+
+Device(C236) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13600)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 236, 0xFD, 2}
+ }) // Domain 236
+}
+
+Device(C237) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13601)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 237, 0xFD, 2}
+ }) // Domain 237
+}
+
+Device(C238) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13700)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 238, 0xFD, 2}
+ }) // Domain 238
+}
+
+Device(C239) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13701)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 239, 0xFD, 2}
+ }) // Domain 239
+}
+
+Device(C240) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13800)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 240, 0xFD, 2}
+ }) // Domain 240
+}
+
+Device(C241) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13801)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 241, 0xFD, 2}
+ }) // Domain 241
+}
+
+Device(C242) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13900)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 242, 0xFD, 2}
+ }) // Domain 242
+}
+
+Device(C243) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13901)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 243, 0xFD, 2}
+ }) // Domain 243
+}
+
+Device(C244) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13a00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 244, 0xFD, 2}
+ }) // Domain 244
+}
+
+Device(C245) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13a01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 245, 0xFD, 2}
+ }) // Domain 245
+}
+
+Device(C246) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13b00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 246, 0xFD, 2}
+ }) // Domain 246
+}
+
+Device(C247) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13b01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 247, 0xFD, 2}
+ }) // Domain 247
+}
+
+Device(C248) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13c00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 248, 0xFD, 2}
+ }) // Domain 248
+}
+
+Device(C249) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13c01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 249, 0xFD, 2}
+ }) // Domain 249
+}
+
+Device(C250) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13d00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 250, 0xFD, 2}
+ }) // Domain 250
+}
+
+Device(C251) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13d01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 251, 0xFD, 2}
+ }) // Domain 251
+}
+
+Device(C252) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13e00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 252, 0xFD, 2}
+ }) // Domain 252
+}
+
+Device(C253) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13e01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 253, 0xFD, 2}
+ }) // Domain 253
+}
+
+Device(C254) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13f00)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package() {
+ Package() {5, 0, 254, 0xFD, 2}
+ }) // Domain 254
+}
+
+Device(C255) {
+ Name(_HID, "ACPI0007")
+ Name(_UID, 0x13f01)
+
+ Method (_LPI, 0, NotSerialized) {
+ return(PLPI)
+ }
+
+ Name(PCPC, Package() {
+ 23, // NumEntries
+ 3, // Revision
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
+ ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
+ ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
+ ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
+ })
+ If (LEqual(CPCE, 0x1)) {
+ Method (_CPC, 0, NotSerialized) {
+ return(PCPC)
+ }
+ }
+ //Performance State dependency
+ Name(_PSD, Package(){
+ Package() {5, 0, 255, 0xFD, 2}
+ }) // Domain 255
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
new file mode 100755
index 000000000000..00c09340b957
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
@@ -0,0 +1,127 @@
+/** @file
+
+ Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Name (CPCE, 1) // CPPC Enable
+Name (LPIE, 0) // LPI Enable
+
+Method (_OSC, 4, Serialized) { // _OSC: Operating System Capabilities
+ CreateDWordField (Arg3, 0x00, STS0)
+ CreateDWordField (Arg3, 0x04, CAP0)
+ If (LEqual(Arg0, ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48")) /* Platform-wide Capabilities */) {
+ If (LNotEqual(Arg1, One)) {
+ And(STS0, 0xFFFFFFE0, STS0)
+ Or(STS0, 0x0A, STS0) // Unrecognized Revision, OSC failure
+ } Else {
+ If (LEqual(And(CAP0, 0x100), 0x100)) {
+ And(CAP0, 0xFFFFFEFF, CAP0) // No support for OS Initiated LPI
+ And(STS0, 0xFFFFFFE0, STS0)
+ Or(STS0, 0x12, STS0)
+ }
+ If (LEqual(LPIE, 0x1)) {
+ Or(CAP0, 0x80, CAP0) // Support for LPI
+ } Else {
+ And(CAP0, 0xFFFFFF7F, CAP0) // No support for LPI
+ }
+ If (LEqual(CPCE, 0x1)) {
+ Or(CAP0, 0x40, CAP0) // Support for CPPCv2
+ } Else {
+ And(CAP0, 0xFFFFFFBF, CAP0) // No support for CPPCv2
+ }
+ }
+ } Else {
+ And(STS0, 0xFFFFFFE0, STS0)
+ Or(STS0, 0x06, STS0) // Unrecognized Revision, Unrecognized UUID
+ }
+ Return (Arg3)
+}
+
+Name(PLPI, Package() {
+ 0, // Version
+ 1, // Level Index
+ 2, // Count
+ // WFI for CPU (NS-WFI)
+ Package() {
+ 1, // Min residency (uS)
+ 1, // Wake latency (uS)
+ 1, // Flags
+ 0, // Arch Context Flags
+ 100, // Residency Counter Frequency
+ 0, // No parent state
+ ResourceTemplate () {
+ // Register Entry method
+ Register (FFixedHW,
+ 0x20, // Bit Width
+ 0x00, // Bit Offset
+ 0xFFFFFFFF, // Address
+ 0x03, // Access Size
+ )
+ },
+ ResourceTemplate() { // Null Residency Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ ResourceTemplate() { // Null Usage Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ "Standby",
+ },
+ // Retention state for CPU (S-WFI)
+ Package() {
+ 2, // Min residency (uS)
+ 2, // Wake latency (uS)
+ 1, // Flags
+ 0, // Arch Context Flags
+ 100, // Residency Counter Frequency
+ 1, // Parent node can be in Standby states
+ ResourceTemplate () {
+ // Register Entry method
+ Register (FFixedHW,
+ 0x20, // Bit Width
+ 0x00, // Bit Offset
+ 0x00000001, // Address
+ 0x03, // Access Size
+ )
+ },
+ ResourceTemplate() { // Null Residency Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ ResourceTemplate() { // Null Usage Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ "Standby_ATF"
+ },
+})
+
+Device (SYST) { // System state
+ Name(_HID, "ACPI0010")
+ Name(_UID, 1)
+ Name (_LPI, Package() {
+ 0, // Version
+ 0, // Level Index
+ 1, // Count
+ // Retention state for Cluster
+ Package() {
+ 100, // Min residency (uS)
+ 100, // Wake latency (uS)
+ 1, // Flags
+ 0, // Arch Context Flags
+ 100, // Residency Counter Frequency
+ 0, // No Parent State
+ 0x02000100, // Integer Entry method
+ ResourceTemplate() { // Null Residency Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ ResourceTemplate() { // Null Usage Counter
+ Register (SystemMemory, 0, 0, 0, 0)
+ },
+ "Standby"
+ },
+ })
+
+ Include ("CPU-S0.asi")
+ Include ("CPU-S1.asi")
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
new file mode 100755
index 000000000000..b9e2da79b5ef
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
@@ -0,0 +1,575 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+DefinitionBlock("Dsdt.aml", "DSDT", 0x02, "Ampere", "Jade", 1) {
+ //
+ // Board Model
+ Name(\BDMD, "Jade Board")
+ Name(TPMF, 0) // TPM presence
+ Name(AERF, 0) // PCIe AER Firmware-First
+ Scope(\_SB) {
+
+ Include ("CPU.asi")
+ Include ("PMU.asi")
+
+ //
+ // Hardware Monitor
+ Device(HM00) {
+ Name(_HID, "APMC0D29")
+ Name(_UID, "HWM0")
+ Name(_DDN, "HWM0")
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Hardware Monitor Device"))
+ Method(_STA, 0, NotSerialized) {
+ return (0xF)
+ }
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package() {
+ Package() {"pcc-channel", 14}
+ }
+ })
+ }
+
+ //
+ // Hardware Monitor
+ Device(HM01) {
+ Name(_HID, "APMC0D29")
+ Name(_UID, "HWM1")
+ Name(_DDN, "HWM1")
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Hardware Monitor Device"))
+ Method(_STA, 0, NotSerialized) {
+ return (0xF)
+ }
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package() {
+ Package() {"pcc-channel", 29}
+ }
+ })
+ }
+
+ //
+ // Hardware Monitor
+ Device(HM02) {
+ Name(_HID, "AMPC0005")
+ Name(_UID, "HWM2")
+ Name(_DDN, "HWM2")
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
+ Method(_STA, 0, NotSerialized) {
+ return (0xF)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000088900000, // AddressMinimum - MIN
+ 0x000000008891FFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000020000 // RangeLength - LEN
+ )
+ })
+ }
+
+ //
+ // Hardware Monitor
+ Device(HM03) {
+ Name(_HID, "AMPC0005")
+ Name(_UID, "HWM3")
+ Name(_DDN, "HWM3")
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
+ Method(_STA, 0, NotSerialized) {
+ return (0xF)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000088920000, // AddressMinimum - MIN
+ 0x000000008893FFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000020000 // RangeLength - LEN
+ )
+ })
+ }
+
+ //
+ // DesignWare I2C on AHBC bus
+ Device(I2C4) {
+ Name(_HID, "APMC0D0F")
+ Name(_UID, 4)
+ Name(_STR, Unicode("Altra I2C Device"))
+ Method(_STA, 0, NotSerialized) {
+ return (0x0f)
+ }
+ Name(_CCA, ONE)
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00001000026B0000, // AddressMinimum - MIN
+ 0x00001000026BFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000010000 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 105 }
+ })
+ Device (IPI) {
+ Name(_HID, "AMPC0004")
+ Name(_CID, "IPI0001")
+ Name(_STR, Unicode("IPMI_SSIF"))
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Method(_IFT) {
+ Return(0x04) // IPMI SSIF
+ }
+ Method(_ADR) {
+ Return(0x10) // SSIF slave address
+ }
+ Method(_SRV) {
+ Return(0x0200) // IPMI Specification Revision
+ }
+ Name(_CRS, ResourceTemplate ()
+ {
+ I2cSerialBus (0x0010, ControllerInitiated, 0x00061A80,
+ AddressingMode7Bit, "\\_SB.I2C4",
+ 0x00, ResourceConsumer,,
+ )
+ })
+ }
+ Name(SSCN, Package() { 0x3E2, 0x47D, 0 })
+ Name(FMCN, Package() { 0xA4, 0x13F, 0 })
+ }
+
+ //
+ // Report APEI Errors to GHES via SCI notification.
+ // SCI notification requires one GED and one HED Device
+ // GED = Generic Event Device (ACPI0013)
+ // HED = Hardware Error Device (PNP0C33)
+ //
+ Device(GED0) {
+ Name(_HID, "ACPI0013")
+ Name(_UID, Zero)
+ Method(_STA) {
+ Return (0xF)
+ }
+ Name(_CRS, ResourceTemplate () {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 84 } // GHES
+ })
+ Method(_EVT, 1, Serialized) {
+ Switch (ToInteger(Arg0)) {
+ Case (84) { // GHES interrupt
+ Notify (HED0, 0x80)
+ }
+ }
+ }
+ }
+
+ // Shutdown button using GED.
+ Device(GED1) {
+ Name(_HID, "ACPI0013")
+ Name(_CID, "ACPI0013")
+ Name(_UID, One)
+ Method(_STA) {
+ Return (0xF)
+ }
+ Name(_CRS, ResourceTemplate () {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 327 }
+ })
+ OperationRegion(PDDR, SystemMemory, 0x1000027B0004, 4)
+ Field(PDDR, DWordAcc, NoLock, Preserve) {
+ STDI, 8
+ }
+
+ OperationRegion(INTE, SystemMemory, 0x1000027B0030, 4)
+ Field(INTE, DWordAcc, NoLock, Preserve) {
+ STDE, 8
+ }
+
+ OperationRegion(INTT, SystemMemory, 0x1000027B0034, 4)
+ Field(INTT, DWordAcc, NoLock, Preserve) {
+ TYPE, 8
+ }
+
+ OperationRegion(INTP, SystemMemory, 0x1000027B0038, 4)
+ Field(INTP, DWordAcc, NoLock, Preserve) {
+ POLA, 8
+ }
+
+ OperationRegion(INTS, SystemMemory, 0x1000027B003c, 4)
+ Field(INTS, DWordAcc, NoLock, Preserve) {
+ STDS, 8
+ }
+
+ OperationRegion(INTC, SystemMemory, 0x1000027B0040, 4)
+ Field(INTC, DWordAcc, NoLock, Preserve) {
+ SINT, 8
+ }
+
+ OperationRegion(INTM, SystemMemory, 0x1000027B0044, 4)
+ Field(INTM, DWordAcc, NoLock, Preserve) {
+ MASK, 8
+ }
+
+ Method(_INI, 0, NotSerialized) {
+ // Set level type, low active (shutdown)
+ Store (0x00, TYPE)
+ Store (0x00, POLA)
+ // Set Input type (shutdown)
+ Store (0x00, STDI)
+ // Enable interrupt (shutdown)
+ Store (0x80, STDE)
+ // Unmask the interrupt.
+ Store (0x00, MASK)
+ }
+ Method(_EVT, 1, Serialized) {
+ Switch (ToInteger(Arg0)) {
+ Case (327) {
+ if (And (STDS, 0x80)) {
+ //Clear the interrupt.
+ Store (0x80, SINT)
+ // Notify OSPM the power button is pressed
+ Notify (\_SB.PWRB, 0x80)
+ }
+ }
+ }
+ }
+ }
+
+ // Power button device description
+ Device(PWRB) {
+ Name(_HID, EISAID("PNP0C0C"))
+ Name(_ADR, 0)
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Method(_STA, 0, Notserialized) {
+ Return (0x0b)
+ }
+ }
+
+ //
+ // UART0 PL011
+ Device(URT0) {
+ Name(_HID, "ARMH0011")
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Method(_STA, 0, NotSerialized) {
+ return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000100002600000, // AddressMinimum - MIN
+ 0x0000100002600FFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000001000 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 98 }
+ })
+ } // UART0
+
+ //
+ // UART2 PL011
+ Device(URT2) {
+ Name(_HID, "ARMH0011")
+ Name(_UID, 1)
+ Name(_CCA, ONE)
+ Method(_STA, 0, NotSerialized) {
+ return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000100002620000, // AddressMinimum - MIN
+ 0x0000100002620FFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000001000 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 100 }
+ })
+ } // UART1
+
+ Device(HED0)
+ {
+ Name(_HID, EISAID("PNP0C33"))
+ Name(_UID, Zero)
+ }
+
+ Device(NVDR) {
+ Name(_HID, "ACPI0012")
+ Method(_STA, 0, NotSerialized) {
+ return (0xf)
+ }
+ Method (_DSM, 0x4, Serialized) {
+ // Not support any functions for now
+ Return (Buffer() {0})
+ }
+ Device (NVD1) {
+ Name(_ADR, 0x0330)
+ Name(SMRT, Buffer(13) {0})
+ CreateDWordField(SMRT, 0, BSTA)
+ CreateWordField(SMRT, 4, BHTH)
+ CreateWordField(SMRT, 6, BTMP)
+ CreateByteField(SMRT, 8, BETH)
+ CreateByteField(SMRT, 9, BWTH)
+ CreateByteField(SMRT, 10, BNLF)
+ OperationRegion(BUF1, SystemMemory, 0x88980000, 16)
+ Field (BUF1, DWordAcc, NoLock, Preserve) {
+ STAT, 32, //Status
+ HLTH, 16, //Module Health
+ CTMP, 16, //Module Current Status
+ ETHS, 8, //Error Threshold Status
+ WTHS, 8, //Warning Threshold Status
+ NVLF, 8, //NVM Lifetime
+ , 40 //Reserve
+ }
+ Method (_DSM, 0x4, Serialized) {
+ //Accept only MSF Family type NVDIMM DSM functions
+ If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
+ //Handle Func 0 query implemented commands
+ If(LEqual(Arg2, 0)) {
+ //Check revision and returned proper implemented commands
+ //Support only health check for now
+ Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
+ }
+ //Handle MSF DSM Func 11 Get Smart and Health Info
+ If(LEqual(Arg2, 11)) {
+ Store(\_SB.NVDR.NVD1.STAT, BSTA)
+ Store(\_SB.NVDR.NVD1.HLTH, BHTH)
+ Store(\_SB.NVDR.NVD1.CTMP, BTMP)
+ Store(\_SB.NVDR.NVD1.ETHS, BETH)
+ Store(\_SB.NVDR.NVD1.WTHS, BWTH)
+ Store(\_SB.NVDR.NVD1.NVLF, BNLF)
+ Return (SMRT)
+ }
+ }
+ Return (Buffer() {0})
+ }
+ Method(_STA, 0, NotSerialized) {
+ return (0xf)
+ }
+ }
+ Device (NVD2) {
+ Name(_ADR, 0x0770)
+ Name(SMRT, Buffer(13) {0})
+ CreateDWordField(SMRT, 0, BSTA)
+ CreateWordField(SMRT, 4, BHTH)
+ CreateWordField(SMRT, 6, BTMP)
+ CreateByteField(SMRT, 8, BETH)
+ CreateByteField(SMRT, 9, BWTH)
+ CreateByteField(SMRT, 10, BNLF)
+ OperationRegion(BUF1, SystemMemory, 0x88988000, 16)
+ Field (BUF1, DWordAcc, NoLock, Preserve) {
+ STAT, 32, //Status
+ HLTH, 16, //Module Health
+ CTMP, 16, //Module Current Status
+ ETHS, 8, //Error Threshold Status
+ WTHS, 8, //Warning Threshold Status
+ NVLF, 8, //NVM Lifetime
+ , 40 //Reserve
+ }
+ Method (_DSM, 0x4, Serialized) {
+ //Accept only MSF Family type NVDIMM DSM functions
+ If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
+ //Handle Func 0 query implemented commands
+ If(LEqual(Arg2, 0)) {
+ //Check revision and returned proper implemented commands
+ //Support only health check for now
+ Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
+ }
+ //Handle MSF DSM Func 11 Get Smart and Health Info
+ If(LEqual(Arg2, 11)) {
+ Store(\_SB.NVDR.NVD2.STAT, BSTA)
+ Store(\_SB.NVDR.NVD2.HLTH, BHTH)
+ Store(\_SB.NVDR.NVD2.CTMP, BTMP)
+ Store(\_SB.NVDR.NVD2.ETHS, BETH)
+ Store(\_SB.NVDR.NVD2.WTHS, BWTH)
+ Store(\_SB.NVDR.NVD2.NVLF, BNLF)
+ Return (SMRT)
+ }
+ }
+ Return (Buffer() {0})
+ }
+ Method(_STA, 0, NotSerialized) {
+ return (0xf)
+ }
+ }
+ Device (NVD3) {
+ Name(_ADR, 0x1330)
+ Name(SMRT, Buffer(13) {0})
+ CreateDWordField(SMRT, 0, BSTA)
+ CreateWordField(SMRT, 4, BHTH)
+ CreateWordField(SMRT, 6, BTMP)
+ CreateByteField(SMRT, 8, BETH)
+ CreateByteField(SMRT, 9, BWTH)
+ CreateByteField(SMRT, 10, BNLF)
+ OperationRegion(BUF1, SystemMemory, 0xC0080000, 16)
+ Field (BUF1, DWordAcc, NoLock, Preserve) {
+ STAT, 32, //Status
+ HLTH, 16, //Module Health
+ CTMP, 16, //Module Current Status
+ ETHS, 8, //Error Threshold Status
+ WTHS, 8, //Warning Threshold Status
+ NVLF, 8, //NVM Lifetime
+ , 40 //Reserve
+ }
+ Method (_DSM, 0x4, Serialized) {
+ //Accept only MSF Family type NVDIMM DSM functions
+ If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
+ //Handle Func 0 query implemented commands
+ If(LEqual(Arg2, 0)) {
+ //Check revision and returned proper implemented commands
+ //Support only health check for now
+ Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
+ }
+ //Handle MSF DSM Func 11 Get Smart and Health Info
+ If(LEqual(Arg2, 11)) {
+ Store(\_SB.NVDR.NVD3.STAT, BSTA)
+ Store(\_SB.NVDR.NVD3.HLTH, BHTH)
+ Store(\_SB.NVDR.NVD3.CTMP, BTMP)
+ Store(\_SB.NVDR.NVD3.ETHS, BETH)
+ Store(\_SB.NVDR.NVD3.WTHS, BWTH)
+ Store(\_SB.NVDR.NVD3.NVLF, BNLF)
+ Return (SMRT)
+ }
+ }
+ Return (Buffer() {0})
+ }
+ Method(_STA, 0, NotSerialized) {
+ return (0xf)
+ }
+ }
+ Device (NVD4) {
+ Name(_ADR, 0x1770)
+ Name(SMRT, Buffer(13) {0})
+ CreateDWordField(SMRT, 0, BSTA)
+ CreateWordField(SMRT, 4, BHTH)
+ CreateWordField(SMRT, 6, BTMP)
+ CreateByteField(SMRT, 8, BETH)
+ CreateByteField(SMRT, 9, BWTH)
+ CreateByteField(SMRT, 10, BNLF)
+ OperationRegion(BUF1, SystemMemory, 0xC0088000, 16)
+ Field (BUF1, DWordAcc, NoLock, Preserve) {
+ STAT, 32, //Status
+ HLTH, 16, //Module Health
+ CTMP, 16, //Module Current Status
+ ETHS, 8, //Error Threshold Status
+ WTHS, 8, //Warning Threshold Status
+ NVLF, 8, //NVM Lifetime
+ , 40 //Reserve
+ }
+ Method (_DSM, 0x4, Serialized) {
+ //Accept only MSF Family type NVDIMM DSM functions
+ If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
+ //Handle Func 0 query implemented commands
+ If(LEqual(Arg2, 0)) {
+ //Check revision and returned proper implemented commands
+ //Support only health check for now
+ Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
+ }
+ //Handle MSF DSM Func 11 Get Smart and Health Info
+ If(LEqual(Arg2, 11)) {
+ Store(\_SB.NVDR.NVD4.STAT, BSTA)
+ Store(\_SB.NVDR.NVD4.HLTH, BHTH)
+ Store(\_SB.NVDR.NVD4.CTMP, BTMP)
+ Store(\_SB.NVDR.NVD4.ETHS, BETH)
+ Store(\_SB.NVDR.NVD4.WTHS, BWTH)
+ Store(\_SB.NVDR.NVD4.NVLF, BNLF)
+ Return (SMRT)
+ }
+ }
+ Return (Buffer() {0})
+ }
+ Method(_STA, 0, NotSerialized) {
+ return (0xf)
+ }
+ }
+ }
+
+ Device (TPM0) {
+ //
+ // TPM 2.0
+ //
+
+ //
+ // TAG for patching TPM2.0 _HID
+ //
+ Name (_HID, "NNNN0000")
+ Name (_CID, "MSFT0101")
+ Name (_UID, 0)
+
+ Name (CRBB, 0x10000000)
+ Name (CRBL, 0x10000000)
+
+ Name (RBUF, ResourceTemplate () {
+ Memory32Fixed (ReadWrite, 0x88500000, 0x1000, PCRE)
+ })
+
+ Method (_CRS, 0x0, Serialized) {
+ // Declare fields in PCRE
+ CreateDWordField(RBUF, ^PCRE._BAS, BASE)
+ CreateDWordField(RBUF, ^PCRE._LEN, LENG)
+
+ // Store updatable values into them
+ Store(CRBB, BASE)
+ Store(CRBL, LENG)
+
+ Return (RBUF)
+ }
+
+ Method (_STR,0) {
+ Return (Unicode ("TPM 2.0 Device"))
+ }
+
+ Method (_STA, 0) {
+ if (TPMF) {
+ Return (0x0f) //Enable resources
+ }
+ Return (0x0)
+ }
+ }
+
+ Include ("PCI-S0.Rca01.asi")
+ Include ("PCI-S0.asi")
+ Include ("PCI-S1.asi")
+ Include ("PCI-PDRC.asi")
+ }
+} // DSDT
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
new file mode 100644
index 000000000000..16c00c35e3fe
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
@@ -0,0 +1,217 @@
+/** @file
+
+ Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+ // Motherboard resource consumption for PCIE resource reservation
+ // as upstream discussion "ACPI namespace details for ARM64"
+ Device (PDRC) {
+ Name (_HID, EISAID("PNP0C02"))
+ Name (_UID, 1)
+ // S0 Start here
+ Name (PDRS, ResourceTemplate() {
+ QWordMemory ( // PCIE0 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00003BFFF0000000, // AddressMinimum - MIN
+ 0x00003BFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE1 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00003FFFF0000000, // AddressMinimum - MIN
+ 0x00003FFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE2 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000023FFF0000000, // AddressMinimum - MIN
+ 0x000023FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE3 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000027FFF0000000, // AddressMinimum - MIN
+ 0x000027FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE4 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00002BFFF0000000, // AddressMinimum - MIN
+ 0x00002BFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE5 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00002FFFF0000000, // AddressMinimum - MIN
+ 0x00002FFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ // S1 Start here
+ QWordMemory ( // PCIE6 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00007BFFF0000000, // AddressMinimum - MIN
+ 0x00007BFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE7 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00007FFFF0000000, // AddressMinimum - MIN
+ 0x00007FFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE8 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000063FFF0000000, // AddressMinimum - MIN
+ 0x000063FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIE9 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000067FFF0000000, // AddressMinimum - MIN
+ 0x000067FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+ QWordMemory ( // PCIEA 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00006BFFF0000000, // AddressMinimum - MIN
+ 0x00006BFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIEB 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00006FFFF0000000, // AddressMinimum - MIN
+ 0x00006FFFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIEC 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000033FFF0000000, // AddressMinimum - MIN
+ 0x000033FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory ( // PCIED 256M CFG region for ECAM
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000037FFF0000000, // AddressMinimum - MIN
+ 0x000037FFFFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+ })
+
+ // Current Resource Settings
+ Method (_CRS, 0, Serialized) {
+ Return (PDRS)
+ }
+ }
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
new file mode 100755
index 000000000000..67e1518ebf88
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
@@ -0,0 +1,681 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+ // PCI0 RCA0
+ Device (PCI0) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 12)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI0")
+ Name (_STR, Unicode("PCIe 0 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 128/129/130/131 respectively. PCI0 RCA0
+ //
+ Package() {0x0001FFFF, 0, 0, 128},
+ Package() {0x0001FFFF, 1, 0, 129},
+ Package() {0x0001FFFF, 2, 0, 130},
+ Package() {0x0001FFFF, 3, 0, 131},
+ Package() {0x0002FFFF, 0, 0, 128},
+ Package() {0x0002FFFF, 1, 0, 129},
+ Package() {0x0002FFFF, 2, 0, 130},
+ Package() {0x0002FFFF, 3, 0, 131},
+ Package() {0x0003FFFF, 0, 0, 128},
+ Package() {0x0003FFFF, 1, 0, 129},
+ Package() {0x0003FFFF, 2, 0, 130},
+ Package() {0x0003FFFF, 3, 0, 131},
+ Package() {0x0004FFFF, 0, 0, 128},
+ Package() {0x0004FFFF, 1, 0, 129},
+ Package() {0x0004FFFF, 2, 0, 130},
+ Package() {0x0004FFFF, 3, 0, 131},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x33FFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000040000000, // AddressMinimum - MIN
+ 0x000000004FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000300000000000, // AddressMinimum - MIN
+ 0x000033FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI0 RCA0
+
+ // PCI1 RCA1
+ Device (PCI1) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 13)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI1")
+ Name (_STR, Unicode("PCIe 1 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 132/133/134/135 respectively. PCI1 RCA1
+ //
+ Package() {0x0001FFFF, 0, 0, 132},
+ Package() {0x0001FFFF, 1, 0, 133},
+ Package() {0x0001FFFF, 2, 0, 134},
+ Package() {0x0001FFFF, 3, 0, 135},
+ Package() {0x0002FFFF, 0, 0, 132},
+ Package() {0x0002FFFF, 1, 0, 133},
+ Package() {0x0002FFFF, 2, 0, 134},
+ Package() {0x0002FFFF, 3, 0, 135},
+ Package() {0x0003FFFF, 0, 0, 132},
+ Package() {0x0003FFFF, 1, 0, 133},
+ Package() {0x0003FFFF, 2, 0, 134},
+ Package() {0x0003FFFF, 3, 0, 135},
+ Package() {0x0004FFFF, 0, 0, 132},
+ Package() {0x0004FFFF, 1, 0, 133},
+ Package() {0x0004FFFF, 2, 0, 134},
+ Package() {0x0004FFFF, 3, 0, 135},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x37FFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000050000000, // AddressMinimum - MIN
+ 0x000000005FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ Cacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000340000000000, // AddressMinimum - MIN
+ 0x000037FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI1 RCA1
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
new file mode 100755
index 000000000000..7c05c6768a0e
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
@@ -0,0 +1,2078 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+ // PCI2 RCA2
+ Device (PCI2) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF)
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 1)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI2")
+ Name (_STR, Unicode("PCIe 2 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 136/137/138/139 respectively. PCI2 RCA2
+ //
+ Package() {0x0001FFFF, 0, 0, 136},
+ Package() {0x0001FFFF, 1, 0, 137},
+ Package() {0x0001FFFF, 2, 0, 138},
+ Package() {0x0001FFFF, 3, 0, 139},
+ Package() {0x0002FFFF, 0, 0, 136},
+ Package() {0x0002FFFF, 1, 0, 137},
+ Package() {0x0002FFFF, 2, 0, 138},
+ Package() {0x0002FFFF, 3, 0, 139},
+ Package() {0x0003FFFF, 0, 0, 136},
+ Package() {0x0003FFFF, 1, 0, 137},
+ Package() {0x0003FFFF, 2, 0, 138},
+ Package() {0x0003FFFF, 3, 0, 139},
+ Package() {0x0004FFFF, 0, 0, 136},
+ Package() {0x0004FFFF, 1, 0, 137},
+ Package() {0x0004FFFF, 2, 0, 138},
+ Package() {0x0004FFFF, 3, 0, 139},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x3BFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE80000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000030000000, // AddressMinimum - MIN
+ 0x0000000037FFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000380000000000, // AddressMinimum - MIN
+ 0x00003BFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP, 0) // PCI _OSC Support Field value
+ Name (CTRL, 0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3,0,CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI2 RCA2
+
+ // PCI3 RCA3
+ Device (PCI3) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF)
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 0)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI3")
+ Name (_STR, Unicode("PCIe 3 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 140/141/142/143 respectively. PCI3 RCA3
+ //
+ Package() {0x0001FFFF, 0, 0, 140},
+ Package() {0x0001FFFF, 1, 0, 141},
+ Package() {0x0001FFFF, 2, 0, 142},
+ Package() {0x0001FFFF, 3, 0, 143},
+ Package() {0x0002FFFF, 0, 0, 140},
+ Package() {0x0002FFFF, 1, 0, 141},
+ Package() {0x0002FFFF, 2, 0, 142},
+ Package() {0x0002FFFF, 3, 0, 143},
+ Package() {0x0003FFFF, 0, 0, 140},
+ Package() {0x0003FFFF, 1, 0, 141},
+ Package() {0x0003FFFF, 2, 0, 142},
+ Package() {0x0003FFFF, 3, 0, 143},
+ Package() {0x0004FFFF, 0, 0, 140},
+ Package() {0x0004FFFF, 1, 0, 141},
+ Package() {0x0004FFFF, 2, 0, 142},
+ Package() {0x0004FFFF, 3, 0, 143},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x3FFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to Return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE00000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000038000000, // AddressMinimum - MIN
+ 0x000000003FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00003C0000000000, // AddressMinimum - MIN
+ 0x00003FFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP, 0) // PCI _OSC Support Field value
+ Name (CTRL, 0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI3 RCA3
+
+ // PCI4 RCB0
+ Device (PCI4) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 2)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI4")
+ Name (_STR, Unicode("PCIe 4 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 144/145/146/147 respectively. PCI4 RCB0
+ //
+ Package() {0x0001FFFF, 0, 0, 144},
+ Package() {0x0001FFFF, 1, 0, 145},
+ Package() {0x0001FFFF, 2, 0, 146},
+ Package() {0x0001FFFF, 3, 0, 147},
+ Package() {0x0002FFFF, 0, 0, 144},
+ Package() {0x0002FFFF, 1, 0, 145},
+ Package() {0x0002FFFF, 2, 0, 146},
+ Package() {0x0002FFFF, 3, 0, 147},
+ Package() {0x0003FFFF, 0, 0, 144},
+ Package() {0x0003FFFF, 1, 0, 145},
+ Package() {0x0003FFFF, 2, 0, 146},
+ Package() {0x0003FFFF, 3, 0, 147},
+ Package() {0x0004FFFF, 0, 0, 144},
+ Package() {0x0004FFFF, 1, 0, 145},
+ Package() {0x0004FFFF, 2, 0, 146},
+ Package() {0x0004FFFF, 3, 0, 147},
+ Package() {0x0005FFFF, 0, 0, 144},
+ Package() {0x0005FFFF, 1, 0, 145},
+ Package() {0x0005FFFF, 2, 0, 146},
+ Package() {0x0005FFFF, 3, 0, 147},
+ Package() {0x0006FFFF, 0, 0, 144},
+ Package() {0x0006FFFF, 1, 0, 145},
+ Package() {0x0006FFFF, 2, 0, 146},
+ Package() {0x0006FFFF, 3, 0, 147},
+ Package() {0x0007FFFF, 0, 0, 144},
+ Package() {0x0007FFFF, 1, 0, 145},
+ Package() {0x0007FFFF, 2, 0, 146},
+ Package() {0x0007FFFF, 3, 0, 147},
+ Package() {0x0008FFFF, 0, 0, 144},
+ Package() {0x0008FFFF, 1, 0, 145},
+ Package() {0x0008FFFF, 2, 0, 146},
+ Package() {0x0008FFFF, 3, 0, 147},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x23FFF0000000)
+ }
+
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FEC0000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000001000000, // AddressMinimum - MIN
+ 0x0000000007FFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000007000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000200000000000, // AddressMinimum - MIN
+ 0x000023FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2))
+ {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI4 RCB0
+
+ // PCI5 RCB1
+ Device (PCI5) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF)
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID,"PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 3)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI5")
+ Name (_STR, Unicode("PCIe 5 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 148/149/150/151 respectively. PCI5 RCB1
+ //
+ Package() {0x0001FFFF, 0, 0, 148},
+ Package() {0x0001FFFF, 1, 0, 149},
+ Package() {0x0001FFFF, 2, 0, 150},
+ Package() {0x0001FFFF, 3, 0, 151},
+ Package() {0x0002FFFF, 0, 0, 148},
+ Package() {0x0002FFFF, 1, 0, 149},
+ Package() {0x0002FFFF, 2, 0, 150},
+ Package() {0x0002FFFF, 3, 0, 151},
+ Package() {0x0003FFFF, 0, 0, 148},
+ Package() {0x0003FFFF, 1, 0, 149},
+ Package() {0x0003FFFF, 2, 0, 150},
+ Package() {0x0003FFFF, 3, 0, 151},
+ Package() {0x0004FFFF, 0, 0, 148},
+ Package() {0x0004FFFF, 1, 0, 149},
+ Package() {0x0004FFFF, 2, 0, 150},
+ Package() {0x0004FFFF, 3, 0, 151},
+ Package() {0x0005FFFF, 0, 0, 148},
+ Package() {0x0005FFFF, 1, 0, 149},
+ Package() {0x0005FFFF, 2, 0, 150},
+ Package() {0x0005FFFF, 3, 0, 151},
+ Package() {0x0006FFFF, 0, 0, 148},
+ Package() {0x0006FFFF, 1, 0, 149},
+ Package() {0x0006FFFF, 2, 0, 150},
+ Package() {0x0006FFFF, 3, 0, 151},
+ Package() {0x0007FFFF, 0, 0, 148},
+ Package() {0x0007FFFF, 1, 0, 149},
+ Package() {0x0007FFFF, 2, 0, 150},
+ Package() {0x0007FFFF, 3, 0, 151},
+ Package() {0x0008FFFF, 0, 0, 148},
+ Package() {0x0008FFFF, 1, 0, 149},
+ Package() {0x0008FFFF, 2, 0, 150},
+ Package() {0x0008FFFF, 3, 0, 151},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x27FFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FF00000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000008000000, // AddressMinimum - MIN
+ 0x000000000FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000240000000000, // AddressMinimum - MIN
+ 0x000027FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP, 0) // PCI _OSC Support Field value
+ Name (CTRL, 0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2))
+ {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI5 RCB1
+
+
+ // PCI6 RCB2
+ Device (PCI6) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID,"PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID,"PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 4)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI6")
+ Name (_STR, Unicode("PCIe 6 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 152/153/154/155 respectively. PCI6 RCB2
+ //
+ Package() {0x0001FFFF, 0, 0, 152},
+ Package() {0x0001FFFF, 1, 0, 153},
+ Package() {0x0001FFFF, 2, 0, 154},
+ Package() {0x0001FFFF, 3, 0, 155},
+ Package() {0x0002FFFF, 0, 0, 152},
+ Package() {0x0002FFFF, 1, 0, 153},
+ Package() {0x0002FFFF, 2, 0, 154},
+ Package() {0x0002FFFF, 3, 0, 155},
+ Package() {0x0003FFFF, 0, 0, 152},
+ Package() {0x0003FFFF, 1, 0, 153},
+ Package() {0x0003FFFF, 2, 0, 154},
+ Package() {0x0003FFFF, 3, 0, 155},
+ Package() {0x0004FFFF, 0, 0, 152},
+ Package() {0x0004FFFF, 1, 0, 153},
+ Package() {0x0004FFFF, 2, 0, 154},
+ Package() {0x0004FFFF, 3, 0, 155},
+ Package() {0x0005FFFF, 0, 0, 152},
+ Package() {0x0005FFFF, 1, 0, 153},
+ Package() {0x0005FFFF, 2, 0, 154},
+ Package() {0x0005FFFF, 3, 0, 155},
+ Package() {0x0006FFFF, 0, 0, 152},
+ Package() {0x0006FFFF, 1, 0, 153},
+ Package() {0x0006FFFF, 2, 0, 154},
+ Package() {0x0006FFFF, 3, 0, 155},
+ Package() {0x0007FFFF, 0, 0, 152},
+ Package() {0x0007FFFF, 1, 0, 153},
+ Package() {0x0007FFFF, 2, 0, 154},
+ Package() {0x0007FFFF, 3, 0, 155},
+ Package() {0x0008FFFF, 0, 0, 152},
+ Package() {0x0008FFFF, 1, 0, 153},
+ Package() {0x0008FFFF, 2, 0, 154},
+ Package() {0x0008FFFF, 3, 0, 155},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x2BFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000010000000, // AddressMinimum - MIN
+ 0x0000000017FFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000280000000000, // AddressMinimum - MIN
+ 0x00002BFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3,0,CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3,4,CDW2)
+ CreateDWordField (Arg3,8,CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2,SUPP)
+ Store (CDW3,CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL,0x1E,CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1,One)) {
+ Or (CDW1,0x08,CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3,CTRL)) {
+ Or (CDW1,0x10,CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL,CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1,4,CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI6 RCB2
+
+ // PCI7 RCB3
+ Device (PCI7) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID,"PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID,"PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 5)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCI7")
+ Name (_STR, Unicode("PCIe 7 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 156/157/158/159 respectively. PCI7 RCB3
+ //
+ Package() {0x0001FFFF, 0, 0, 156},
+ Package() {0x0001FFFF, 1, 0, 157},
+ Package() {0x0001FFFF, 2, 0, 158},
+ Package() {0x0001FFFF, 3, 0, 159},
+ Package() {0x0002FFFF, 0, 0, 156},
+ Package() {0x0002FFFF, 1, 0, 157},
+ Package() {0x0002FFFF, 2, 0, 158},
+ Package() {0x0002FFFF, 3, 0, 159},
+ Package() {0x0003FFFF, 0, 0, 156},
+ Package() {0x0003FFFF, 1, 0, 157},
+ Package() {0x0003FFFF, 2, 0, 158},
+ Package() {0x0003FFFF, 3, 0, 159},
+ Package() {0x0004FFFF, 0, 0, 156},
+ Package() {0x0004FFFF, 1, 0, 157},
+ Package() {0x0004FFFF, 2, 0, 158},
+ Package() {0x0004FFFF, 3, 0, 159},
+ Package() {0x0005FFFF, 0, 0, 156},
+ Package() {0x0005FFFF, 1, 0, 157},
+ Package() {0x0005FFFF, 2, 0, 158},
+ Package() {0x0005FFFF, 3, 0, 159},
+ Package() {0x0006FFFF, 0, 0, 156},
+ Package() {0x0006FFFF, 1, 0, 157},
+ Package() {0x0006FFFF, 2, 0, 158},
+ Package() {0x0006FFFF, 3, 0, 159},
+ Package() {0x0007FFFF, 0, 0, 156},
+ Package() {0x0007FFFF, 1, 0, 157},
+ Package() {0x0007FFFF, 2, 0, 158},
+ Package() {0x0007FFFF, 3, 0, 159},
+ Package() {0x0008FFFF, 0, 0, 156},
+ Package() {0x0008FFFF, 1, 0, 157},
+ Package() {0x0008FFFF, 2, 0, 158},
+ Package() {0x0008FFFF, 3, 0, 159},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x2FFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000018000000, // AddressMinimum - MIN
+ 0x000000001FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00002C0000000000, // AddressMinimum - MIN
+ 0x00002FFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3,0,CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3,4,CDW2)
+ CreateDWordField (Arg3,8,CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2,SUPP)
+ Store (CDW3,CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL,0x1E,CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1,One)) {
+ Or (CDW1,0x08,CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3,CTRL)) {
+ Or (CDW1,0x10,CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL,CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1,4,CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCI7 RCB3
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
new file mode 100755
index 000000000000..2757f3124b83
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
@@ -0,0 +1,2087 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+ //
+ // S1 Start here
+ //
+
+ // PCIE6 S1 RCA2
+ Device (PCIA) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID,"PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF)
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID,"PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 6)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCIA")
+ Name (_STR, Unicode("PCIe 10 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 136/137/138/139 + 320 respectively. PCIA RCA2
+ //
+ Package() {0x0001FFFF, 0, 0, 456},
+ Package() {0x0001FFFF, 1, 0, 457},
+ Package() {0x0001FFFF, 2, 0, 458},
+ Package() {0x0001FFFF, 3, 0, 459},
+ Package() {0x0002FFFF, 0, 0, 456},
+ Package() {0x0002FFFF, 1, 0, 457},
+ Package() {0x0002FFFF, 2, 0, 458},
+ Package() {0x0002FFFF, 3, 0, 459},
+ Package() {0x0003FFFF, 0, 0, 456},
+ Package() {0x0003FFFF, 1, 0, 457},
+ Package() {0x0003FFFF, 2, 0, 458},
+ Package() {0x0003FFFF, 3, 0, 459},
+ Package() {0x0004FFFF, 0, 0, 456},
+ Package() {0x0004FFFF, 1, 0, 457},
+ Package() {0x0004FFFF, 2, 0, 458},
+ Package() {0x0004FFFF, 3, 0, 459},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x7BFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FF80000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000070000000, // AddressMinimum - MIN
+ 0x0000000077FFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000780000000000, // AddressMinimum - MIN
+ 0x00007BFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3,0,CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3,4,CDW2)
+ CreateDWordField (Arg3,8,CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2,SUPP)
+ Store (CDW3,CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL,0x1E,CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1,One)) {
+ Or (CDW1,0x08,CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3,CTRL)) {
+ Or (CDW1,0x10,CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL,CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1,4,CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCIA RCA2
+
+ // PCIEB RCA3
+ Device (PCIB) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID,"PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF)
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID,"PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 7)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCIB")
+ Name (_STR, Unicode("PCIe 11 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 140/141/142/143 + 320 respectively. PCIB RCA3
+ //
+ Package() {0x0001FFFF, 0, 0, 460},
+ Package() {0x0001FFFF, 1, 0, 461},
+ Package() {0x0001FFFF, 2, 0, 462},
+ Package() {0x0001FFFF, 3, 0, 463},
+ Package() {0x0002FFFF, 0, 0, 460},
+ Package() {0x0002FFFF, 1, 0, 461},
+ Package() {0x0002FFFF, 2, 0, 462},
+ Package() {0x0002FFFF, 3, 0, 463},
+ Package() {0x0003FFFF, 0, 0, 460},
+ Package() {0x0003FFFF, 1, 0, 461},
+ Package() {0x0003FFFF, 2, 0, 462},
+ Package() {0x0003FFFF, 3, 0, 463},
+ Package() {0x0004FFFF, 0, 0, 460},
+ Package() {0x0004FFFF, 1, 0, 461},
+ Package() {0x0004FFFF, 2, 0, 462},
+ Package() {0x0004FFFF, 3, 0, 463},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x7FFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FFC0000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000078000000, // AddressMinimum - MIN
+ 0x000000007FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00007C0000000000, // AddressMinimum - MIN
+ 0x00007FFFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3,0,CDW1)
+ If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3,4,CDW2)
+ CreateDWordField (Arg3,8,CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2,SUPP)
+ Store (CDW3,CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL,0x1E,CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1,One)) {
+ Or (CDW1,0x08,CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3,CTRL)) {
+ Or (CDW1,0x10,CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL,CDW3)
+ Return (Arg3)
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1,4,CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCIB RCA3
+
+ // PCIC RCB0
+ Device (PCIC) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 8)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCIC")
+ Name (_STR, Unicode("PCIe 12 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 144/145/146/147 + 320 respectively. PCIC RCB0
+ //
+ Package() {0x0001FFFF, 0, 0, 464},
+ Package() {0x0001FFFF, 1, 0, 465},
+ Package() {0x0001FFFF, 2, 0, 466},
+ Package() {0x0001FFFF, 3, 0, 467},
+ Package() {0x0002FFFF, 0, 0, 464},
+ Package() {0x0002FFFF, 1, 0, 465},
+ Package() {0x0002FFFF, 2, 0, 466},
+ Package() {0x0002FFFF, 3, 0, 467},
+ Package() {0x0003FFFF, 0, 0, 464},
+ Package() {0x0003FFFF, 1, 0, 465},
+ Package() {0x0003FFFF, 2, 0, 466},
+ Package() {0x0003FFFF, 3, 0, 467},
+ Package() {0x0004FFFF, 0, 0, 464},
+ Package() {0x0004FFFF, 1, 0, 465},
+ Package() {0x0004FFFF, 2, 0, 466},
+ Package() {0x0004FFFF, 3, 0, 467},
+ Package() {0x0005FFFF, 0, 0, 464},
+ Package() {0x0005FFFF, 1, 0, 465},
+ Package() {0x0005FFFF, 2, 0, 466},
+ Package() {0x0005FFFF, 3, 0, 467},
+ Package() {0x0006FFFF, 0, 0, 464},
+ Package() {0x0006FFFF, 1, 0, 465},
+ Package() {0x0006FFFF, 2, 0, 466},
+ Package() {0x0006FFFF, 3, 0, 467},
+ Package() {0x0007FFFF, 0, 0, 464},
+ Package() {0x0007FFFF, 1, 0, 465},
+ Package() {0x0007FFFF, 2, 0, 466},
+ Package() {0x0007FFFF, 3, 0, 467},
+ Package() {0x0008FFFF, 0, 0, 464},
+ Package() {0x0008FFFF, 1, 0, 465},
+ Package() {0x0008FFFF, 2, 0, 466},
+ Package() {0x0008FFFF, 3, 0, 467},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x63FFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000040000000, // AddressMinimum - MIN
+ 0x0000000047FFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000600000000000, // AddressMinimum - MIN
+ 0x000063FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCIC RCB0
+
+ // PCID RCB1
+ Device (PCID) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 9)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCID")
+ Name (_STR, Unicode("PCIe 13 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 148/149/150/151 + 320 respectively. PCID RCB1
+ //
+ Package() {0x0001FFFF, 0, 0, 468},
+ Package() {0x0001FFFF, 1, 0, 469},
+ Package() {0x0001FFFF, 2, 0, 470},
+ Package() {0x0001FFFF, 3, 0, 471},
+ Package() {0x0002FFFF, 0, 0, 468},
+ Package() {0x0002FFFF, 1, 0, 469},
+ Package() {0x0002FFFF, 2, 0, 470},
+ Package() {0x0002FFFF, 3, 0, 471},
+ Package() {0x0003FFFF, 0, 0, 468},
+ Package() {0x0003FFFF, 1, 0, 469},
+ Package() {0x0003FFFF, 2, 0, 470},
+ Package() {0x0003FFFF, 3, 0, 471},
+ Package() {0x0004FFFF, 0, 0, 468},
+ Package() {0x0004FFFF, 1, 0, 469},
+ Package() {0x0004FFFF, 2, 0, 470},
+ Package() {0x0004FFFF, 3, 0, 471},
+ Package() {0x0005FFFF, 0, 0, 468},
+ Package() {0x0005FFFF, 1, 0, 469},
+ Package() {0x0005FFFF, 2, 0, 470},
+ Package() {0x0005FFFF, 3, 0, 471},
+ Package() {0x0006FFFF, 0, 0, 468},
+ Package() {0x0006FFFF, 1, 0, 469},
+ Package() {0x0006FFFF, 2, 0, 470},
+ Package() {0x0006FFFF, 3, 0, 471},
+ Package() {0x0007FFFF, 0, 0, 468},
+ Package() {0x0007FFFF, 1, 0, 469},
+ Package() {0x0007FFFF, 2, 0, 470},
+ Package() {0x0007FFFF, 3, 0, 471},
+ Package() {0x0008FFFF, 0, 0, 468},
+ Package() {0x0008FFFF, 1, 0, 469},
+ Package() {0x0008FFFF, 2, 0, 470},
+ Package() {0x0008FFFF, 3, 0, 471},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x67FFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000048000000, // AddressMinimum - MIN
+ 0x000000004FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000640000000000, // AddressMinimum - MIN
+ 0x000067FFDFFFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCID RCB1
+
+ // PCIE RCB2
+ Device (PCIE) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 10)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCIE")
+ Name (_STR, Unicode("PCIe 14 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 152/153/154/155 + 320 respectively. PCIE RCB2
+ //
+ Package() {0x0001FFFF, 0, 0, 472},
+ Package() {0x0001FFFF, 1, 0, 473},
+ Package() {0x0001FFFF, 2, 0, 474},
+ Package() {0x0001FFFF, 3, 0, 475},
+ Package() {0x0002FFFF, 0, 0, 472},
+ Package() {0x0002FFFF, 1, 0, 473},
+ Package() {0x0002FFFF, 2, 0, 474},
+ Package() {0x0002FFFF, 3, 0, 475},
+ Package() {0x0003FFFF, 0, 0, 472},
+ Package() {0x0003FFFF, 1, 0, 473},
+ Package() {0x0003FFFF, 2, 0, 474},
+ Package() {0x0003FFFF, 3, 0, 475},
+ Package() {0x0004FFFF, 0, 0, 472},
+ Package() {0x0004FFFF, 1, 0, 473},
+ Package() {0x0004FFFF, 2, 0, 474},
+ Package() {0x0004FFFF, 3, 0, 475},
+ Package() {0x0005FFFF, 0, 0, 472},
+ Package() {0x0005FFFF, 1, 0, 473},
+ Package() {0x0005FFFF, 2, 0, 474},
+ Package() {0x0005FFFF, 3, 0, 475},
+ Package() {0x0006FFFF, 0, 0, 472},
+ Package() {0x0006FFFF, 1, 0, 473},
+ Package() {0x0006FFFF, 2, 0, 474},
+ Package() {0x0006FFFF, 3, 0, 475},
+ Package() {0x0007FFFF, 0, 0, 472},
+ Package() {0x0007FFFF, 1, 0, 473},
+ Package() {0x0007FFFF, 2, 0, 474},
+ Package() {0x0007FFFF, 3, 0, 475},
+ Package() {0x0008FFFF, 0, 0, 472},
+ Package() {0x0008FFFF, 1, 0, 473},
+ Package() {0x0008FFFF, 2, 0, 474},
+ Package() {0x0008FFFF, 3, 0, 475},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x6BFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000050000000, // AddressMinimum - MIN
+ 0x0000000057FFFFFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000680000000000, // AddressMinimum - MIN
+ 0x00006BFFDFFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCIE RCB2
+
+ // PCIF RCB3
+ Device (PCIF) {
+ //
+ // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
+ // Section 6.1.5
+ //
+
+ Name (_HID, "PNP0A08")
+ Name (_CCA, ONE)
+
+ Method (_STA, 0, NotSerialized) {
+ Return (0xF) // The default value is 0x0. Unfortunately, it breaks
+ // run-time patching as the representation of 0 is special
+ // encoding and cannot be patched to expand with extra bytes
+ // easily. As such, we default to 0xF and patch this based
+ // on whether the port was enabled or not by the BIOS.
+ }
+
+ //
+ // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
+ // root complex for use with pre-PCIe operating systems.
+ // Section 6.1.2
+ //
+
+ Name (_CID, "PNP0A03")
+
+ //
+ // Declare the segment number of this root complex. Most systems only
+ // have one segment, which is numbered 0.
+ // Section 6.5.6
+ //
+
+ Name (_SEG, 11)
+
+ //
+ // Declare the base bus number, which is the bus number of the root
+ // bus in this root complex. This is usually 0, but need not be.
+ // For root complexes supporting multiple root busses, this should
+ // be the lowest numbered root bus.
+ // Section 6.5.5
+ //
+
+ Name (_BBN, 0)
+
+ //
+ // The _UID value provides a way of uniquely identifying a device
+ // in the case where more than one instance of a specific device
+ // is implemented with the same _HID/_CID. For systems with a
+ // single root complex, this is usually just 0. For systems with
+ // multiple root complexes, this should be different for each
+ // root complex.
+ // Section 6.1.12
+ //
+
+ Name (_UID, "PCIF")
+ Name (_STR, Unicode("PCIe 15 Device"))
+
+ //
+ // Declare the PCI Routing Table.
+ // This defines SPI mappings of the four line-based interrupts
+ // associated with the root complex and hierarchy below it.
+ // Section 6.2.12
+ //
+
+ Name (_PRT, Package() {
+
+ //
+ // Routing for device 0, all functions.
+ // Note: ARM doesn't support LNK nodes, so the third param
+ // is 0 and the fourth param is the SPI number of the interrupt
+ // line. In this example, the A/B/C/D interrupts are wired to
+ // SPI lines 156/157/158/159 + 320 respectively. PCIF RCB3
+ //
+ Package() {0x0001FFFF, 0, 0, 476},
+ Package() {0x0001FFFF, 1, 0, 477},
+ Package() {0x0001FFFF, 2, 0, 478},
+ Package() {0x0001FFFF, 3, 0, 479},
+ Package() {0x0002FFFF, 0, 0, 476},
+ Package() {0x0002FFFF, 1, 0, 477},
+ Package() {0x0002FFFF, 2, 0, 478},
+ Package() {0x0002FFFF, 3, 0, 479},
+ Package() {0x0003FFFF, 0, 0, 476},
+ Package() {0x0003FFFF, 1, 0, 477},
+ Package() {0x0003FFFF, 2, 0, 478},
+ Package() {0x0003FFFF, 3, 0, 479},
+ Package() {0x0004FFFF, 0, 0, 476},
+ Package() {0x0004FFFF, 1, 0, 477},
+ Package() {0x0004FFFF, 2, 0, 478},
+ Package() {0x0004FFFF, 3, 0, 479},
+ Package() {0x0005FFFF, 0, 0, 476},
+ Package() {0x0005FFFF, 1, 0, 477},
+ Package() {0x0005FFFF, 2, 0, 478},
+ Package() {0x0005FFFF, 3, 0, 479},
+ Package() {0x0006FFFF, 0, 0, 476},
+ Package() {0x0006FFFF, 1, 0, 477},
+ Package() {0x0006FFFF, 2, 0, 478},
+ Package() {0x0006FFFF, 3, 0, 479},
+ Package() {0x0007FFFF, 0, 0, 476},
+ Package() {0x0007FFFF, 1, 0, 477},
+ Package() {0x0007FFFF, 2, 0, 478},
+ Package() {0x0007FFFF, 3, 0, 479},
+ Package() {0x0008FFFF, 0, 0, 476},
+ Package() {0x0008FFFF, 1, 0, 477},
+ Package() {0x0008FFFF, 2, 0, 478},
+ Package() {0x0008FFFF, 3, 0, 479},
+ })
+
+ //
+ // Declare the resources assigned to this root complex.
+ // Section 6.2.2
+ //
+ Method (_CBA, 0, Serialized) {
+ Return (0x6FFFF0000000)
+ }
+
+ //
+ // Declare a ResourceTemplate buffer to return the resource
+ // requirements from _CRS.
+ // Section 19.5.109
+ //
+
+ Name (RBUF, ResourceTemplate () {
+
+ //
+ // Declare the range of bus numbers assigned to this root
+ // complex. In this example, the minimum bus number will be
+ // 0, the maximum bus number will be 0xFF, supporting
+ // 256 busses total.
+ // Section 19.5.141
+ //
+
+ WordBusNumber (
+ ResourceProducer,
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ PosDecode, // Decode
+ 0, // AddressGranularity
+ 0, // AddressMinimum - Minimum Bus Number
+ 255, // AddressMaximum - Maximum Bus Number
+ 0, // AddressTranslation - Set to 0
+ 256) // RangeLength - Number of Busses
+
+ //
+ // Declare the memory range to be used for BAR memory
+ // windows. This declares a 4GB region starting at
+ // 0x4000000000.
+ // Section 19.5.80
+ //
+ // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000000058000000, // AddressMinimum - MIN
+ 0x000000005FFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000008000000 // RangeLength - LEN
+ )
+
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // NonCacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x00006C0000000000, // AddressMinimum - MIN
+ 0x00006FFFDFFFFFFF, // AddressMinimum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x000003FFE0000000 // RangeLength - LEN
+ )
+ })
+
+ Method (_CRS, 0, Serialized) {
+ Return (RBUF)
+ }
+
+ //
+ // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
+ //
+ // Argments:
+ // Arg0 A Buffer containing a UUID
+ // Arg1 An Integer containing a Revision ID of the buffer format
+ // Arg2 An Integer containing a count of entries in Arg3
+ // Arg3 A Buffer containing a list of DWORD capabilities
+ // Return Value:
+ // A Buffer containing a list of capabilities
+ // See the APCI spec, Section 6.2.10,
+ // and the PCI FW spec, Section 4.5.
+ //
+ // The following is an example, and may need modification for
+ // specific implementations.
+ //
+
+ Name (SUPP,0) // PCI _OSC Support Field value
+ Name (CTRL,0) // PCI _OSC Control Field value
+
+ Method (_OSC, 4) {
+
+ //
+ // Look for the PCI Host Bridge Interface UUID.
+ // Section 6.2.10.3
+ //
+
+ //
+ // Create DWord-adressable fields from the Capabilities Buffer
+ // Create CDW1 outside the test as it's used in the else clause.
+ //
+
+ CreateDWordField (Arg3, 0, CDW1)
+ If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
+
+ CreateDWordField (Arg3, 4, CDW2)
+ CreateDWordField (Arg3, 8, CDW3)
+
+ //
+ // Save Capabilities DWord 2 & 3
+ //
+
+ Store (CDW2, SUPP)
+ Store (CDW3, CTRL)
+
+ //
+ // Only allow native hot plug control if OS supports:
+ // ASPM
+ // Clock PM
+ // MSI/MSI-X
+ //
+
+ If (LNotEqual (And (SUPP, 0x16), 0x16)) {
+
+ //
+ // Mask bit 0 (and undefined bits)
+ //
+
+ And (CTRL, 0x1E, CTRL)
+ }
+
+ //
+ // Never allow native Hot plug, PME.
+ // Never allow SHPC (no SHPC controller in this system).
+ // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
+ // Allows PCI Express Capability Structure control
+ //
+
+ If (AERF) {
+ And (CTRL, 0x10, CTRL)
+ } Else {
+ And (CTRL, 0x18, CTRL)
+ }
+
+ //
+ // Check for unknown revision.
+ //
+
+ If (LNotEqual (Arg1, One)) {
+ Or (CDW1, 0x08, CDW1)
+ }
+
+ //
+ // Check if capabilities bits were masked.
+ //
+
+ If (LNotEqual (CDW3, CTRL)) {
+ Or (CDW1, 0x10, CDW1)
+ }
+
+ //
+ // Update DWORD3 in the buffer.
+ //
+
+ Store (CTRL, CDW3)
+ Return (Arg3)
+
+ } Else {
+
+ //
+ // Unrecognized UUID
+ //
+
+ Or (CDW1, 4, CDW1)
+ Return (Arg3)
+ }
+ } // End _OSC
+
+ //
+ // Declare a _DSM method for various functions called by the OS.
+ // See the APCI spec, Section 9.14.1,
+ // and the PCI FW spec, Section 4.6.
+ // See also:
+ // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
+ //
+
+ Method (_DSM, 0x4, Serialized) {
+
+ //
+ // Match against the _DSM PCI GUID.
+ //
+
+ If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
+
+ Switch (ToInteger(Arg2)) {
+ //
+ // Function 0: Return supported functions as a bitfield
+ // with one bit for each supported function.
+ // Bit 0 must always be set, as that represents
+ // function 0 (which is what is being called here).
+ // Support for different functions may depend on
+ // the revision ID of the interface, passed as Arg1.
+ //
+
+ Case (0) {
+
+ //
+ // Functions 0-7 are supported.
+ //
+
+ Return (Buffer() {0x01})
+ }
+ }
+ }
+
+ //
+ // If not one of the function identifiers we recognize, then return a buffer
+ // with bit 0 set to 0 indicating no functions supported.
+ //
+
+ Return (Buffer() {0})
+ }
+
+ //
+ // Root Port 0 Device within the Root Complex.
+ //
+ Device (RP0) {
+ //
+ // Device 0, Function 0.
+ //
+
+ Name (_ADR, 0x00000000)
+ }
+
+ Method (_PXM, 0, NotSerialized) {
+ // Patch by code
+ Return(0xFF)
+ }
+ } // PCIF RCB3
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
new file mode 100755
index 000000000000..0e9db557d925
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
@@ -0,0 +1,1303 @@
+/** @file
+
+ Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Device(CMN0) {
+ Name(_HID, "ARMHC600") // Device Identification Objects
+ Name(_CID, "ARMHC600")
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("CMN0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceConsumer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000100010000000, // AddressMinimum - MIN
+ 0x000010001fffffff, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+ QWordMemory (
+ ResourceConsumer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000100012500000, // AddressMinimum - MIN
+ 0x00001000164fffff, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000004000000 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 314 }
+ })
+}
+
+Device(MC00) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008C000A00, // AddressMinimum - MIN
+ 0x000010008C000BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC01) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 1)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008C400A00, // AddressMinimum - MIN
+ 0x000010008C400BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC02) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 2)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU2"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008C800A00, // AddressMinimum - MIN
+ 0x000010008C800BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC03) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 3)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU3"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008CC00A00, // AddressMinimum - MIN
+ 0x000010008CC00BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC04) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 4)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU4"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008D000A00, // AddressMinimum - MIN
+ 0x000010008D000BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC05) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 5)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU5"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008D400A00, // AddressMinimum - MIN
+ 0x000010008D400BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC06) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 6)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU6"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008D800A00, // AddressMinimum - MIN
+ 0x000010008D800BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(MC07) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 7)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 0: MCU7"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000010008DC00A00, // AddressMinimum - MIN
+ 0x000010008DC00BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
+ })
+}
+
+Device(DU00) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 64 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x000000,
+ 0x000100
+ }
+ }
+ }
+ })
+}
+
+Device(DU01) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 65 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x010000,
+ 0x010100
+ }
+ }
+ }
+ })
+}
+
+Device(DU02) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x2)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x2 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 66 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x020000,
+ 0x020100
+ }
+ }
+ }
+ })
+}
+
+Device(DU03) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x3)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x3 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 67 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x030000,
+ 0x030100
+ }
+ }
+ }
+ })
+}
+
+Device(DU04) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 68 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x040000,
+ 0x040100
+ }
+ }
+ }
+ })
+}
+
+Device(DU05) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 69 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x050000,
+ 0x050100
+ }
+ }
+ }
+ })
+}
+
+Device(DU06) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x6)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x6 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 71 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x060000,
+ 0x060100
+ }
+ }
+ }
+ })
+}
+
+Device(DU07) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x7)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x7 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 80 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x070000,
+ 0x070100
+ }
+ }
+ }
+ })
+}
+
+Device(DU08) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x8)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x8 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 81 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x080000,
+ 0x080100
+ }
+ }
+ }
+ })
+}
+
+Device(DU09) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x9)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x9 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 82 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x090000,
+ 0x090100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0A) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xA)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xA Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 83 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0A0000,
+ 0x0A0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0B) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xB)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xB Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 115 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0B0000,
+ 0x0B0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0C) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xC)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xC Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 116 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0C0000,
+ 0x0C0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0D) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xD)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xD Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 221 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0D0000,
+ 0x0D0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0E) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xE)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xE Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 222 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0E0000,
+ 0x0E0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU0F) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0xF)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0xF Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 223 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x0F0000,
+ 0x0F0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU10) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x10)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x10 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 248 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100000,
+ 0x100100
+ }
+ }
+ }
+ })
+}
+
+Device(DU11) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x11)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x11 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 249 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x110000,
+ 0x110100
+ }
+ }
+ }
+ })
+}
+
+Device(DU12) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x12)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x12 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 250 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x120000,
+ 0x120100
+ }
+ }
+ }
+ })
+}
+
+Device(DU13) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x13)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x13 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 251 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x130000,
+ 0x130100
+ }
+ }
+ }
+ })
+}
+
+Device(DU14) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x14)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x14 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 252 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x140000,
+ 0x140100
+ }
+ }
+ }
+ })
+}
+
+Device(DU15) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x15)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x15 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 253 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x150000,
+ 0x150100
+ }
+ }
+ }
+ })
+}
+
+Device(DU16) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x16)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x16 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 254 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x160000,
+ 0x160100
+ }
+ }
+ }
+ })
+}
+
+Device(DU17) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x17)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x17 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 255 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x170000,
+ 0x170100
+ }
+ }
+ }
+ })
+}
+
+Device(DU18) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x18)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x18 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 297 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x180000,
+ 0x180100
+ }
+ }
+ }
+ })
+}
+
+Device(DU19) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x19)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x19 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 298 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x190000,
+ 0x190100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1A) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1A)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1A Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 299 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1A0000,
+ 0x1A0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1B) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1B)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1B Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 300 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1B0000,
+ 0x1B0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1C) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1C)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1C Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 301 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1C0000,
+ 0x1C0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1D) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1D)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1D Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 313 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1D0000,
+ 0x1D0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1E) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1E)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1E Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 316 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1E0000,
+ 0x1E0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU1F) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x1F)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x1F Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 317 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1F0000,
+ 0x1F0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU20) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x20)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x20 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 318 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x200000,
+ 0x200100
+ }
+ }
+ }
+ })
+}
+
+Device(DU21) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x21)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x21 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 319 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x210000,
+ 0x210100
+ }
+ }
+ }
+ })
+}
+
+Device(DU22) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x22)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x22 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 344 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x220000,
+ 0x220100
+ }
+ }
+ }
+ })
+}
+
+Device(DU23) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x23)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x23 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 345 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x230000,
+ 0x230100
+ }
+ }
+ }
+ })
+}
+
+Device(DU24) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x24)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x24 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 346 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x240000,
+ 0x240100
+ }
+ }
+ }
+ })
+}
+
+Device(DU25) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x25)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x25 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 347 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x250000,
+ 0x250100
+ }
+ }
+ }
+ })
+}
+
+Device(DU26) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x26)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x26 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 348 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x260000,
+ 0x260100
+ }
+ }
+ }
+ })
+}
+
+Device(DU27) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x27)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x27 Socket 0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 349 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x270000,
+ 0x270100
+ }
+ }
+ }
+ })
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
new file mode 100755
index 000000000000..1ae1bac8098b
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
@@ -0,0 +1,1303 @@
+/** @file
+
+ Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Device(CMN1) {
+ Name(_HID, "ARMHC600") // Device Identification Objects
+ Name(_CID, "ARMHC600")
+ Name(_UID, 1)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("CMN1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceConsumer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000500010000000, // AddressMinimum - MIN
+ 0x000050001fffffff, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000010000000 // RangeLength - LEN
+ )
+ QWordMemory (
+ ResourceConsumer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x0000500012500000, // AddressMinimum - MIN
+ 0x00005000164fffff, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000004000000 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 634 }
+ })
+}
+
+Device(MC10) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 8)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU0"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008C000A00, // AddressMinimum - MIN
+ 0x000050008C000BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC11) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 9)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008C400A00, // AddressMinimum - MIN
+ 0x000050008C400BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC12) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xa)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU2"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008C800A00, // AddressMinimum - MIN
+ 0x000050008C800BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC13) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xb)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU3"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008CC00A00, // AddressMinimum - MIN
+ 0x000050008CC00BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC14) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xc)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU4"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008D000A00, // AddressMinimum - MIN
+ 0x000050008D000BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC15) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xd)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU5"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008D400A00, // AddressMinimum - MIN
+ 0x000050008D400BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC16) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xe)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU6"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008D800A00, // AddressMinimum - MIN
+ 0x000050008D800BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(MC17) {
+ Name(_HID, "ARMHD620")
+ Name(_CID, "ARMHD620")
+ Name(_UID, 0xf)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("Socket 1: MCU7"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ QWordMemory (
+ ResourceProducer, // ResourceUsage
+ PosDecode, // Decode
+ MinFixed, // IsMinFixed
+ MaxFixed, // IsMaxFixed
+ NonCacheable, // Cacheable
+ ReadWrite, // ReadAndWrite
+ 0x0000000000000000, // AddressGranularity - GRA
+ 0x000050008DC00A00, // AddressMinimum - MIN
+ 0x000050008DC00BFF, // AddressMaximum - MAX
+ 0x0000000000000000, // AddressTranslation - TRA
+ 0x0000000000000200 // RangeLength - LEN
+ )
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
+ })
+}
+
+Device(DU40) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x40)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x40 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 384 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100000000,
+ 0x100000100
+ }
+ }
+ }
+ })
+}
+
+Device(DU41) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x41)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x41 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 385 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100010000,
+ 0x100010100
+ }
+ }
+ }
+ })
+}
+
+Device(DU42) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x42)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x42 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 386 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100020000,
+ 0x100020100
+ }
+ }
+ }
+ })
+}
+
+Device(DU43) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x43)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x43 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 387 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100030000,
+ 0x100030100
+ }
+ }
+ }
+ })
+}
+
+Device(DU44) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x44)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x44 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 388 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100040000,
+ 0x100040100
+ }
+ }
+ }
+ })
+}
+
+Device(DU45) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x45)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x45 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 389 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100050000,
+ 0x100050100
+ }
+ }
+ }
+ })
+}
+
+Device(DU46) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x46)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x46 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 391 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100060000,
+ 0x100060100
+ }
+ }
+ }
+ })
+}
+
+Device(DU47) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x47)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x47 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 400 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100070000,
+ 0x100070100
+ }
+ }
+ }
+ })
+}
+
+Device(DU48) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x48)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x48 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 401 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100080000,
+ 0x100080100
+ }
+ }
+ }
+ })
+}
+
+Device(DU49) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x49)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x49 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 402 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100090000,
+ 0x100090100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4A) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4A)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4A Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 403 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000A0000,
+ 0x1000A0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4B) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4B)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4B Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 435 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000B0000,
+ 0x1000B0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4C) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4C)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4C Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 436 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000C0000,
+ 0x1000C0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4D) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4D)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4D Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 541 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000D0000,
+ 0x1000D0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4E) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4E)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4E Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 542 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000E0000,
+ 0x1000E0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU4F) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x4F)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x4F Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 543 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1000F0000,
+ 0x1000F0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU50) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x50)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x50 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 568 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100100000,
+ 0x100100100
+ }
+ }
+ }
+ })
+}
+
+Device(DU51) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x51)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x51 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 569 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100110000,
+ 0x100110100
+ }
+ }
+ }
+ })
+}
+
+Device(DU52) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x52)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x52 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 570 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100120000,
+ 0x100120100
+ }
+ }
+ }
+ })
+}
+
+Device(DU53) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x53)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x53 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 571 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100130000,
+ 0x100130100
+ }
+ }
+ }
+ })
+}
+
+Device(DU54) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x54)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x54 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 572 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100140000,
+ 0x100140100
+ }
+ }
+ }
+ })
+}
+
+Device(DU55) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x55)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x55 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 573 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100150000,
+ 0x100150100
+ }
+ }
+ }
+ })
+}
+
+Device(DU56) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x56)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x56 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 574 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100160000,
+ 0x100160100
+ }
+ }
+ }
+ })
+}
+
+Device(DU57) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x57)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x57 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 575 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100170000,
+ 0x100170100
+ }
+ }
+ }
+ })
+}
+
+Device(DU58) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x58)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x58 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 617 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100180000,
+ 0x100180100
+ }
+ }
+ }
+ })
+}
+
+Device(DU59) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x59)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x59 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 618 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100190000,
+ 0x100190100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5A) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5A)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5A Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 619 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001A0000,
+ 0x1001A0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5B) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5B)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5B Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 620 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001B0000,
+ 0x1001B0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5C) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5C)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5C Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 621 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001C0000,
+ 0x1001C0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5D) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5D)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5D Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 633 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001D0000,
+ 0x1001D0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5E) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5E)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5E Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 636 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001E0000,
+ 0x1001E0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU5F) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x5F)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x5F Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 637 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x1001F0000,
+ 0x1001F0100
+ }
+ }
+ }
+ })
+}
+
+Device(DU60) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x60)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x60 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 638 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100200000,
+ 0x100200100
+ }
+ }
+ }
+ })
+}
+
+Device(DU61) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x61)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x61 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 639 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100210000,
+ 0x100210100
+ }
+ }
+ }
+ })
+}
+
+Device(DU62) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x62)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x62 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 664 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100220000,
+ 0x100220100
+ }
+ }
+ }
+ })
+}
+
+Device(DU63) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x63)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x63 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 665 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100230000,
+ 0x100230100
+ }
+ }
+ }
+ })
+}
+
+Device(DU64) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x64)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x64 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 666 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100240000,
+ 0x100240100
+ }
+ }
+ }
+ })
+}
+
+Device(DU65) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x65)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x65 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 667 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100250000,
+ 0x100250100
+ }
+ }
+ }
+ })
+}
+
+Device(DU66) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x66)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x66 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 668 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100260000,
+ 0x100260100
+ }
+ }
+ }
+ })
+}
+
+Device(DU67) {
+ Name(_HID, "ARMHD500")
+ Name(_CID, "ARMHD500")
+ Name(_UID, 0x67)
+ Name(_CCA, ONE)
+ Name(_STR, Unicode("DSU CPM 0x67 Socket 1"))
+ Method(_STA, 0, NotSerialized) {
+ Return (0x0f)
+ }
+ Name(_CRS, ResourceTemplate() {
+ Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 669 }
+ })
+ Name (_DSD, Package () {
+ ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
+ Package () {
+ Package (2) {
+ "cpus",
+ Package (2) {
+ 0x100270000,
+ 0x100270100
+ }
+ }
+ }
+ })
+}
diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
new file mode 100644
index 000000000000..0d177de8696d
--- /dev/null
+++ b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
@@ -0,0 +1,10 @@
+/** @file
+
+ Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+Include ("PMU-S0.asi")
+Include ("PMU-S1.asi")
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
new file mode 100644
index 000000000000..a80f1e81b24f
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
@@ -0,0 +1,33 @@
+/** @file
+
+ Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <IndustryStandard/Acpi.h>
+#include <AcpiHeader.h>
+
+#define BOOT_ERROR_REGION_LENGTH 0x50000
+#define BOOT_ERROR_REGION_BASE 0x0000000088230000
+
+#pragma pack(1)
+
+EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER Bert = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE,
+ EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER,
+ EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_REVISION
+ ),
+ BOOT_ERROR_REGION_LENGTH,
+ BOOT_ERROR_REGION_BASE
+};
+
+#pragma pack()
+
+//
+// Reference the table being generated to prevent the optimizer from removing
+// the data structure from the executable
+//
+VOID* CONST ReferenceAcpiTable = &Bert;
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
new file mode 100644
index 000000000000..bc2bbded11fd
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
@@ -0,0 +1,87 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/AcpiLib.h>
+#include <Library/ArmLib.h>
+#include <Library/PcdLib.h>
+#include <IndustryStandard/Acpi.h>
+#include <IndustryStandard/DebugPort2Table.h>
+#include <AcpiHeader.h>
+
+#pragma pack(1)
+
+#define DBG2_NUM_DEBUG_PORTS 1
+#define DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS 1
+#define DBG2_NAMESPACESTRING_FIELD_SIZE 10
+#define SERIAL_PORT_PL011_UART_ADDR_SIZE 0x8
+
+#define NAME_STR_UART2 {'\\', '_', 'S', 'B', '.', 'U', 'R', 'T', '2', '\0'}
+
+typedef struct {
+ EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT Dbg2Device;
+ EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister;
+ UINT32 AddressSize;
+ UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE];
+} DBG2_DEBUG_DEVICE_INFORMATION;
+
+typedef struct {
+ EFI_ACPI_DEBUG_PORT_2_DESCRIPTION_TABLE Description;
+ DBG2_DEBUG_DEVICE_INFORMATION Dbg2DeviceInfo[DBG2_NUM_DEBUG_PORTS];
+} DBG2_TABLE;
+
+
+#define DBG2_DEBUG_PORT_DDI(NumReg, SubType, UartBase, UartAddrLen, UartNameStr) { \
+ { \
+ EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION, /* UINT8 Revision */ \
+ sizeof (DBG2_DEBUG_DEVICE_INFORMATION), /* UINT16 Length */ \
+ NumReg, /* UINT8 NumberofGenericAddressRegisters */ \
+ DBG2_NAMESPACESTRING_FIELD_SIZE, /* UINT16 NameSpaceStringLength */ \
+ OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, NameSpaceString), /* UINT16 NameSpaceStringOffset */ \
+ 0, /* UINT16 OemDataLength */ \
+ 0, /* UINT16 OemDataOffset */ \
+ EFI_ACPI_DBG2_PORT_TYPE_SERIAL, /* UINT16 Port Type */ \
+ SubType, /* UINT16 Port Subtype */ \
+ {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}, /* UINT8 Reserved[2] */ \
+ OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, BaseAddressRegister), /* UINT16 BaseAddressRegister Offset */ \
+ OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, AddressSize) /* UINT16 AddressSize Offset */ \
+ }, \
+ ARM_GAS32 (UartBase), /* EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister */ \
+ UartAddrLen, /* UINT32 AddressSize */ \
+ UartNameStr /* UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE] */ \
+ }
+
+
+STATIC DBG2_TABLE Dbg2 = {
+ {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_DEBUG_PORT_2_TABLE_SIGNATURE,
+ DBG2_TABLE,
+ EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION
+ ),
+ OFFSET_OF (DBG2_TABLE, Dbg2DeviceInfo),
+ DBG2_NUM_DEBUG_PORTS /* UINT32 NumberDbgDeviceInfo */
+ },
+ {
+ // Kernel Debug Port
+ DBG2_DEBUG_PORT_DDI (
+ DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS,
+ EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_SBSA_GENERIC_UART,
+ FixedPcdGet64 (PcdSerialDbgRegisterBase),
+ SERIAL_PORT_PL011_UART_ADDR_SIZE,
+ NAME_STR_UART2
+ ),
+ }
+};
+
+#pragma pack()
+
+//
+// Reference the table being generated to prevent the optimizer from removing
+// the data structure from the executable
+//
+VOID* CONST ReferenceAcpiTable = &Dbg2;
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
new file mode 100755
index 000000000000..9607b2e403e0
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
@@ -0,0 +1,165 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+[0004] Signature : "EINJ" [Error Injection table]
+[0004] Table Length : 00000150
+[0001] Revision : 01
+[0001] Checksum : 09
+[0006] Oem ID : "Ampere"
+[0008] Oem Table ID : "Altra "
+[0004] Oem Revision : 00000001
+[0004] Asl Compiler ID : "INTL"
+[0004] Asl Compiler Revision : 20100528
+
+[0004] Injection Header Length : 00000030
+[0001] Flags : 00
+[0003] Reserved : 000000
+[0004] Injection Entry Count : 00000009
+
+[0001] Action : 00 [Begin Operation]
+[0001] Instruction : 00 [Read Register]
+[0001] Flags (decoded below) : 00
+ Preserve Register Bits : 0
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088220000
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 01 [Get Trigger Table]
+[0001] Instruction : 00 [Read Register]
+[0001] Flags (decoded below) : 00
+ Preserve Register Bits : 0
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088220040
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 08 [Set Error Type With Address]
+[0001] Instruction : 02 [Write Register]
+[0001] Flags (decoded below) : 01
+ Preserve Register Bits : 1
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 20
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 03 [DWord Access:32]
+[0008] Address : 0000000088221000
+
+[0008] Value : 00000000
+[0008] Mask : FFFFFFFF
+
+[0001] Action : 02 [Set Error Type]
+[0001] Instruction : 02 [Write Register]
+[0001] Flags (decoded below) : 01
+ Preserve Register Bits : 1
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 20
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [DWord Access:64]
+[0008] Address : 0000000088220080
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 03 [Get Error Type]
+[0001] Instruction : 00 [Read Register]
+[0001] Flags (decoded below) : 00
+ Preserve Register Bits : 0
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 00000000882200c0
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 04 [End Operation]
+[0001] Instruction : 03 [Write Register Value]
+[0001] Flags (decoded below) : 01
+ Preserve Register Bits : 1
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088220100
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 05 [Execute Operation]
+[0001] Instruction : 03 [Write Register Value]
+[0001] Flags (decoded below) : 01
+ Preserve Register Bits : 1
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 20
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 03 [DWord Access:32]
+[0008] Address : 0000100000543010
+
+[0008] Value : B1A00000
+[0008] Mask : FFFFFFFF
+
+[0001] Action : 06 [Check Busy Status]
+[0001] Instruction : 01 [Read Register Value]
+[0001] Flags (decoded below) : 00
+ Preserve Register Bits : 0
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088220140
+
+[0008] Value : 0000000000000001
+[0008] Mask : FFFFFFFFFFFFFFFF
+
+[0001] Action : 07 [Get Command Status]
+[0001] Instruction : 00 [Read Register]
+[0001] Flags (decoded below) : 01
+ Preserve Register Bits : 1
+[0001] Reserved : 00
+
+[0012] Register Region : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088220180
+
+[0008] Value : 0000000000000000
+[0008] Mask : FFFFFFFFFFFFFFFF
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
new file mode 100644
index 000000000000..5be828f1cdf0
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
@@ -0,0 +1,87 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/AcpiLib.h>
+#include <IndustryStandard/Acpi63.h>
+#include <AcpiHeader.h>
+
+//
+// This macro defines the FADT flag options.
+//
+#define FADT_FLAGS (EFI_ACPI_6_3_HW_REDUCED_ACPI | \
+ EFI_ACPI_6_3_PWR_BUTTON)
+
+
+EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE Fadt = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE,
+ EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE,
+ EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_REVISION
+ ),
+ 0, // UINT32 FirmwareCtrl
+ 0, // UINT32 Dsdt
+ EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved0
+ EFI_ACPI_6_3_PM_PROFILE_PERFORMANCE_SERVER, // UINT8 PreferredPmProfile
+ 0, // UINT16 SciInt
+ 0, // UINT32 SmiCmd
+ 0, // UINT8 AcpiEnable
+ 0, // UINT8 AcpiDisable
+ 0, // UINT8 S4BiosReq
+ 0, // UINT8 PstateCnt
+ 0, // UINT32 Pm1aEvtBlk
+ 0, // UINT32 Pm1bEvtBlk
+ 0, // UINT32 Pm1aCntBlk
+ 0, // UINT32 Pm1bCntBlk
+ 0, // UINT32 Pm2CntBlk
+ 0, // UINT32 PmTmrBlk
+ 0, // UINT32 Gpe0Blk
+ 0, // UINT32 Gpe1Blk
+ 0, // UINT8 Pm1EvtLen
+ 0, // UINT8 Pm1CntLen
+ 0, // UINT8 Pm2CntLen
+ 0, // UINT8 PmTmrLen
+ 0, // UINT8 Gpe0BlkLen
+ 0, // UINT8 Gpe1BlkLen
+ 0, // UINT8 Gpe1Base
+ 0, // UINT8 CstCnt
+ 0, // UINT16 PLvl2Lat
+ 0, // UINT16 PLvl3Lat
+ 0, // UINT16 FlushSize
+ 0, // UINT16 FlushStride
+ 0, // UINT8 DutyOffset
+ 0, // UINT8 DutyWidth
+ 0, // UINT8 DayAlrm
+ 0, // UINT8 MonAlrm
+ 0, // UINT8 Century
+ 0, // UINT16 IaPcBootArch
+ 0, // UINT8 Reserved1
+ FADT_FLAGS, // UINT32 Flags
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE ResetReg
+ 0, // UINT8 ResetValue
+ EFI_ACPI_6_3_ARM_PSCI_COMPLIANT, // UINT16 ArmBootArchFlags
+ EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION, // UINT8 MinorRevision
+ 0, // UINT64 XFirmwareCtrl
+ 0, // UINT64 XDsdt
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aEvtBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bEvtBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aCntBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bCntBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm2CntBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPmTmrBlk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe0Blk
+ NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe1Blk
+ ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepControlReg
+ ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepStatusReg
+ 0 // UINT64 HypervisorVendorIdentity
+};
+
+//
+// Reference the table being generated to prevent the optimizer from removing the
+// data structure from the executable
+//
+VOID* CONST ReferenceAcpiTable = &Fadt;
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
new file mode 100644
index 000000000000..3824bd6bb956
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
@@ -0,0 +1,180 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/PcdLib.h>
+#include <Library/AcpiLib.h>
+#include <IndustryStandard/Acpi63.h>
+#include <AcpiHeader.h>
+
+#define SYSTEM_TIMER_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
+#define CNT_READ_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
+
+#define SECURE_TIMER_EL1_GSIV 0x1D
+#define NON_SECURE_TIMER_EL1_GSIV 0x1E
+#define VIRTUAL_TIMER_GSIV 0x1B
+#define NON_SECURE_EL2_GSIV 0x1A
+
+#define GTDT_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE
+#define GTDT_TIMER_LEVEL_TRIGGERED 0
+#define GTDT_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
+#define GTDT_TIMER_ACTIVE_HIGH 0
+#define GTDT_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY
+#define GTDT_TIMER_LOSE_CONTEXT 0
+
+#define GTDT_GTIMER_FLAGS (GTDT_TIMER_LOSE_CONTEXT | GTDT_TIMER_ACTIVE_HIGH | GTDT_TIMER_LEVEL_TRIGGERED)
+
+#define WATCHDOG_COUNT FixedPcdGet32 (PcdWatchdogCount)
+#define PLATFORM_TIMER_COUNT (WATCHDOG_COUNT + 1)
+#define TIMER_FRAMES_COUNT 3
+
+#define GT_BLOCK_CTL_BASE 0x0000100002700000
+#define GT_BLOCK_FRAME0_CTL_BASE 0x0000100002710000
+#define GT_BLOCK_FRAME0_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
+#define GT_BLOCK_FRAME0_GSIV 0x58
+
+#define GT_BLOCK_FRAME1_CTL_BASE 0x0000100002720000
+#define GT_BLOCK_FRAME1_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
+#define GT_BLOCK_FRAME1_GSIV 0x59
+
+#define GT_BLOCK_FRAME2_CTL_BASE 0x0000100002730000
+#define GT_BLOCK_FRAME2_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
+#define GT_BLOCK_FRAME2_GSIV 0x5A
+
+#define GTX_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE
+#define GTX_TIMER_LEVEL_TRIGGERED 0
+#define GTX_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
+#define GTX_TIMER_ACTIVE_HIGH 0
+
+#define GTX_TIMER_FLAGS (GTX_TIMER_ACTIVE_HIGH | GTX_TIMER_LEVEL_TRIGGERED)
+
+#define GTX_TIMER_SECURE EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER
+#define GTX_TIMER_NON_SECURE 0
+#define GTX_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY
+#define GTX_TIMER_LOSE_CONTEXT 0
+
+#define GTX_COMMON_FLAGS_S (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_SECURE)
+#define GTX_COMMON_FLAGS_NS (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_NON_SECURE)
+
+#define SBSA_WATCHDOG_REFRESH_BASE 0x00001000027D0000
+#define SBSA_WATCHDOG_CONTROL_BASE 0x00001000027C0000
+#define SBSA_WATCHDOG_GSIV 0x5C
+
+#define SBSA_WATCHDOG_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE
+#define SBSA_WATCHDOG_LEVEL_TRIGGERED 0
+#define SBSA_WATCHDOG_ACTIVE_LOW EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY
+#define SBSA_WATCHDOG_ACTIVE_HIGH 0
+#define SBSA_WATCHDOG_SECURE EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER
+#define SBSA_WATCHDOG_NON_SECURE 0
+
+#define SBSA_WATCHDOG_FLAGS (SBSA_WATCHDOG_NON_SECURE | SBSA_WATCHDOG_ACTIVE_HIGH | SBSA_WATCHDOG_LEVEL_TRIGGERED)
+
+#pragma pack (1)
+
+typedef struct {
+ EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE Gtdt;
+ EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE GtBlock;
+ EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE Frames[TIMER_FRAMES_COUNT];
+#if (WATCHDOG_COUNT != 0)
+ EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE Watchdogs[WATCHDOG_COUNT];
+#endif
+} EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES;
+
+#pragma pack ()
+
+EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES Gtdt = {
+ {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE,
+ EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES,
+ EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION
+ ),
+ SYSTEM_TIMER_BASE_ADDRESS, // UINT64 CntControlBasePhysicalAddress
+ EFI_ACPI_RESERVED_DWORD, // UINT32 Reserved
+ SECURE_TIMER_EL1_GSIV, // UINT32 SecurePL1TimerGSIV
+ GTDT_GTIMER_FLAGS, // UINT32 SecurePL1TimerFlags
+ NON_SECURE_TIMER_EL1_GSIV, // UINT32 NonSecurePL1TimerGSIV
+ GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL1TimerFlags
+ VIRTUAL_TIMER_GSIV, // UINT32 VirtualTimerGSIV
+ GTDT_GTIMER_FLAGS, // UINT32 VirtualTimerFlags
+ NON_SECURE_EL2_GSIV, // UINT32 NonSecurePL2TimerGSIV
+ GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL2TimerFlags
+ CNT_READ_BASE_ADDRESS, // UINT64 CntReadBasePhysicalAddress
+ PLATFORM_TIMER_COUNT, // UINT32 PlatformTimerCount
+ sizeof (EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE), // UINT32 PlatformTimerOffset
+ },
+ {
+ EFI_ACPI_6_3_GTDT_GT_BLOCK, // UINT8 Type
+ sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT16 Length
+ + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE) *
+ TIMER_FRAMES_COUNT,
+ EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
+ GT_BLOCK_CTL_BASE, // UINT64 CntCtlBase
+ TIMER_FRAMES_COUNT, // UINT32 GTBlockTimerCount
+ sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT32 GTBlockTimerOffset
+ },
+ {
+ {
+ 0, // UINT8 GTFrameNumber
+ {EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
+ GT_BLOCK_FRAME0_CTL_BASE, // UINT64 CntBaseX
+ GT_BLOCK_FRAME0_CTL_EL0_BASE, // UINT64 CntEL0BaseX
+ GT_BLOCK_FRAME0_GSIV, // UINT32 GTxPhysicalTimerGSIV
+ GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
+ 0, // UINT32 GTxVirtualTimerGSIV
+ 0, // UINT32 GTxVirtualTimerFlags
+ GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
+ },
+ {
+ 1, // UINT8 GTFrameNumber
+ {EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
+ GT_BLOCK_FRAME1_CTL_BASE, // UINT64 CntBaseX
+ GT_BLOCK_FRAME1_CTL_EL0_BASE, // UINT64 CntEL0BaseX
+ GT_BLOCK_FRAME1_GSIV, // UINT32 GTxPhysicalTimerGSIV
+ GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
+ 0, // UINT32 GTxVirtualTimerGSIV
+ 0, // UINT32 GTxVirtualTimerFlags
+ GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
+ },
+ {
+ 2, // UINT8 GTFrameNumber
+ {EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
+ GT_BLOCK_FRAME2_CTL_BASE, // UINT64 CntBaseX
+ GT_BLOCK_FRAME2_CTL_EL0_BASE, // UINT64 CntEL0BaseX
+ GT_BLOCK_FRAME2_GSIV, // UINT32 GTxPhysicalTimerGSIV
+ GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
+ 0, // UINT32 GTxVirtualTimerGSIV
+ 0, // UINT32 GTxVirtualTimerFlags
+ GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
+ },
+ },
+#if (WATCHDOG_COUNT != 0)
+ {
+ {
+ EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG, // UINT8 Type
+ sizeof(EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE), // UINT16 Length
+ EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
+ SBSA_WATCHDOG_REFRESH_BASE, // UINT64 RefreshFramePhysicalAddress
+ SBSA_WATCHDOG_CONTROL_BASE, // UINT64 WatchdogControlFramePhysicalAddress
+ SBSA_WATCHDOG_GSIV, // UINT32 WatchdogTimerGSIV
+ SBSA_WATCHDOG_FLAGS // UINT32 WatchdogTimerFlags
+ }
+ }
+#endif
+};
+
+//
+// Reference the table being generated to prevent the optimizer from removing the
+// data structure from the executable
+//
+VOID* CONST ReferenceAcpiTable = &Gtdt;
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
new file mode 100644
index 000000000000..4413428719b8
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
@@ -0,0 +1,330 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+[0004] Signature : "HEST" [Hardware Error Source Table]
+[0004] Table Length : 00000308
+[0001] Revision : 01
+[0001] Checksum : 20
+[0006] Oem ID : "Ampere"
+[0008] Oem Table ID : "Altra "
+[0004] Oem Revision : 00000001
+[0004] Asl Compiler ID : "INTL"
+[0004] Asl Compiler Revision : 20100528
+
+[0004] Error Source Count : 00000008
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0000
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200000
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000100000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1D00000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0001
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200008
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 00 [Polled]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000100000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1C00000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0002
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200010
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000100000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1F00000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0006
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200030
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000100000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1900000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0007
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200038
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000100000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1900001
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0003
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200018
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000500000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1D00000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0004
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200020
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 00 [Polled]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000500000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1C00000
+
+[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
+[0002] Source Id : 0005
+[0002] Related Source Id : FFFF
+[0001] Reserved : 00
+[0001] Enabled : 01
+[0004] Records To Preallocate : 00000001
+[0004] Max Sections Per Record : 00000001
+[0004] Max Raw Data Length : 00001000
+
+[0012] Error Status Address : [Generic Address Structure]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000000088200028
+
+[0028] Notify : [Hardware Error Notification Structure]
+[0001] Notify Type : 03 [SCI]
+[0001] Notify Length : 1C
+[0002] Configuration Write Enable : 0000
+[0004] PollInterval : 00000BB8
+[0004] Vector : 00000000
+[0004] Polling Threshold Value : 00000000
+[0004] Polling Threshold Window : 00000000
+[0004] Error Threshold Value : 00000000
+[0004] Error Threshold Window : 00000000
+
+[0004] Error Status Block Length : 00001000
+
+[0012] Read Ack Register : [Generic Address Structure v2]
+[0001] Space ID : 00 [SystemMemory]
+[0001] Bit Width : 40
+[0001] Bit Offset : 00
+[0001] Encoded Access Width : 04 [QWord Access:64]
+[0008] Address : 0000500000543010
+
+[0008] Read Ack Preserve : 00000000
+[0008] Read Ack Write : B1F00000
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
new file mode 100644
index 000000000000..3c0a048552cf
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
@@ -0,0 +1,17 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+[0004] Signature : "SDEI"
+[0004] Table Length : 0000003E
+[0001] Revision : 01
+[0001] Checksum : 59
+[0006] Oem ID : "Ampere"
+[0008] Oem Table ID : "Altra "
+[0004] Oem Revision : 00000001
+[0004] Asl Compiler ID : "INTL"
+[0004] Asl Compiler Revision : 20160930
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
new file mode 100644
index 000000000000..42042f8a3474
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
@@ -0,0 +1,81 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/PcdLib.h>
+#include <Library/AcpiLib.h>
+#include <IndustryStandard/Acpi63.h>
+#include <IndustryStandard/SerialPortConsoleRedirectionTable.h>
+#include <AcpiHeader.h>
+
+STATIC EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE Spcr = {
+ __ACPI_HEADER (
+ EFI_ACPI_6_3_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE,
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE,
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_REVISION
+ ),
+ // UINT8 InterfaceType;
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_PL011_UART,
+ // UINT8 Reserved1[3];
+ {
+ EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE,
+ EFI_ACPI_RESERVED_BYTE
+ },
+ // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddress;
+ ARM_GAS32 (FixedPcdGet64 (PcdSerialRegisterBase)),
+ // UINT8 InterruptType;
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_GIC,
+ // UINT8 Irq;
+ 0, // Not used on ARM
+ // UINT32 GlobalSystemInterrupt;
+ FixedPcdGet32 (PL011UartInterrupt),
+ // UINT8 BaudRate;
+#if (FixedPcdGet64 (PcdUartDefaultBaudRate) == 9600)
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_9600,
+#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 19200)
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_19200,
+#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 57600)
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_57600,
+#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 115200)
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_115200,
+#else
+#error Unsupported SPCR Baud Rate
+#endif
+ // UINT8 Parity;
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_PARITY_NO_PARITY,
+ // UINT8 StopBits;
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_STOP_BITS_1,
+ // UINT8 FlowControl;
+ 0,
+ // UINT8 TerminalType;
+ EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT_UTF8,
+ // UINT8 Reserved2;
+ EFI_ACPI_RESERVED_BYTE,
+ // UINT16 PciDeviceId;
+ 0xFFFF,
+ // UINT16 PciVendorId;
+ 0xFFFF,
+ // UINT8 PciBusNumber;
+ 0x00,
+ // UINT8 PciDeviceNumber;
+ 0x00,
+ // UINT8 PciFunctionNumber;
+ 0x00,
+ // UINT32 PciFlags;
+ 0x00000000,
+ // UINT8 PciSegment;
+ 0x00,
+ // UINT32 Reserved3;
+ EFI_ACPI_RESERVED_DWORD
+};
+
+//
+// Reference the table being generated to prevent the optimizer from removing the
+// data structure from the executable
+//
+VOID* CONST ReferenceAcpiTable = &Spcr;
diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
new file mode 100755
index 000000000000..cdb4bf5de9bf
--- /dev/null
+++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
@@ -0,0 +1,15 @@
+/** @file
+
+ Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
+
+ SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+DefinitionBlock("Ssdt.aml", "SSDT", 2, "Ampere", "Altra ", 0x00000001)
+{
+ Method (MAIN, 0, NotSerialized)
+ {
+ Return (Zero)
+ }
+}
--
2.17.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#75627): https://edk2.groups.io/g/devel/message/75627
Mute This Topic: https://groups.io/mt/83097115/1787277
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org]
-=-=-=-=-=-=-=-=-=-=-=-
On Wed, May 26, 2021 at 17:07:05 +0700, Nhi Pham wrote:
> Add various ACPI tables for the Mt. Jade platform including: DSDT, SPCR,
> DBG2, GTDT, FACP, SSDT, MADT, PPTT, PCCT, SLIT, SRAT, and NFIT.
>
> Cc: Thang Nguyen <thang@os.amperecomputing.com>
> Cc: Chuong Tran <chuong@os.amperecomputing.com>
> Cc: Phong Vo <phong@os.amperecomputing.com>
> Cc: Leif Lindholm <leif@nuviainc.com>
> Cc: Michael D Kinney <michael.d.kinney@intel.com>
> Cc: Ard Biesheuvel <ardb+tianocore@kernel.org>
> Cc: Nate DeSimone <nathaniel.l.desimone@intel.com>
>
> Signed-off-by: Nhi Pham <nhi@os.amperecomputing.com>
Contents of ACPI tables not reviewed.
Creation modes on many of these files are incorrect (as commented on
cover letter).
Address this, and you can have:
Acked-by: Leif Lindholm <leif@nuviainc.com>
/
Leif
> ---
> Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc | 8 +
> Platform/Ampere/JadePkg/Jade.dsc | 23 +
> Platform/Ampere/JadePkg/Jade.fdf | 8 +
> Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf | 20 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf | 75 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf | 44 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h | 121 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h | 49 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h | 76 +
> Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h | 37 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c | 457 ++
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c | 445 ++
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c | 351 ++
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c | 599 +++
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c | 196 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c | 178 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c | 378 ++
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c | 190 +
> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c | 274 +
> Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi | 5639 ++++++++++++++++++++
> Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi | 5639 ++++++++++++++++++++
> Platform/Ampere/JadePkg/AcpiTables/CPU.asi | 127 +
> Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl | 575 ++
> Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi | 217 +
> Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi | 681 +++
> Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi | 2078 ++++++++
> Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi | 2087 ++++++++
> Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi | 1303 +++++
> Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi | 1303 +++++
> Platform/Ampere/JadePkg/AcpiTables/PMU.asi | 10 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc | 33 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc | 87 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl | 165 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc | 87 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc | 180 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl | 330 ++
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl | 17 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc | 81 +
> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl | 15 +
> 39 files changed, 24183 insertions(+)
>
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
> index 3c47099b8edc..11f50f2f09cd 100755
> --- a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
> +++ b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
> @@ -466,6 +466,14 @@ [PcdsFixedAtBuild.common]
> #
> gEfiMdeModulePkgTokenSpaceGuid.PcdBootManagerMenuFile|{ 0x21, 0xaa, 0x2c, 0x46, 0x14, 0x76, 0x03, 0x45, 0x83, 0x6e, 0x8a, 0xb6, 0xf4, 0x66, 0x23, 0x31 }
>
> + #
> + # ACPI table
> + #
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId|"Ampere"
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId|0x2020206172746C41 # Altra
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId|0x2E504D41 # AMP.
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision|0x01000013
> +
> #
> # Enable strict image permissions for all images. (This applies
> # only to images that were built with >= 4 KB section alignment.)
> diff --git a/Platform/Ampere/JadePkg/Jade.dsc b/Platform/Ampere/JadePkg/Jade.dsc
> index 9b9a5d0bad0f..0f9d0adbd34e 100755
> --- a/Platform/Ampere/JadePkg/Jade.dsc
> +++ b/Platform/Ampere/JadePkg/Jade.dsc
> @@ -81,12 +81,24 @@ [LibraryClasses]
> #
> FailSafeLib|Platform/Ampere/AmperePlatformPkg/Library/FailSafeLib/FailSafeLib.inf
>
> + #
> + # ACPI Libraries
> + #
> + AcpiLib|EmbeddedPkg/Library/AcpiLib/AcpiLib.inf
> + AcpiHelperLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiHelperLib/AcpiHelperLib.inf
> + AcpiPccLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiPccLib/AcpiPccLib.inf
> +
> ################################################################################
> #
> # Specific Platform Pcds
> #
> ################################################################################
> [PcdsFeatureFlag.common]
> + #
> + # Activate AcpiSdtProtocol
> + #
> + gEfiMdeModulePkgTokenSpaceGuid.PcdInstallAcpiSdtProtocol|TRUE
> +
> [PcdsFixedAtBuild.common]
>
> !if $(SECURE_BOOT_ENABLE) == TRUE
> @@ -108,3 +120,14 @@ [Components.common]
> # FailSafe and Watchdog Timer
> #
> Platform/Ampere/AmperePlatformPkg/Drivers/FailSafeDxe/FailSafeDxe.inf
> +
> + #
> + # ACPI
> + #
> + MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf {
> + <PcdsFixedAtBuild>
> + gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2B
> + }
> + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
> + Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
> + Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
> diff --git a/Platform/Ampere/JadePkg/Jade.fdf b/Platform/Ampere/JadePkg/Jade.fdf
> index 375455086d0b..2c6f9fac76fd 100755
> --- a/Platform/Ampere/JadePkg/Jade.fdf
> +++ b/Platform/Ampere/JadePkg/Jade.fdf
> @@ -289,4 +289,12 @@ [FV.FvMain]
> #
> !include NetworkPkg/Network.fdf.inc
>
> + #
> + # ACPI
> + #
> + INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf
> + INF Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
> + INF RuleOverride=ACPITABLE Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
> + INF RuleOverride=ACPITABLE Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
> +
> !include Platform/Ampere/AmperePlatformPkg/FvRules.fdf.inc
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
> new file mode 100644
> index 000000000000..1cf632f8a406
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
> @@ -0,0 +1,20 @@
> +## @file
> +#
> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +#
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> + INF_VERSION = 0x0001001B
> + BASE_NAME = JadeAcpiTables
> + FILE_GUID = 5ADDBC13-8634-480C-9B94-671B7855CDB8
> + MODULE_TYPE = USER_DEFINED
> + VERSION_STRING = 1.0
> +
> +[Sources]
> + Dsdt.asl
> +
> +[Packages]
> + MdePkg/MdePkg.dec
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
> new file mode 100644
> index 000000000000..a1a323eee472
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
> @@ -0,0 +1,75 @@
> +## @file
> +#
> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +#
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> + INF_VERSION = 0x0001001B
> + BASE_NAME = AcpiPlatformDxe
> + FILE_GUID = CDA4ED56-6960-4092-885D-FEF37D29093E
> + MODULE_TYPE = DXE_DRIVER
> + VERSION_STRING = 1.0
> + ENTRY_POINT = AcpiPlatformDxeInitialize
> +
> +[Sources.common]
> + AcpiApei.c
> + AcpiApei.h
> + AcpiDsdt.c
> + AcpiMadt.c
> + AcpiNfit.c
> + AcpiPcct.c
> + AcpiPptt.c
> + AcpiPlatform.h
> + AcpiPlatformDxe.c
> + AcpiSlit.c
> + AcpiSrat.c
> +
> +[Packages]
> + ArmPkg/ArmPkg.dec
> + ArmPlatformPkg/ArmPlatformPkg.dec
> + EmbeddedPkg/EmbeddedPkg.dec
> + MdeModulePkg/MdeModulePkg.dec
> + MdePkg/MdePkg.dec
> + Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
> + Silicon/Ampere/AmpereSiliconPkg/AmpereSiliconPkg.dec
> +
> +[LibraryClasses]
> + AcpiHelperLib
> + AcpiLib
> + AcpiPccLib
> + AmpereCpuLib
> + BaseLib
> + DebugLib
> + FlashLib
> + UefiBootServicesTableLib
> + UefiDriverEntryPoint
> + UefiLib
> + UefiRuntimeServicesTableLib
> +
> +[Pcd]
> + gArmPlatformTokenSpaceGuid.PcdCoreCount
> + gArmPlatformTokenSpaceGuid.PcdClusterCount
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision
> + gAmpereTokenSpaceGuid.PcdPmproDbBaseReg
> + gAmpereTokenSpaceGuid.PcdSmproDbBaseReg
> +
> +[Guids]
> + gArmMpCoreInfoGuid
> + gEfiAcpiTableGuid
> + gEfiEventReadyToBootGuid
> + gPlatformHobGuid
> +
> +[Protocols]
> + gEfiAcpiTableProtocolGuid ## ALWAYS_CONSUMED
> + gEfiAcpiSdtProtocolGuid
> + gEfiPciRootBridgeIoProtocolGuid
> +
> +[Depex]
> + gEfiAcpiTableProtocolGuid
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
> new file mode 100644
> index 000000000000..acc4092c650d
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
> @@ -0,0 +1,44 @@
> +## @file
> +#
> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +#
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +#
> +##
> +
> +[Defines]
> + INF_VERSION = 0x0001001B
> + BASE_NAME = AcpiCommonTables
> + FILE_GUID = CEFA2AEB-357E-4F48-8066-EA950853056E
> + MODULE_TYPE = USER_DEFINED
> + VERSION_STRING = 1.0
> +
> +[Sources]
> + Bert.aslc
> + Dbg2.aslc
> + Einj.asl
> + Fadt.aslc
> + Gtdt.aslc
> + Hest.asl
> + Sdei.asl
> + Spcr.aslc
> + Ssdt.asl
> +
> +[Packages]
> + ArmPkg/ArmPkg.dec
> + ArmPlatformPkg/ArmPlatformPkg.dec
> + EmbeddedPkg/EmbeddedPkg.dec
> + MdeModulePkg/MdeModulePkg.dec
> + MdePkg/MdePkg.dec
> + Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
> +
> +[FixedPcd]
> + gEfiMdeModulePkgTokenSpaceGuid.PcdSerialRegisterBase ## CONSUMES
> + gArmPlatformTokenSpaceGuid.PL011UartInterrupt ## CONSUMES
> + gArmPlatformTokenSpaceGuid.PcdWatchdogCount ## CONSUMES
> +
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision ## CONSUMES
> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision ## CONSUMES
> +
> + gArmPlatformTokenSpaceGuid.PcdSerialDbgRegisterBase ## CONSUMES
> + gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate ## CONSUMES
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
> new file mode 100644
> index 000000000000..c207142459ad
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
> @@ -0,0 +1,121 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef ACPI_APEI_H_
> +#define ACPI_APEI_H_
> +
> +#include <Base.h>
> +#include <IndustryStandard/Acpi63.h>
> +#include <Library/AcpiHelperLib.h>
> +#include <Library/AmpereCpuLib.h>
> +#include <Library/BaseLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UefiBootServicesTableLib.h>
> +#include <Library/UefiRuntimeServicesTableLib.h>
> +#include <Platform/Ac01.h>
> +#include <Protocol/AcpiTable.h>
> +
> +#pragma pack(1)
> +#define BERT_MSG_SIZE 0x2C
> +#define BERT_ERROR_TYPE 0x7F
> +#define BERT_UEFI_FAILURE 5
> +#define RAS_2P_TYPE 0x03
> +#define BERT_DEFAULT_ERROR_SEVERITY 0x1
> +#define GENERIC_ERROR_DATA_REVISION 0x300
> +
> +
> +#define PLAT_CRASH_ITERATOR_SIZE 0x398
> +#define SMPRO_CRASH_SIZE 0x800
> +#define PMPRO_CRASH_SIZE 0x800
> +#define HEST_NUM_ENTRIES_PER_SOC 3
> +
> +#define CURRENT_BERT_VERSION 0x10
> +#define BERT_FLASH_OFFSET 0x91B30000ULL
> +#define BERT_DDR_OFFSET 0x88230000ULL
> +#define BERT_DDR_LENGTH 0x50000
> +
> +typedef struct {
> + UINT8 Type;
> + UINT8 SubType;
> + UINT16 Instance;
> + CHAR8 Msg[BERT_MSG_SIZE];
> +} APEI_BERT_ERROR_DATA;
> +
> +typedef struct {
> + APEI_BERT_ERROR_DATA Vendor;
> + UINT8 BertRev;
> + UINT8 S0PmproRegisters[PMPRO_CRASH_SIZE];
> + UINT8 S0SmproRegisters[SMPRO_CRASH_SIZE];
> + UINT8 S1PmproRegisters[PMPRO_CRASH_SIZE];
> + UINT8 S1SmproRegisters[SMPRO_CRASH_SIZE];
> + UINT8 AtfDump[PLATFORM_CPU_MAX_NUM_CORES * PLAT_CRASH_ITERATOR_SIZE];
> +} APEI_CRASH_DUMP_DATA;
> +
> +typedef struct {
> + EFI_ACPI_6_3_GENERIC_ERROR_STATUS_STRUCTURE Ges;
> + EFI_ACPI_6_3_GENERIC_ERROR_DATA_ENTRY_STRUCTURE Ged;
> + APEI_CRASH_DUMP_DATA Bed;
> +} APEI_CRASH_DUMP_BERT_ERROR;
> +#pragma pack()
> +
> +VOID
> +EFIAPI
> +CreateDefaultBertData (
> + APEI_BERT_ERROR_DATA *Data
> + );
> +
> +VOID
> +EFIAPI
> +WrapBertErrorData (
> + APEI_CRASH_DUMP_BERT_ERROR *WrappedError
> + );
> +
> +VOID
> +EFIAPI
> +PullBertSpinorData (
> + APEI_CRASH_DUMP_DATA *BertErrorData
> + );
> +
> +VOID
> +EFIAPI
> +AdjustBERTRegionLen (
> + UINT32 Len
> + );
> +
> +BOOLEAN
> +EFIAPI
> +IsBertEnabled (
> + VOID
> + );
> +
> +VOID
> +EFIAPI
> +WriteDDRBertTable (
> + APEI_CRASH_DUMP_BERT_ERROR *Data
> + );
> +
> +VOID
> +WriteSpinorDefaultBertTable (
> + APEI_CRASH_DUMP_DATA *SpiRefrenceData
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +AcpiApeiUpdate (
> + VOID
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +AcpiPopulateBert (
> + VOID
> + );
> +
> +#endif /* ACPI_APEI_H_ */
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
> new file mode 100644
> index 000000000000..920579281dd5
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
> @@ -0,0 +1,49 @@
> +/** @file
> +
> + Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef ACPI_NFIT_H_
> +#define ACPI_NFIT_H_
> +
> +#include <Platform/Ac01.h>
> +
> +#define NVDIMM_SK0 0
> +#define NVDIMM_SK1 1
> +#define NVDIMM_NUM_PER_SK (PLATFORM_NVDIMM_MCU_MAX_PER_SK * PLATFORM_NVDIMM_NUM_MAX_PER_MCU)
> +#define ONE_GB (1024 * 1024 * 1024)
> +
> +enum NvdimmMode {
> + NVDIMM_DISABLED = 0,
> + NVDIMM_NON_HASHED = 1,
> + NVDIMM_HASHED = 2
> +};
> +
> +typedef struct {
> + BOOLEAN Enabled;
> + UINT64 NvdSize;
> + UINT32 DeviceHandle;
> + UINT16 PhysId;
> + UINT8 InterleaveWays;
> + UINT64 RegionOffset;
> + UINT16 VendorId;
> + UINT16 DeviceId;
> + UINT16 RevisionId;
> + UINT16 SubVendorId;
> + UINT16 SubDeviceId;
> + UINT16 SubRevisionId;
> + UINT32 SerialNumber;
> +} NVDIMM_INFO;
> +
> +typedef struct {
> + UINT8 NvdRegionNum;
> + UINT8 NvdRegionId[PLATFORM_NVDIMM_REGION_MAX_PER_SK];
> + UINT8 NvdMode;
> + UINT8 NvdNum;
> + NVDIMM_INFO NvdInfo[NVDIMM_NUM_PER_SK];
> +} NVDIMM_DATA;
> +
> +#endif
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
> new file mode 100644
> index 000000000000..ce4d9b8440b8
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
> @@ -0,0 +1,76 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef ACPI_PLATFORM_H_
> +#define ACPI_PLATFORM_H_
> +
> +#include <Uefi.h>
> +
> +#include <AcpiHeader.h>
> +#include <Guid/EventGroup.h>
> +#include <Guid/PlatformInfoHobGuid.h>
> +#include <IndustryStandard/Acpi63.h>
> +#include <Library/ArmLib/ArmLibPrivate.h>
> +#include <Library/AcpiHelperLib.h>
> +#include <Library/AcpiLib.h>
> +#include <Library/AmpereCpuLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/DebugLib.h>
> +#include <Library/DevicePathLib.h>
> +#include <Library/HobLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/PcdLib.h>
> +#include <Library/PrintLib.h>
> +#include <Library/UefiBootServicesTableLib.h>
> +#include <Library/UefiLib.h>
> +#include <Library/UefiRuntimeServicesTableLib.h>
> +#include <Platform/Ac01.h>
> +#include <PlatformInfoHob.h>
> +#include <Protocol/AcpiTable.h>
> +
> +EFI_STATUS
> +AcpiPatchDsdtTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallMadtTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallNfitTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiPcctInit (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallPcctTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallPpttTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallSlitTable (
> + VOID
> + );
> +
> +EFI_STATUS
> +AcpiInstallSratTable (
> + VOID
> + );
> +
> +#endif /* ACPI_PLATFORM_H_ */
> diff --git a/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
> new file mode 100644
> index 000000000000..d604b712d8c8
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
> @@ -0,0 +1,37 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#ifndef ACPI_HEADER_H_
> +#define ACPI_HEADER_H_
> +
> +#include <IndustryStandard/Acpi.h>
> +
> +//
> +// ACPI table information used to initialize tables.
> +//
> +#define EFI_ACPI_OEM_ID {'A','m','p','e','r','e'}
> +#define EFI_ACPI_OEM_TABLE_ID SIGNATURE_64('A','l','t','r','a',' ',' ',' ')
> +#define EFI_ACPI_OEM_REVISION FixedPcdGet32 (PcdAcpiDefaultOemRevision)
> +#define EFI_ACPI_CREATOR_ID SIGNATURE_32('A','M','P','.')
> +#define EFI_ACPI_CREATOR_REVISION FixedPcdGet32 (PcdAcpiDefaultCreatorRevision)
> +
> +// A macro to initialise the common header part of EFI ACPI tables as defined by
> +// EFI_ACPI_DESCRIPTION_HEADER structure.
> +#define __ACPI_HEADER(Signature, Type, Revision) { \
> + Signature, /* UINT32 Signature */ \
> + sizeof (Type), /* UINT32 Length */ \
> + Revision, /* UINT8 Revision */ \
> + 0, /* UINT8 Checksum */ \
> + EFI_ACPI_OEM_ID, /* UINT8 OemId[6] */ \
> + EFI_ACPI_OEM_TABLE_ID, /* UINT64 OemTableId */ \
> + EFI_ACPI_OEM_REVISION, /* UINT32 OemRevision */ \
> + EFI_ACPI_CREATOR_ID, /* UINT32 CreatorId */ \
> + EFI_ACPI_CREATOR_REVISION /* UINT32 CreatorRevision */ \
> + }
> +
> +#endif /* ACPI_HEADER_H_ */
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
> new file mode 100644
> index 000000000000..fa188c7776db
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
> @@ -0,0 +1,457 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Uefi.h>
> +
> +#include <Library/AcpiHelperLib.h>
> +#include <Library/FlashLib.h>
> +#include <Library/NVParamLib.h>
> +#include <NVParamDef.h>
> +
> +#include "AcpiApei.h"
> +
> +UINT8 AMPERE_GUID[16] = {0x8d, 0x89, 0xed, 0xe8, 0x16, 0xdf, 0xcc, 0x43, 0x8e, 0xcc, 0x54, 0xf0, 0x60, 0xef, 0x15, 0x7f};
> +CHAR8 DEFAULT_BERT_REBOOT_MSG[BERT_MSG_SIZE] = "Unknown reboot reason";
> +
> +STATIC VOID
> +AcpiApeiUninstallTable (
> + UINT32 Signature
> + )
> +{
> + EFI_STATUS Status;
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol;
> + EFI_ACPI_SDT_HEADER *Table;
> + EFI_ACPI_TABLE_VERSION TableVersion;
> + UINTN TableKey;
> + UINTN Idx;
> +
> + /*
> + * Get access to ACPI tables
> + */
> + Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **)&AcpiTableProtocol);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table protocol\n", __FUNCTION__, __LINE__));
> + return;
> + }
> +
> + Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table support protocol\n", __FUNCTION__, __LINE__));
> + return;
> + }
> +
> + /*
> + * Search for ACPI Table Signature
> + */
> + for (Idx = 0; ; Idx++) {
> + Status = AcpiTableSdtProtocol->GetAcpiTable (Idx, &Table, &TableVersion, &TableKey);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to get ACPI table index %d \n", __FUNCTION__, __LINE__, Idx));
> + return;
> + } else if (Table->Signature == Signature) {
> + break;
> + }
> + }
> +
> + /*
> + * Uninstall ACPI Table
> + */
> + Status = AcpiTableProtocol->UninstallAcpiTable (AcpiTableProtocol, TableKey);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to uninstall table\n", __FUNCTION__, __LINE__));
> + }
> +}
> +
> +VOID
> +AdjustBERTRegionLen (
> + UINT32 Len
> + )
> +{
> + UINT32 Signature = EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE;
> + EFI_STATUS Status;
> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
> + EFI_ACPI_TABLE_VERSION TableVersion;
> + UINTN TableKey;
> + UINTN Idx;
> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER *Table;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiSdtProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableSdtProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
> + return;
> + }
> +
> + /*
> + * Search for ACPI Table Signature
> + */
> + for (Idx = 0; ; Idx++) {
> + Status = AcpiTableSdtProtocol->GetAcpiTable (
> + Idx,
> + (EFI_ACPI_SDT_HEADER **)&Table,
> + &TableVersion,
> + &TableKey
> + );
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "APEI: Unable to get ACPI table index:%d\n", Idx));
> + return;
> + } else if (Table->Header.Signature == Signature) {
> + break;
> + }
> + }
> +
> + /*
> + * Adjust Boot Error Region Length
> + */
> + Table->BootErrorRegionLength = Len;
> +
> + AcpiTableChecksum ((UINT8 *)Table, Table->Header.Length);
> +}
> +
> +/*
> + * Retrieve Bert data from SPI NOR
> + */
> +VOID
> +PullBertSpinorData (
> + APEI_CRASH_DUMP_DATA *BertErrorData
> + )
> +{
> + UINTN Length;
> +
> + Length = sizeof (*BertErrorData);
> +
> + FlashReadCommand (
> + (UINT8 *)BERT_FLASH_OFFSET,
> + (UINT8 *)BertErrorData,
> + &Length
> + );
> +}
> +
> +/*
> + * wrap raw bert error data
> + *
> + * @param IN BertErrorData Bert Error record to be wrapped
> + * @param OUT WrappedError Generic error data for OS to consume.
> + */
> +VOID
> +WrapBertErrorData (
> + APEI_CRASH_DUMP_BERT_ERROR *WrappedError
> + )
> +{
> + UINT32 CrashSize;
> +
> + CrashSize = PLAT_CRASH_ITERATOR_SIZE *
> + GetNumberOfSupportedSockets () *
> + GetMaximumNumberOfCores ();
> + CrashSize += 2 * (SMPRO_CRASH_SIZE + PMPRO_CRASH_SIZE);
> + CrashSize += sizeof (WrappedError->Bed.Vendor) + sizeof (WrappedError->Bed.BertRev);
> +
> + WrappedError->Ges.BlockStatus.ErrorDataEntryCount = 1;
> + WrappedError->Ges.BlockStatus.UncorrectableErrorValid = 1;
> + WrappedError->Ged.ErrorSeverity = BERT_DEFAULT_ERROR_SEVERITY;
> + WrappedError->Ged.Revision = GENERIC_ERROR_DATA_REVISION;
> +
> + if (WrappedError->Bed.Vendor.Type == RAS_2P_TYPE ||
> + (WrappedError->Bed.Vendor.Type == BERT_ERROR_TYPE &&
> + (WrappedError->Bed.Vendor.SubType == 0 ||
> + WrappedError->Bed.Vendor.SubType == BERT_UEFI_FAILURE)))
> + {
> + WrappedError->Ged.ErrorDataLength = sizeof (WrappedError->Bed.Vendor) +
> + sizeof (WrappedError->Bed.BertRev);
> + WrappedError->Ges.DataLength = sizeof (WrappedError->Bed.Vendor) +
> + sizeof (WrappedError->Bed.BertRev) +
> + sizeof (WrappedError->Ged);
> + AdjustBERTRegionLen (
> + sizeof (WrappedError->Bed.Vendor) +
> + sizeof (WrappedError->Bed.BertRev) +
> + sizeof (WrappedError->Ged) +
> + sizeof (WrappedError->Ges)
> + );
> + } else {
> + WrappedError->Ged.ErrorDataLength = CrashSize;
> + WrappedError->Ges.DataLength = CrashSize + sizeof (WrappedError->Ged);
> + AdjustBERTRegionLen (
> + CrashSize +
> + sizeof (WrappedError->Ged) +
> + sizeof (WrappedError->Ges)
> + );
> + }
> + CopyMem (
> + WrappedError->Ged.SectionType,
> + AMPERE_GUID,
> + sizeof (AMPERE_GUID)
> + );
> +}
> +
> +
> +/*
> + * create default bert error
> + * Msg: Unknown reboot reason
> + */
> +VOID
> +CreateDefaultBertData (
> + APEI_BERT_ERROR_DATA *Data
> + )
> +{
> + Data->Type = BERT_ERROR_TYPE;
> + AsciiStrCpyS (
> + Data->Msg,
> + BERT_MSG_SIZE,
> + DEFAULT_BERT_REBOOT_MSG
> + );
> +}
> +
> +/*
> + * Ensures BertErrorData In SPINOR matches
> + * the record produced by CreateDefaultBertData.
> + * @param Bed Crash dump Data
> + */
> +VOID
> +WriteSpinorDefaultBertTable (
> + APEI_CRASH_DUMP_DATA *Bed
> + )
> +{
> + UINT8 BertRev;
> + UINTN Length;
> + UINT64 Offset;
> + UINT32 MsgDiff;
> + APEI_BERT_ERROR_DATA DefaultData = {0};
> +
> + CreateDefaultBertData (&DefaultData);
> + if ((Bed->Vendor.Type != DefaultData.Type)) {
> + Offset = BERT_FLASH_OFFSET +
> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
> + OFFSET_OF (APEI_BERT_ERROR_DATA, Type);
> + Length = sizeof (DefaultData.Type);
> + FlashEraseCommand ((UINT8 *)Offset, Length);
> + FlashProgramCommand (
> + (UINT8 *)Offset,
> + (UINT8 *)&(DefaultData.Type),
> + &Length
> + );
> + }
> +
> + if ((Bed->Vendor.SubType != DefaultData.SubType)) {
> + Offset = BERT_FLASH_OFFSET +
> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
> + OFFSET_OF (APEI_BERT_ERROR_DATA, SubType);
> + Length = sizeof (DefaultData.SubType);
> + FlashEraseCommand ((UINT8 *)Offset, Length);
> + FlashProgramCommand (
> + (UINT8 *)Offset,
> + (UINT8 *)&(DefaultData.SubType),
> + &Length
> + );
> + }
> +
> + if ((Bed->Vendor.Instance != DefaultData.Instance)) {
> + Offset = BERT_FLASH_OFFSET +
> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
> + OFFSET_OF (APEI_BERT_ERROR_DATA, Instance);
> + Length = sizeof (DefaultData.Instance);
> + FlashEraseCommand ((UINT8 *)Offset, Length);
> + FlashProgramCommand (
> + (UINT8 *)Offset,
> + (UINT8 *)&(DefaultData.Instance),
> + &Length
> + );
> + }
> +
> + MsgDiff = AsciiStrnCmp (Bed->Vendor.Msg, DefaultData.Msg, BERT_MSG_SIZE);
> + if (MsgDiff != 0) {
> + Offset = BERT_FLASH_OFFSET +
> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
> + OFFSET_OF (APEI_BERT_ERROR_DATA, Msg);
> + Length = sizeof (DefaultData.Msg);
> + FlashEraseCommand ((UINT8 *)Offset, Length);
> + FlashProgramCommand (
> + (UINT8 *)Offset,
> + (UINT8 *)&(DefaultData.Msg),
> + &Length
> + );
> + }
> +
> + if (Bed->BertRev != CURRENT_BERT_VERSION) {
> + Offset = BERT_FLASH_OFFSET + OFFSET_OF (APEI_CRASH_DUMP_DATA, BertRev);
> + Length = sizeof (Bed->BertRev);
> + BertRev = CURRENT_BERT_VERSION;
> + FlashEraseCommand ((UINT8 *)Offset, Length);
> + FlashProgramCommand ((UINT8 *)Offset, (UINT8 *)&BertRev, &Length);
> + }
> +
> +}
> +
> +/*
> + * Checks Status of NV_SI_RAS_BERT_ENABLED
> + * Returns TRUE if enabled and FALSE if disabled
> + */
> +BOOLEAN
> +IsBertEnabled (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Value;
> +
> + Status = NVParamGet (
> + NV_SI_RAS_BERT_ENABLED,
> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
> + &Value
> + );
> + if (EFI_ERROR (Status)) {
> + // BERT is enabled by default
> + return TRUE;
> + }
> +
> + return (Value != 0) ? TRUE : FALSE;
> +}
> +
> +/*
> + * Write bert table to DDR
> + */
> +VOID
> +WriteDDRBertTable (
> + APEI_CRASH_DUMP_BERT_ERROR *Data
> + )
> +{
> + VOID *Blk = (VOID *)BERT_DDR_OFFSET;
> +
> + /*
> + * writing sizeof data to ddr produces alignment error
> + * this is a temporary workaround
> + */
> + CopyMem (Blk, Data, BERT_DDR_LENGTH);
> +}
> +
> +/*
> + * Update Bert Table
> + */
> +EFI_STATUS
> +AcpiPopulateBert (
> + VOID
> + )
> +{
> + APEI_CRASH_DUMP_BERT_ERROR *DDRError;
> +
> + DDRError =
> + (APEI_CRASH_DUMP_BERT_ERROR *)
> + AllocateZeroPool (sizeof (APEI_CRASH_DUMP_BERT_ERROR));
> +
> + if (DDRError == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + if (IsBertEnabled ()) {
> + PullBertSpinorData (&(DDRError->Bed));
> + if ((DDRError->Bed.BertRev == CURRENT_BERT_VERSION)) {
> + WrapBertErrorData (DDRError);
> + WriteDDRBertTable (DDRError);
> + }
> + WriteSpinorDefaultBertTable (&(DDRError->Bed));
> + }
> +
> + FreePool (DDRError);
> + return EFI_SUCCESS;
> +}
> +
> +/*
> + * Checks Status of NV_SI_RAS_SDEI_ENABLED
> + * Returns TRUE if enabled and FALSE if disabled or error occurred
> + */
> +BOOLEAN
> +IsSdeiEnabled (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + UINT32 Value;
> +
> + Status = NVParamGet (
> + NV_SI_RAS_SDEI_ENABLED,
> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
> + &Value
> + );
> + if (EFI_ERROR (Status)) {
> + // SDEI is disabled by default
> + return FALSE;
> + }
> +
> + return (Value != 0) ? TRUE : FALSE;
> +}
> +
> +STATIC
> +VOID
> +AcpiApeiHestUpdateTable1P (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
> + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_HEADER *HestTablePointer;
> + EFI_ACPI_TABLE_VERSION TableVersion;
> + UINTN TableKey;
> + UINTN Idx;
> +
> + Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
> + return;
> + }
> +
> + /*
> + * Search for ACPI Table Signature
> + */
> + for (Idx = 0; ; Idx++) {
> + Status = AcpiTableSdtProtocol->GetAcpiTable (
> + Idx,
> + (EFI_ACPI_SDT_HEADER **)&HestTablePointer,
> + &TableVersion,
> + &TableKey
> + );
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "APEI: Unable to get HEST table"));
> + return;
> + } else if (HestTablePointer->Header.Signature ==
> + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE)
> + {
> + break;
> + }
> + }
> +
> + HestTablePointer->ErrorSourceCount -= HEST_NUM_ENTRIES_PER_SOC;
> + HestTablePointer->Header.Length -=
> + (HEST_NUM_ENTRIES_PER_SOC *
> + sizeof (EFI_ACPI_6_3_GENERIC_HARDWARE_ERROR_SOURCE_VERSION_2_STRUCTURE));
> +
> + AcpiTableChecksum ((UINT8 *)HestTablePointer, HestTablePointer->Header.Length);
> +}
> +
> +/*
> + * Update APEI
> + *
> + */
> +EFI_STATUS
> +EFIAPI
> +AcpiApeiUpdate (
> + VOID
> + )
> +{
> + if (!IsSlaveSocketActive ()) {
> + AcpiApeiHestUpdateTable1P ();
> + }
> +
> + if (!IsSdeiEnabled ()) {
> + AcpiApeiUninstallTable (EFI_ACPI_6_3_SOFTWARE_DELEGATED_EXCEPTIONS_INTERFACE_TABLE_SIGNATURE);
> + }
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
> new file mode 100644
> index 000000000000..7881044104e4
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
> @@ -0,0 +1,445 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Protocol/PciRootBridgeIo.h>
> +#include <Library/NVParamLib.h>
> +#include <NVParamDef.h>
> +
> +#include "AcpiNfit.h"
> +#include "AcpiPlatform.h"
> +
> +#define PCIE_DEVICE_CONTROL_OFFSET 0x078
> +#define PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN 0x08
> +#define PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN 0x04
> +#define PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN 0x02
> +#define PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN 0x01
> +
> +#define PCIE_ROOT_ERR_CMD_OFFSET 0x12C
> +#define PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN 0x4
> +#define PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN 0x2
> +#define PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN 0x1
> +
> +#define PCIE_MAX_DEVICE_PER_ROOT_PORT 8
> +
> +STATIC VOID
> +AcpiPatchCmn600 (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINTN Index;
> +
> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.CMN%1X._STA", Index);
> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
> + } else {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> +}
> +
> +STATIC VOID
> +AcpiPatchDmc620 (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINTN Index, Index1;
> + PLATFORM_INFO_HOB *PlatformHob;
> + UINT32 McuMask;
> + VOID *Hob;
> +
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL) {
> + return;
> + }
> +
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
> + McuMask = PlatformHob->DramInfo.McuMask[Index];
> + for (Index1 = 0; Index1 < sizeof (McuMask) * 8; Index1++) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.MC%1X%1X._STA", Index, Index1);
> + if (McuMask & (0x1 << Index1)) {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
> + } else {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> + }
> +}
> +
> +STATIC VOID
> +AcpiPatchNvdimm (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINTN NvdRegionNumSK0, NvdRegionNumSK1, NvdRegionNum, Count;
> + PLATFORM_INFO_HOB *PlatformHob;
> + VOID *Hob;
> +
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL) {
> + return;
> + }
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + NvdRegionNumSK0 = 0;
> + NvdRegionNumSK1 = 0;
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0) {
> + if (PlatformHob->DramInfo.Socket[Count] == 0) {
> + NvdRegionNumSK0++;
> + } else {
> + NvdRegionNumSK1++;
> + }
> + }
> + }
> + NvdRegionNum = NvdRegionNumSK0 + NvdRegionNumSK1;
> +
> + /* Disable NVDIMM Root Device */
> + if (NvdRegionNum == 0) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + /* Update NVDIMM Device _STA for SK0 */
> + if (NvdRegionNumSK0 == 0) {
> + /* Disable NVD1/2 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + } else if (NvdRegionNumSK0 == 1) {
> + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK0] == NVDIMM_NON_HASHED) {
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
> + PlatformHob->DramInfo.Socket[Count] == 0)
> + {
> + if (PlatformHob->DramInfo.Base[Count] ==
> + PLATFORM_NVDIMM_SK0_NHASHED_REGION0)
> + {
> + /* Disable NVD2 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + } else if (PlatformHob->DramInfo.Base[Count] ==
> + PLATFORM_NVDIMM_SK0_NHASHED_REGION1)
> + {
> + /* Disable NVD1 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> + }
> + }
> + }
> + /* Update NVDIMM Device _STA for SK1 */
> + if (NvdRegionNumSK1 == 0) {
> + /* Disable NVD3/4 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + } else if (NvdRegionNumSK1 == 1) {
> + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK1] == NVDIMM_NON_HASHED) {
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
> + PlatformHob->DramInfo.Socket[Count] == 1)
> + {
> + if (PlatformHob->DramInfo.Base[Count] ==
> + PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
> + {
> + /* Disable NVD4 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + } else if (PlatformHob->DramInfo.Base[Count] ==
> + PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
> + {
> + /* Disable NVD3 */
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> + }
> + }
> + }
> +}
> +
> +STATIC VOID
> +AcpiPatchHwmon (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINT8 Index;
> +
> + // PCC Hardware Monitor Devices
> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index);
> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
> + } else {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> +
> + // Ampere Altra SoC Hardware Monitor Devices
> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index + 2);
> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
> + } else {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> +}
> +
> +STATIC VOID
> +AcpiPatchDsu (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINTN Index;
> +
> + for (Index = 0; Index < PLATFORM_CPU_MAX_NUM_CORES; Index += PLATFORM_CPU_NUM_CORES_PER_CPM) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.DU%2X._STA", Index / PLATFORM_CPU_NUM_CORES_PER_CPM);
> + if (IsCpuEnabled (Index)) {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
> + } else {
> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
> + }
> + }
> +}
> +
> +VOID
> +AcpiPatchPcieNuma (
> + VOID
> + )
> +{
> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
> + UINTN Index;
> + UINTN NumaIdx;
> + UINTN NumPciePort;
> + UINTN NumaAssignment[3][16] = {
> + { 0, 0, 0, 0, 0, 0, 0, 0, // Monolithic Node 0 (S0)
> + 1, 1, 1, 1, 1, 1, 1, 1 }, // Monolithic Node 1 (S1)
> + { 0, 1, 0, 1, 0, 0, 1, 1, // Hemisphere Node 0, 1 (S0)
> + 2, 3, 2, 3, 2, 2, 3, 3 }, // Hemisphere Node 2, 3 (S1)
> + { 0, 2, 1, 3, 1, 1, 3, 3, // Quadrant Node 0, 1, 2, 3 (S0)
> + 4, 6, 5, 7, 5, 5, 7, 7 }, // Quadrant Node 4, 5, 6, 7 (S1)
> + };
> +
> + switch (CpuGetSubNumaMode ()) {
> + case SUBNUMA_MODE_MONOLITHIC:
> + NumaIdx = 0;
> + break;
> +
> + case SUBNUMA_MODE_HEMISPHERE:
> + NumaIdx = 1;
> + break;
> +
> + case SUBNUMA_MODE_QUADRANT:
> + NumaIdx = 2;
> + break;
> +
> + default:
> + NumaIdx = 0;
> + break;
> + }
> +
> + if (IsSlaveSocketActive ()) {
> + NumPciePort = 16; // 16 ports total (8 per socket)
> + } else {
> + NumPciePort = 8; // 8 ports total
> + }
> +
> + for (Index = 0; Index < NumPciePort; Index++) {
> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.PCI%X._PXM", Index);
> + AcpiDSDTSetNodeStatusValue (NodePath, NumaAssignment[NumaIdx][Index]);
> + }
> +}
> +
> +EFI_STATUS
> +AcpiPatchPcieAerFwFirst (
> + VOID
> + )
> +{
> + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS Address;
> + EFI_ACPI_SDT_PROTOCOL *AcpiTableProtocol;
> + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
> + EFI_HANDLE *HandleBuffer;
> + UINTN HandleCount;
> + EFI_ACPI_HANDLE TableHandle;
> + EFI_ACPI_HANDLE ChildHandle;
> + EFI_ACPI_DATA_TYPE DataType;
> + UINTN DataSize;
> + CHAR8 ObjectPath[8];
> + EFI_STATUS Status;
> + UINT32 AerFwFirstConfigValue;
> + UINT32 RegData;
> + UINT16 Device;
> + UINT32 Index;
> + UINT8 *Data;
> +
> + //
> + // Check if PCIe AER Firmware First should be enabled
> + //
> + Status = NVParamGet (
> + NV_SI_RAS_PCIE_AER_FW_FIRST,
> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
> + &AerFwFirstConfigValue
> + );
> + if (EFI_ERROR (Status)) {
> + Status = NVParamGet (
> + NV_SI_RO_BOARD_PCIE_AER_FW_FIRST,
> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
> + &AerFwFirstConfigValue
> + );
> + if (EFI_ERROR (Status)) {
> + AerFwFirstConfigValue = 0;
> + }
> + }
> +
> + if (AerFwFirstConfigValue == 0) {
> + //
> + // By default, the PCIe AER FW-First (ACPI Object "AERF") is set to 0
> + // in the DSDT table.
> + //
> + return EFI_SUCCESS;
> + }
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiSdtProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Unable to locate ACPI table protocol\n"));
> + return Status;
> + }
> +
> + Status = AcpiOpenDSDT (AcpiTableProtocol, &TableHandle);
> + if (EFI_ERROR (Status)) {
> + AcpiTableProtocol->Close (TableHandle);
> + return Status;
> + }
> +
> + //
> + // Update Name Object "AERF" (PCIe AER Firmware-First) if it is enabled.
> + //
> + AsciiSPrint (ObjectPath, sizeof (ObjectPath), "\\AERF");
> + Status = AcpiTableProtocol->FindPath (TableHandle, ObjectPath, &ChildHandle);
> + ASSERT_EFI_ERROR (Status);
> + if (!EFI_ERROR (Status)) {
> + Status = AcpiTableProtocol->GetOption (
> + ChildHandle,
> + 0,
> + &DataType,
> + (VOID *)&Data,
> + &DataSize
> + );
> + ASSERT_EFI_ERROR (Status);
> + if (!EFI_ERROR (Status)
> + && Data[0] == AML_NAME_OP
> + && (Data[5] == AML_ZERO_OP || Data[5] == AML_ONE_OP))
> + {
> + Data[5] = 1; // Enable PCIe AER Firmware-First
> + }
> + }
> +
> + AcpiTableProtocol->Close (TableHandle);
> + AcpiDSDTUpdateChecksum (AcpiTableProtocol);
> +
> + //
> + // For PCIe AER Firmware First, PCIe capability registers need
> + // to be updated to allow Firmware to detect AER errors.
> + //
> +
> + HandleCount = 0;
> + HandleBuffer = NULL;
> + PciRootBridgeIo = NULL;
> +
> + Status = gBS->LocateHandleBuffer (
> + ByProtocol,
> + &gEfiPciRootBridgeIoProtocolGuid,
> + NULL,
> + &HandleCount,
> + &HandleBuffer
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + //
> + // Loop through each root complex
> + //
> + for (Index = 0; Index < HandleCount; Index++) {
> + Status = gBS->HandleProtocol (
> + HandleBuffer[Index],
> + &gEfiPciRootBridgeIoProtocolGuid,
> + (VOID **)&PciRootBridgeIo
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + //
> + // Loop through each root port
> + //
> + for (Device = 1; Device <= PCIE_MAX_DEVICE_PER_ROOT_PORT; Device++) {
> + Address.Bus = 0;
> + Address.Device = Device;
> + Address.Function = 0;
> + Address.Register = 0;
> +
> + Address.ExtendedRegister = PCIE_DEVICE_CONTROL_OFFSET;
> + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
> +
> + if (RegData == 0xFFFFFFFF) {
> + continue;
> + }
> +
> + RegData |= PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN
> + | PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN
> + | PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN
> + | PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN;
> +
> + PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
> +
> + RegData = 0;
> + Address.ExtendedRegister = PCIE_ROOT_ERR_CMD_OFFSET;
> + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
> +
> + RegData |= PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN
> + | PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN
> + | PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN;
> +
> + PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
> + }
> + }
> +
> + return Status;
> +}
> +
> +EFI_STATUS
> +AcpiPatchDsdtTable (
> + VOID
> + )
> +{
> + AcpiPatchCmn600 ();
> + AcpiPatchDmc620 ();
> + AcpiPatchDsu ();
> + AcpiPatchHwmon ();
> + AcpiPatchNvdimm ();
> + AcpiPatchPcieNuma ();
> + AcpiPatchPcieAerFwFirst ();
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
> new file mode 100644
> index 000000000000..1d1643abd299
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
> @@ -0,0 +1,351 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "AcpiPlatform.h"
> +
> +EFI_ACPI_6_3_GIC_ITS_STRUCTURE GicItsTemplate = {
> + EFI_ACPI_6_3_GIC_ITS,
> + sizeof (EFI_ACPI_6_3_GIC_ITS_STRUCTURE),
> + EFI_ACPI_RESERVED_WORD,
> + 0, /* GicItsId */
> + 0, /* PhysicalBaseAddress */
> + 0, /* Reserved2 */
> +};
> +
> +EFI_ACPI_6_3_GICR_STRUCTURE GicRTemplate = {
> + EFI_ACPI_6_3_GICR,
> + sizeof (EFI_ACPI_6_3_GICR_STRUCTURE),
> + EFI_ACPI_RESERVED_WORD,
> + GICR_MASTER_BASE_REG, /* DiscoveryRangeBaseAddress */
> + 0x1000000, /* DiscoveryRangeLength */
> +};
> +
> +EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE GicDTemplate = {
> + EFI_ACPI_6_3_GICD,
> + sizeof (EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE),
> + EFI_ACPI_RESERVED_WORD,
> + 0, /* GicDistHwId */
> + GICD_BASE_REG, /* GicDistBase */
> + 0, /* GicDistVector */
> + 0x3, /* GicVersion */
> + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}
> +};
> +
> +EFI_ACPI_6_3_GIC_STRUCTURE GiccTemplate = {
> + EFI_ACPI_6_3_GIC,
> + sizeof (EFI_ACPI_6_3_GIC_STRUCTURE),
> + EFI_ACPI_RESERVED_WORD,
> + 0, /* GicId */
> + 0, /* AcpiCpuUid */
> + 0, /* Flags */
> + 0,
> + 23, /* PmuIrq */
> + 0,
> + 0,
> + 0,
> + 0,
> + 25, /* GsivId */
> + 0, /* GicRBase */
> + 0, /* Mpidr */
> + 0, /* ProcessorPowerEfficiencyClass */
> + 0, /* Reserved2 */
> + 21, /* SPE irq */
> +};
> +
> +EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER MADTTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE,
> + 0, /* need fill in */
> + EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION
> + ),
> +};
> +
> +UINT32 Ac01CoreOrderMonolithic[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
> + 36, 52, 40, 56, 32, 48, 44, 60,
> + 20, 68, 24, 72, 16, 64, 28, 76,
> + 4, 8, 0, 12, 38, 54, 42, 58,
> + 34, 50, 46, 62, 22, 70, 26, 74,
> + 18, 66, 30, 78, 6, 10, 2, 14,
> + 37, 53, 41, 57, 33, 49, 45, 61,
> + 21, 69, 25, 73, 17, 65, 29, 77,
> + 5, 9, 1, 13, 39, 55, 43, 59,
> + 35, 51, 47, 63, 23, 71, 27, 75,
> + 19, 67, 31, 79, 7, 11, 3, 15,
> +};
> +
> +UINT32 Ac01CoreOrderHemisphere[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
> + 32, 48, 16, 64, 36, 52, 0, 20,
> + 68, 4, 34, 50, 18, 66, 38, 54,
> + 2, 22, 70, 6, 33, 49, 17, 65,
> + 37, 53, 1, 21, 69, 5, 35, 51,
> + 19, 67, 39, 55, 3, 23, 71, 7,
> + 44, 60, 28, 76, 40, 56, 12, 24,
> + 72, 8, 46, 62, 30, 78, 42, 58,
> + 14, 26, 74, 10, 45, 61, 29, 77,
> + 41, 57, 13, 25, 73, 9, 47, 63,
> + 31, 79, 43, 59, 15, 27, 75, 11,
> +};
> +
> +UINT32 Ac01CoreOrderQuadrant[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
> + 16, 32, 0, 20, 4, 18, 34, 2,
> + 22, 6, 17, 33, 1, 21, 5, 19,
> + 35, 3, 23, 7, 48, 64, 52, 68,
> + 36, 50, 66, 54, 70, 38, 49, 65,
> + 53, 69, 37, 51, 67, 55, 71, 39,
> + 28, 44, 12, 24, 8, 30, 46, 14,
> + 26, 10, 29, 45, 13, 25, 9, 31,
> + 47, 15, 27, 11, 60, 76, 56, 72,
> + 40, 62, 78, 58, 74, 42, 61, 77,
> + 57, 73, 41, 63, 79, 59, 75, 43,
> +};
> +
> +EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *MadtTablePointer;
> +
> +UINT32 *
> +CpuGetCoreOrder (
> + VOID
> + )
> +{
> + UINT8 SubNumaMode;
> +
> + SubNumaMode = CpuGetSubNumaMode ();
> + switch (SubNumaMode) {
> + case SUBNUMA_MODE_MONOLITHIC:
> + return (UINT32 *)&Ac01CoreOrderMonolithic;
> +
> + case SUBNUMA_MODE_HEMISPHERE:
> + return (UINT32 *)&Ac01CoreOrderHemisphere;
> +
> + case SUBNUMA_MODE_QUADRANT:
> + return (UINT32 *)&Ac01CoreOrderQuadrant;
> +
> + default:
> + // Should never reach here
> + ASSERT (FALSE);
> + return NULL;
> + }
> +
> + return NULL;
> +}
> +
> +UINT32
> +AcpiInstallMadtProcessorNode (
> + VOID *EntryPointer,
> + UINT32 CpuId
> + )
> +{
> + EFI_ACPI_6_3_GIC_STRUCTURE *MadtProcessorEntryPointer = EntryPointer;
> + UINT32 SocketId;
> + UINT32 ClusterId;
> + UINTN Size;
> +
> + Size = sizeof (GiccTemplate);
> + CopyMem (MadtProcessorEntryPointer, &GiccTemplate, Size);
> +
> + SocketId = SOCKET_ID (CpuId);
> + ClusterId = CLUSTER_ID (CpuId);
> +
> + //
> + // GICv2 compatibility mode is not supported.
> + // Hence, set GIC's CPU Interface Number to 0.
> + //
> + MadtProcessorEntryPointer->CPUInterfaceNumber = 0;
> + MadtProcessorEntryPointer->AcpiProcessorUid =
> + (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
> + (ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM);
> + MadtProcessorEntryPointer->Flags = 1;
> + MadtProcessorEntryPointer->MPIDR =
> + (((ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM)) << 8);
> + MadtProcessorEntryPointer->MPIDR += (((UINT64)SocketId) << 32);
> +
> + return Size;
> +}
> +
> +UINT32
> +AcpiInstallMadtGicD (
> + VOID *EntryPointer
> + )
> +{
> + EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE *GicDEntryPointer = EntryPointer;
> + UINTN Size;
> +
> + Size = sizeof (GicDTemplate);
> + CopyMem (GicDEntryPointer, &GicDTemplate, Size);
> +
> + return Size;
> +}
> +
> +UINT32
> +AcpiInstallMadtGicR (
> + VOID *EntryPointer,
> + UINT32 SocketId
> + )
> +{
> + EFI_ACPI_6_3_GICR_STRUCTURE *GicREntryPointer = EntryPointer;
> + UINTN Size;
> +
> + /*
> + * If the Slave socket is not present, discard the Slave socket
> + * GIC redistributor region
> + */
> + if (SocketId == 1 && !IsSlaveSocketActive ()) {
> + return 0;
> + }
> +
> + Size = sizeof (GicRTemplate);
> + CopyMem (GicREntryPointer, &GicRTemplate, Size);
> +
> + if (SocketId == 1) {
> + GicREntryPointer->DiscoveryRangeBaseAddress = GICR_SLAVE_BASE_REG;
> + }
> +
> + return Size;
> +}
> +
> +UINT32
> +AcpiInstallMadtGicIts (
> + VOID *EntryPointer,
> + UINT32 Index
> + )
> +{
> + EFI_ACPI_6_3_GIC_ITS_STRUCTURE *GicItsEntryPointer = EntryPointer;
> + UINTN Size, Offset;
> + UINT64 GicBase = GICD_BASE_REG;
> + UINT32 ItsId = Index;
> +
> + if (Index > SOCKET0_LAST_RC) { /* Socket 1, Index: 8-15 */
> + GicBase = GICD_SLAVE_BASE_REG;
> + Index -= (SOCKET0_LAST_RC + 1); /* Socket 1, Index:8 -> RCA0 */
> + }
> + Size = sizeof (GicItsTemplate);
> + CopyMem (GicItsEntryPointer, &GicItsTemplate, Size);
> + Offset = 0x40000 + Index * 0x20000;
> + GicItsEntryPointer->GicItsId = ItsId;
> + GicItsEntryPointer->PhysicalBaseAddress = Offset + GicBase;
> +
> + return Size;
> +}
> +
> +/*
> + * Install MADT table.
> + */
> +EFI_STATUS
> +AcpiInstallMadtTable (
> + VOID
> + )
> +{
> + EFI_ACPI_6_3_GIC_STRUCTURE *GiccEntryPointer = NULL;
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + UINTN MadtTableKey = 0;
> + INTN Index;
> + EFI_STATUS Status;
> + UINTN Size;
> + UINT32 *CoreOrder;
> + UINT32 SktMaxCoreNum;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + Size = sizeof (MADTTableHeaderTemplate) +
> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (GiccTemplate)) +
> + sizeof (GicDTemplate) +
> + (PLATFORM_CPU_MAX_SOCKET * sizeof (GicRTemplate)) +
> + ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsTemplate));
> + if (IsSlaveSocketActive ()) {
> + Size += ((SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsTemplate));
> + } else if (!IsSlaveSocketPresent ()) {
> + Size += 2 * sizeof (GicItsTemplate); /* RCA0/1 */
> + }
> +
> + MadtTablePointer =
> + (EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)AllocateZeroPool (Size);
> + if (MadtTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + GiccEntryPointer =
> + (EFI_ACPI_6_3_GIC_STRUCTURE *)((UINT64)MadtTablePointer +
> + sizeof (MADTTableHeaderTemplate));
> +
> + /* Install Gic interface for each processor */
> + Size = 0;
> + CoreOrder = CpuGetCoreOrder ();
> + ASSERT (CoreOrder != NULL);
> + SktMaxCoreNum = PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM;
> + for (Index = 0; Index < SktMaxCoreNum; Index++) {
> + if (IsCpuEnabled (CoreOrder[Index])) {
> + Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index]);
> + }
> + }
> +
> + for (Index = 0; Index < SktMaxCoreNum; Index++) {
> + if (IsCpuEnabled (CoreOrder[Index] + SktMaxCoreNum)) {
> + Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index] + SktMaxCoreNum);
> + }
> + }
> +
> + /* Install Gic Distributor */
> + Size += AcpiInstallMadtGicD ((VOID *)((UINT64)GiccEntryPointer + Size));
> +
> + /* Install Gic Redistributor */
> + for (Index = 0; Index < PLATFORM_CPU_MAX_SOCKET; Index++) {
> + Size += AcpiInstallMadtGicR ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
> + }
> +
> + /* Install Gic ITS */
> + if (!IsSlaveSocketPresent ()) {
> + for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
> + }
> + }
> + for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
> + }
> + if (IsSlaveSocketActive ()) {
> + for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
> + }
> + }
> + CopyMem (
> + MadtTablePointer,
> + &MADTTableHeaderTemplate,
> + sizeof (MADTTableHeaderTemplate)
> + );
> +
> + Size += sizeof (MADTTableHeaderTemplate);
> + MadtTablePointer->Header.Length = Size;
> + CopyMem (
> + MadtTablePointer->Header.OemId,
> + PcdGetPtr (PcdAcpiDefaultOemId),
> + sizeof (MadtTablePointer->Header.OemId)
> + );
> +
> + AcpiTableChecksum (
> + (UINT8 *)MadtTablePointer,
> + MadtTablePointer->Header.Length
> + );
> +
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)MadtTablePointer,
> + MadtTablePointer->Header.Length,
> + &MadtTableKey
> + );
> + FreePool ((VOID *)MadtTablePointer);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
> new file mode 100644
> index 000000000000..d13ac3514e11
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
> @@ -0,0 +1,599 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "AcpiNfit.h"
> +#include "AcpiPlatform.h"
> +
> +EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE NfitSPATemplate = {
> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE,
> + sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE),
> + 0, // The uniue index - need to be filled.
> + 0, // The flags - need to be filled.
> + 0, // Reserved.
> + 0, // Proximity domain - need to be filled.
> + EFI_ACPI_6_3_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION, // PM range type.
> + 0, // Start address - need to be filled.
> + 0, // Size - need to be filled.
> + EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB |
> + EFI_MEMORY_WP | EFI_MEMORY_UCE, // attribute - need to be filled.
> +};
> +
> +EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE NvdimmControlRegionTemplate = {
> + EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE_TYPE,
> + sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE),
> + 0, // The unique index - need to be filled.
> + 0, // The vendor id - need to be filled.
> + 0, // The device id - need to be filled.
> + 0, // The revision - need to be filled.
> + 0, // The subsystem nvdimm id - need to be filled.
> + 0, // The subsystem nvdimm device id - need to be filled.
> + 0, // The subsystem revision - need to be filled.
> + 0, // The valid field.
> + 0, // The manufacturing location - not valid.
> + 0, // The manufacturing date - not valid.
> + {0}, // Reserved.
> + 0, // The serial number - need to be filled.
> + 0, // The region format interface code - dummy value.
> + 0, // The number of block control windows.
> + 0, // The size of block control windows.
> + 0, // The Command Register Offset in Block Control Window.
> + 0, // The Size of Command Register in Block Control Windows.
> + 0, // The Status Register Offset in Block Control Window.
> + 0, // Size of Status Register in Block Control Windows.
> + 0, // The NVDIMM Control Region Flag.
> + {0}, // Reserved.
> +};
> +
> +EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE NvdimmRegionMappingTemplate = {
> + EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE_TYPE,
> + sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE),
> + {0}, // _ADR of the NVDIMM device - need to be filled.
> + 0, // Dimm smbios handle index - need to be filled.
> + 0, // The unique region index - need to be filled.
> + 0, // The SPA range index - need to be filled.
> + 0, // The control region index - need to be filled.
> + 0, // The region size - need to be filled.
> + 0, // The region offset - need to be filled.
> + 0, // The region base - need to be filled.
> + 0, // The interleave structure index - need to be filled.
> + 0, // The interleave ways - need to be filled.
> + 0, // NVDIMM flags - need to be filled.
> + 0, // Reserved.
> +};
> +
> +EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE NFITTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE,
> + 0, /* need fill in */
> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION
> + ),
> + 0x00000000, // Reserved
> +};
> +
> +NVDIMM_DATA NvdData[PLATFORM_CPU_MAX_SOCKET] = { 0 };
> +
> +EFI_STATUS
> +AcpiNvdInfoInit (
> + IN OUT NVDIMM_INFO *NvdInfoPtr,
> + IN UINTN NvdId
> + )
> +{
> + PLATFORM_INFO_HOB *PlatformHob;
> + VOID *Hob;
> +
> + /* Get the Platform HOB */
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL || NvdInfoPtr == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + NvdInfoPtr->Enabled = TRUE;
> + NvdInfoPtr->PhysId = NvdId;
> + NvdInfoPtr->NvdSize = PlatformHob->DimmList.Dimm[NvdId].Info.DimmSize * ONE_GB;
> + NvdInfoPtr->VendorId =
> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[320]);
> + NvdInfoPtr->DeviceId =
> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[192]);
> + NvdInfoPtr->RevisionId =
> + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[349];
> + NvdInfoPtr->SubVendorId =
> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[194]);
> + NvdInfoPtr->SubDeviceId =
> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[196]);
> + NvdInfoPtr->SubRevisionId =
> + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[198];
> + NvdInfoPtr->SerialNumber =
> + *((UINT32 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[325]);
> +
> + return EFI_SUCCESS;
> +}
> +
> +EFI_STATUS
> +AcpiNvdDataInit (
> + IN UINTN Socket
> + )
> +{
> + PLATFORM_INFO_HOB *PlatformHob;
> + NVDIMM_INFO *NvdInfo;
> + UINTN Count;
> + VOID *Hob;
> + UINTN NvdRegionNum, RegionId;
> +
> + /* Get the Platform HOB */
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + NvdRegionNum = 0;
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + if (PlatformHob->DramInfo.NvdRegion[Count] != 0
> + && (PlatformHob->DramInfo.Socket[Count] == Socket))
> + {
> + NvdData[Socket].NvdRegionId[NvdRegionNum] = Count;
> + NvdRegionNum++;
> + }
> + }
> + if (NvdRegionNum == 0) {
> + return EFI_SUCCESS;
> + }
> +
> + NvdData[Socket].NvdRegionNum = NvdRegionNum;
> + NvdData[Socket].NvdMode = PlatformHob->DramInfo.NvdimmMode[Socket];
> + if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
> + NvdInfo = &NvdData[Socket].NvdInfo[NVDIMM_SK0];
> + NvdInfo->DeviceHandle =
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
> + PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
> + NvdInfo->RegionOffset = 0;
> + AcpiNvdInfoInit (
> + NvdInfo,
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
> + PLATFORM_NVDIMM_NVD3_DIMM_ID
> + );
> +
> + NvdInfo = &NvdData[Socket].NvdInfo[1];
> + NvdInfo->DeviceHandle =
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
> + PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
> + NvdInfo->RegionOffset = PLATFORM_NVDIMM_HASHED_REGION_OFFSET;
> + AcpiNvdInfoInit (
> + NvdInfo,
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
> + PLATFORM_NVDIMM_NVD4_DIMM_ID
> + );
> +
> + /* Update NvdNum */
> + NvdData[Socket].NvdNum = 0;
> + for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
> + if (NvdData[Socket].NvdInfo[Count].Enabled) {
> + NvdData[Socket].NvdNum++;
> + }
> + }
> + return EFI_SUCCESS;
> + }
> + /* NVDIMM_NON_HASHED */
> + NvdData[Socket].NvdNum = 0;
> + for (Count = 0; Count < NvdData[Socket].NvdRegionNum; Count++) {
> + RegionId = NvdData[Socket].NvdRegionId[Count];
> + if (PlatformHob->DramInfo.Base[RegionId] ==
> + PLATFORM_NVDIMM_SK0_NHASHED_REGION0 ||
> + PlatformHob->DramInfo.Base[RegionId] ==
> + PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
> + {
> + NvdInfo = &NvdData[Socket].NvdInfo[0];
> + NvdInfo->DeviceHandle =
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
> + PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
> + NvdInfo->RegionOffset = 0;
> + AcpiNvdInfoInit (
> + NvdInfo,
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
> + PLATFORM_NVDIMM_NVD3_DIMM_ID
> + );
> +
> + } else if (PlatformHob->DramInfo.Base[RegionId] ==
> + PLATFORM_NVDIMM_SK0_NHASHED_REGION1 ||
> + PlatformHob->DramInfo.Base[RegionId] ==
> + PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
> + {
> + NvdInfo = &NvdData[Socket].NvdInfo[1];
> + NvdInfo->DeviceHandle =
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
> + PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
> + NvdInfo->RegionOffset = 0;
> + AcpiNvdInfoInit (
> + NvdInfo,
> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
> + PLATFORM_NVDIMM_NVD4_DIMM_ID
> + );
> + }
> + }
> + /* Update NvdNum */
> + NvdData[Socket].NvdNum = 0;
> + for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
> + if (NvdData[Socket].NvdInfo[Count].Enabled) {
> + NvdData[Socket].NvdNum++;
> + }
> + }
> + return EFI_SUCCESS;
> +}
> +
> +/*
> + * Fill in SPA structure
> + */
> +VOID
> +AcpiNfitFillSPA (
> + IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
> + IN UINTN NvdRegionIndex,
> + IN UINT64 NvdRegionBase,
> + IN UINT64 NvdRegionSize
> + )
> +{
> + ASSERT (NfitSpaPointer != NULL);
> +
> + NfitSpaPointer->Flags = 0;
> + NfitSpaPointer->SPARangeStructureIndex = NvdRegionIndex;
> + NfitSpaPointer->SystemPhysicalAddressRangeBase = NvdRegionBase;
> + NfitSpaPointer->SystemPhysicalAddressRangeLength = NvdRegionSize;
> +}
> +
> +VOID
> +NfitFillControlRegion (
> + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
> + IN NVDIMM_INFO *NvdInfo,
> + IN UINTN NvdControlRegionIndex
> + )
> +{
> + ASSERT (
> + NfitControlRegionPointer != NULL
> + && NvdInfo != NULL
> + );
> +
> + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex =
> + NvdControlRegionIndex;
> + NfitControlRegionPointer->VendorID = NvdInfo->VendorId;
> + NfitControlRegionPointer->DeviceID = NvdInfo->DeviceId;
> + NfitControlRegionPointer->RevisionID = NvdInfo->RevisionId;
> + NfitControlRegionPointer->SubsystemVendorID = NvdInfo->SubVendorId;
> + NfitControlRegionPointer->SubsystemDeviceID = NvdInfo->SubDeviceId;
> + NfitControlRegionPointer->SubsystemRevisionID = NvdInfo->SubRevisionId;
> + NfitControlRegionPointer->SerialNumber = NvdInfo->SerialNumber;
> +}
> +
> +VOID
> +NfitFillRegionMapping (
> + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer,
> + IN EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
> + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
> + IN NVDIMM_INFO *NvdInfo,
> + IN UINTN NvdRegionID
> + )
> +{
> + ASSERT (
> + NfitRegionMappingPointer != NULL
> + && NfitRegionMappingPointer != NULL
> + && NfitRegionMappingPointer != NULL
> + && NfitRegionMappingPointer != NULL
> + && NvdInfo != NULL
> + );
> +
> + NfitRegionMappingPointer->NVDIMMRegionID = NvdRegionID;
> + NfitRegionMappingPointer->NVDIMMPhysicalID = NvdInfo->PhysId;
> + NfitRegionMappingPointer->InterleaveWays = NvdInfo->InterleaveWays;
> + NfitRegionMappingPointer->RegionOffset = NvdInfo->RegionOffset;
> + NfitRegionMappingPointer->NVDIMMRegionSize = NvdInfo->NvdSize;
> + NfitRegionMappingPointer->NFITDeviceHandle.DIMMNumber =
> + NvdInfo->DeviceHandle & 0x0F;
> + NfitRegionMappingPointer->NFITDeviceHandle.MemoryChannelNumber =
> + (NvdInfo->DeviceHandle >> 4) & 0x0F;
> + NfitRegionMappingPointer->NFITDeviceHandle.MemoryControllerID =
> + (NvdInfo->DeviceHandle >> 8) & 0x0F;
> + NfitRegionMappingPointer->NFITDeviceHandle.SocketID =
> + (NvdInfo->DeviceHandle >> 12) & 0x0F;
> + NfitRegionMappingPointer->SPARangeStructureIndex =
> + NfitSpaPointer->SPARangeStructureIndex;
> + NfitRegionMappingPointer->NVDIMMPhysicalAddressRegionBase =
> + NfitSpaPointer->SystemPhysicalAddressRangeBase;
> + NfitRegionMappingPointer->NVDIMMControlRegionStructureIndex =
> + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex;
> +}
> +
> +EFI_STATUS
> +AcpiNfitFillTableBySK (
> + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerStart,
> + IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE **NfitSpaPointerNext,
> + IN UINTN Socket
> + )
> +{
> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer;
> + EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer;
> + EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer;
> + PLATFORM_INFO_HOB *PlatformHob;
> + VOID *Hob;
> + UINT64 NvdRegionBase,
> + NvdRegionSize;
> + UINTN NvdCount, MaxNvdCount, RegionCount;
> + UINTN RegionId, NvdRegionIndex, NvdIndex;
> +
> + /* Get the Platform HOB */
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL
> + || NfitSpaPointerStart == NULL
> + || NfitSpaPointerNext == NULL)
> + {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> + NvdRegionIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdRegionNum;
> + NvdIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdNum;
> + if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
> + /* Table Type 0: SPA Range Structure */
> + NfitSpaPointer = NfitSpaPointerStart;
> + CopyMem (
> + (VOID *)NfitSpaPointer,
> + (VOID *)&NfitSPATemplate,
> + sizeof (NfitSPATemplate)
> + );
> + RegionId = NvdData[Socket].NvdRegionId[0];
> + NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
> + NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
> + NvdRegionIndex++;
> + AcpiNfitFillSPA (
> + NfitSpaPointer,
> + NvdRegionIndex,
> + NvdRegionBase,
> + NvdRegionSize
> + );
> +
> + NfitControlRegionPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
> + (NfitSpaPointer + 1);
> + for (NvdCount = 0; NvdCount < NVDIMM_NUM_PER_SK; NvdCount++) {
> + if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
> + continue;
> + }
> + NvdIndex++;
> + /* Table Type 4: NVDIMM Control Region Structure Mark */
> + CopyMem (
> + (VOID *)NfitControlRegionPointer,
> + (VOID *)&NvdimmControlRegionTemplate,
> + sizeof (NvdimmControlRegionTemplate)
> + );
> + NfitFillControlRegion (
> + NfitControlRegionPointer,
> + &NvdData[Socket].NvdInfo[NvdCount],
> + NvdIndex
> + );
> +
> + NfitRegionMappingPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
> + (NfitControlRegionPointer + 1);
> +
> + /* Table Type 1: NVDIMM Region Mapping Structure */
> + CopyMem (
> + (VOID *)NfitRegionMappingPointer,
> + (VOID *)&NvdimmRegionMappingTemplate,
> + sizeof (NvdimmRegionMappingTemplate)
> + );
> + NfitFillRegionMapping (
> + NfitRegionMappingPointer,
> + NfitControlRegionPointer,
> + NfitSpaPointer,
> + &NvdData[Socket].NvdInfo[NvdCount],
> + NvdIndex - 1
> + );
> +
> + NfitControlRegionPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
> + (NfitRegionMappingPointer + 1);
> + }
> + NfitSpaPointer =
> + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
> + NfitControlRegionPointer;
> + } else { /* NVDIMM_NON_HASHED */
> + NfitSpaPointer = NfitSpaPointerStart;
> + for (RegionCount = 0; RegionCount < NvdData[Socket].NvdRegionNum;
> + RegionCount++)
> + {
> + /* Table Type 0: SPA Range Structure */
> + CopyMem (
> + (VOID *)NfitSpaPointer,
> + (VOID *)&NfitSPATemplate,
> + sizeof (NfitSPATemplate)
> + );
> + RegionId = NvdData[Socket].NvdRegionId[RegionCount];
> + NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
> + NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
> + NvdRegionIndex++;
> + AcpiNfitFillSPA (
> + NfitSpaPointer,
> + NvdRegionIndex,
> + NvdRegionBase,
> + NvdRegionSize
> + );
> +
> + NfitControlRegionPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
> + (NfitSpaPointer + 1);
> + NvdCount = ((NvdRegionBase == PLATFORM_NVDIMM_SK0_NHASHED_REGION0) ||
> + (NvdRegionBase == PLATFORM_NVDIMM_SK1_NHASHED_REGION0)) ?
> + 0 : PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
> + MaxNvdCount = NvdCount + PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
> + for (; NvdCount < MaxNvdCount; NvdCount++) {
> + if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
> + continue;
> + }
> + NvdIndex++;
> +
> + /* Table Type 4: NVDIMM Control Region Structure Mark */
> + CopyMem (
> + (VOID *)NfitControlRegionPointer,
> + (VOID *)&NvdimmControlRegionTemplate,
> + sizeof (NvdimmControlRegionTemplate)
> + );
> + NfitFillControlRegion (
> + NfitControlRegionPointer,
> + &NvdData[Socket].NvdInfo[NvdCount],
> + NvdIndex
> + );
> +
> + NfitRegionMappingPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
> + (NfitControlRegionPointer + 1);
> +
> + /* Table Type 1: NVDIMM Region Mapping Structure */
> + CopyMem (
> + (VOID *)NfitRegionMappingPointer,
> + (VOID *)&NvdimmRegionMappingTemplate,
> + sizeof (NvdimmRegionMappingTemplate)
> + );
> + NfitFillRegionMapping (
> + NfitRegionMappingPointer,
> + NfitControlRegionPointer,
> + NfitSpaPointer,
> + &NvdData[Socket].NvdInfo[NvdCount],
> + NvdIndex - 1
> + );
> +
> + NfitControlRegionPointer =
> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
> + (NfitRegionMappingPointer + 1);
> + }
> + NfitSpaPointer =
> + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
> + NfitControlRegionPointer;
> + }
> + }
> + /* Update NfitSpaPointerNext */
> + *NfitSpaPointerNext = NfitSpaPointer;
> +
> + return EFI_SUCCESS;
> +}
> +
> +EFI_STATUS
> +AcpiNfitFillTable (
> + IN EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer
> + )
> +{
> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerNext;
> +
> + if (NfitTablePointer == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + NfitSpaPointerNext = (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
> + (NfitTablePointer + 1);
> +
> + if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
> + AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK0);
> + }
> +
> + if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
> + AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK1);
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +/*
> + * Install NFIT table.
> + */
> +EFI_STATUS
> +AcpiInstallNfitTable (
> + VOID
> + )
> +{
> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer;
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + UINTN NfitTableKey = 0;
> + EFI_STATUS Status;
> + UINTN Size;
> + UINTN NvdRegionNum;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> + Status = AcpiNvdDataInit (NVDIMM_SK0);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> + Status = AcpiNvdDataInit (NVDIMM_SK1);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> + NvdRegionNum = NvdData[NVDIMM_SK0].NvdRegionNum +
> + NvdData[NVDIMM_SK1].NvdRegionNum;
> + if (NvdRegionNum == 0) {
> + return EFI_INVALID_PARAMETER; /* No NVDIMM Region */
> + }
> + Size = sizeof (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE);
> + if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
> + Size +=
> + (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
> + NvdData[NVDIMM_SK0].NvdRegionNum) +
> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
> + NvdData[NVDIMM_SK0].NvdNum) +
> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
> + NvdData[NVDIMM_SK0].NvdNum);
> + }
> + if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
> + Size +=
> + (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
> + NvdData[NVDIMM_SK1].NvdRegionNum) +
> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
> + NvdData[NVDIMM_SK1].NvdNum) +
> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
> + NvdData[NVDIMM_SK1].NvdNum);
> + }
> + NfitTablePointer =
> + (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *)AllocateZeroPool (Size);
> + if (NfitTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> + CopyMem (
> + (VOID *)NfitTablePointer,
> + (VOID *)&NFITTableHeaderTemplate,
> + sizeof (NFITTableHeaderTemplate)
> + );
> +
> + NfitTablePointer->Header.Length = Size;
> +
> + Status = AcpiNfitFillTable (NfitTablePointer);
> + if (EFI_ERROR (Status)) {
> + FreePool ((VOID *)NfitTablePointer);
> + return Status;
> + }
> + AcpiTableChecksum (
> + (UINT8 *)NfitTablePointer,
> + NfitTablePointer->Header.Length
> + );
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)NfitTablePointer,
> + NfitTablePointer->Header.Length,
> + &NfitTableKey
> + );
> + if (EFI_ERROR (Status)) {
> + FreePool ((VOID *)NfitTablePointer);
> + }
> + return Status;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
> new file mode 100644
> index 000000000000..296ae57aada0
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
> @@ -0,0 +1,196 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Library/AcpiPccLib.h>
> +#include "AcpiPlatform.h"
> +
> +EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS PcctSubspaceTemplate = {
> + EFI_ACPI_6_3_PCCT_SUBSPACE_TYPE_2_HW_REDUCED_COMMUNICATIONS,
> + sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS),
> + 0, // PlatformInterrupt
> + 0, // PlatformInterruptFlags
> + 0, // Reserved
> + 0, // BaseAddress
> + 0x100, // AddressLength
> + { 0, 0x20, 0, 0x3, 0x0 }, // DoorbellRegister
> + 0, // DoorbellPreserve
> + 0x53000040, // DoorbellWrite
> + 1, // NominalLatency
> + 1, // MaximumPeriodicAccessRate
> + 1, // MinimumRequestTurnaroundTime
> + { 0, 0x20, 0, 0x3, 0x0 }, // PlatformInterruptAckRegister
> + 0, // PlatformInterruptAckPreserve
> + 0x10001, // PlatformInterruptAckWrite
> +};
> +
> +EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER PcctTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_PLATFORM_COMMUNICATIONS_CHANNEL_TABLE_SIGNATURE,
> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER,
> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION
> + ),
> + EFI_ACPI_6_3_PCCT_FLAGS_PLATFORM_INTERRUPT,
> +};
> +
> +EFI_STATUS
> +AcpiPcctInit (
> + VOID
> + )
> +{
> + UINT8 NumberOfSockets;
> + UINT8 Socket;
> + UINT16 Doorbell;
> + UINT16 Subspace;
> +
> + NumberOfSockets = GetNumberOfActiveSockets ();
> + Subspace = 0;
> +
> + for (Socket = 0; Socket < NumberOfSockets; Socket++) {
> + for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
> + if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
> + continue;
> + }
> + AcpiPccInitSharedMemory (Socket, Doorbell, Subspace);
> + AcpiPccUnmaskDoorbellInterrupt (Socket, Doorbell);
> +
> + Subspace++;
> + }
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + Install PCCT table.
> +
> + Each socket has 16 PCC subspaces corresponding to 16 Mailbox/Doorbell channels
> + 0 - 7 : PMpro subspaces
> + 8 - 15 : SMpro subspaces
> +
> + Please note that some SMpro/PMpro Doorbell are reserved for private use.
> + The reserved Doorbells are filtered by using the ACPI_PCC_AVAILABLE_DOORBELL_MASK
> + and ACPI_PCC_NUMBER_OF_RESERVED_DOORBELLS macro.
> +
> +**/
> +EFI_STATUS
> +AcpiInstallPcctTable (
> + VOID
> + )
> +{
> + EFI_STATUS Status;
> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *PcctTablePointer;
> + EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *PcctEntryPointer;
> + EFI_PHYSICAL_ADDRESS PccSharedMemPointer;
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + UINTN PcctTableKey;
> + UINT8 NumberOfSockets;
> + UINT8 Socket;
> + UINT16 Doorbell;
> + UINT16 Subspace;
> + UINT16 NumberOfSubspaces;
> + UINTN Size;
> + UINTN DoorbellAddress;
> +
> + Subspace = 0;
> + NumberOfSockets = GetNumberOfActiveSockets ();
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + NumberOfSubspaces = ACPI_PCC_MAX_SUBPACE_PER_SOCKET * NumberOfSockets;
> +
> + AcpiPccAllocateSharedMemory (&PccSharedMemPointer, NumberOfSubspaces);
> + if (PccSharedMemPointer == 0) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
> + NumberOfSubspaces * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
> +
> + PcctTablePointer = (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *)AllocateZeroPool (Size);
> + if (PcctTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + PcctEntryPointer = (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *)
> + ((UINT64)PcctTablePointer + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER));
> +
> + for (Socket = 0; Socket < NumberOfSockets; Socket++) {
> + for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
> + if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
> + continue;
> + }
> +
> + CopyMem (
> + &PcctEntryPointer[Subspace],
> + &PcctSubspaceTemplate,
> + sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS)
> + );
> +
> + PcctEntryPointer[Subspace].BaseAddress = (UINT64)PccSharedMemPointer + ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE * Subspace;
> + PcctEntryPointer[Subspace].AddressLength = ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE;
> +
> + DoorbellAddress = MailboxGetDoorbellAddress (Socket, Doorbell);
> +
> + PcctEntryPointer[Subspace].DoorbellRegister.Address = DoorbellAddress + DB_OUT_REG_OFST;
> + PcctEntryPointer[Subspace].PlatformInterrupt = MailboxGetDoorbellInterruptNumber (Socket, Doorbell);
> + PcctEntryPointer[Subspace].PlatformInterruptAckRegister.Address = DoorbellAddress + DB_STATUS_REG_OFST;
> +
> + if (Doorbell == ACPI_PCC_CPPC_DOORBELL_ID) {
> + PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_URGENT_CPPC_MESSAGE;
> + PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_CPPC_NOMINAL_LATENCY_US;
> + PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_CPPC_MIN_REQ_TURNAROUND_TIME_US;
> + } else {
> + PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_TYPICAL_PCC_MESSAGE;
> + PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_NOMINAL_LATENCY_US;
> + PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_MIN_REQ_TURNAROUND_TIME_US;
> + }
> + PcctEntryPointer[Subspace].MaximumPeriodicAccessRate = ACPI_PCC_MAX_PERIODIC_ACCESS_RATE;
> +
> + Subspace++;
> + }
> + }
> +
> + CopyMem (
> + PcctTablePointer,
> + &PcctTableHeaderTemplate,
> + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER)
> + );
> +
> + //
> + // Recalculate the size
> + //
> + Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
> + Subspace * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
> +
> + PcctTablePointer->Header.Length = Size;
> + AcpiTableChecksum (
> + (UINT8 *)PcctTablePointer,
> + PcctTablePointer->Header.Length
> + );
> +
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)PcctTablePointer,
> + PcctTablePointer->Header.Length,
> + &PcctTableKey
> + );
> + if (EFI_ERROR (Status)) {
> + AcpiPccFreeSharedMemory ();
> + FreePool ((VOID *)PcctTablePointer);
> + return Status;
> + }
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
> new file mode 100644
> index 000000000000..3ed3e98d00d2
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
> @@ -0,0 +1,178 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "AcpiApei.h"
> +#include "AcpiPlatform.h"
> +
> +STATIC EFI_EVENT mAcpiRegistration = NULL;
> +
> +/*
> + * This GUID must match the FILE_GUID in AcpiTables.inf of each boards
> + */
> +STATIC CONST EFI_GUID mAcpiCommonTableFile = { 0xCEFA2AEB, 0x357E, 0x4F48, { 0x80, 0x66, 0xEA, 0x95, 0x08, 0x53, 0x05, 0x6E } } ;
> +STATIC CONST EFI_GUID mJadeAcpiTableFile = { 0x5addbc13, 0x8634, 0x480c, { 0x9b, 0x94, 0x67, 0x1b, 0x78, 0x55, 0xcd, 0xb8 } };
> +/**
> + * Callback called when ACPI Protocol is installed
> + */
> +STATIC VOID
> +AcpiNotificationEvent (
> + IN EFI_EVENT Event,
> + IN VOID *Context
> + )
> +{
> + EFI_STATUS Status;
> + EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp;
> +
> + Status = LocateAndInstallAcpiFromFv (&mAcpiCommonTableFile);
> + ASSERT_EFI_ERROR (Status);
> +
> + Status = LocateAndInstallAcpiFromFv (&mJadeAcpiTableFile);
> + ASSERT_EFI_ERROR (Status);
> +
> + //
> + // Find ACPI table RSD_PTR from the system table.
> + //
> + Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **)&Rsdp);
> + if (EFI_ERROR (Status)) {
> + Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **)&Rsdp);
> + }
> +
> + if (!EFI_ERROR (Status) &&
> + Rsdp != NULL &&
> + Rsdp->Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION &&
> + Rsdp->RsdtAddress != 0)
> + {
> + // ARM Platforms must set the RSDT address to NULL
> + Rsdp->RsdtAddress = 0;
> + }
> +
> + DEBUG ((DEBUG_INFO, "[%a:%d]-\n", __FUNCTION__, __LINE__));
> +}
> +
> +VOID
> +EFIAPI
> +InstallAcpiOnReadyToBoot (
> + IN EFI_EVENT Event,
> + IN VOID *Context
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = AcpiInstallMadtTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Installed MADT table\n"));
> + }
> +
> + Status = AcpiInstallPpttTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Installed PPTT table\n"));
> + }
> +
> + Status = AcpiInstallSlitTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Installed SLIT table\n"));
> + }
> +
> + Status = AcpiInstallSratTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Installed SRAT table\n"));
> + }
> +
> + Status = AcpiInstallPcctTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Installed PCCT table\n"));
> + }
> +
> + Status = AcpiInstallNfitTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR, "Installed NFIT table\n"));
> + }
> +
> + Status = AcpiPopulateBert ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "Populate BERT record\n"));
> + }
> +
> + //
> + // Close the event, so it will not be signalled again.
> + //
> + gBS->CloseEvent (Event);
> +}
> +
> +VOID
> +EFIAPI
> +UpdateAcpiOnExitBootServices (
> + IN EFI_EVENT Event,
> + IN VOID *Context
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = AcpiPatchDsdtTable ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "DSDT Table updated!\n"));
> + }
> +
> + // Configure ACPI Platform Error Interfaces
> + Status = AcpiApeiUpdate ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "APEI Table updated!\n"));
> + }
> +
> + // Configure PCC mailbox base address and unmask interrupt
> + Status = AcpiPcctInit ();
> + if (!EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_INFO, "PCCT Table updated!\n"));
> + }
> +
> + //
> + // Close the event, so it will not be signalled again.
> + //
> + gBS->CloseEvent (Event);
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +AcpiPlatformDxeInitialize (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + EFI_EVENT ReadyToBootEvent;
> + EFI_EVENT ExitBootServicesEvent;
> + EFI_STATUS Status;
> +
> + EfiCreateProtocolNotifyEvent (
> + &gEfiAcpiTableProtocolGuid,
> + TPL_CALLBACK,
> + AcpiNotificationEvent,
> + NULL,
> + &mAcpiRegistration
> + );
> +
> + Status = gBS->CreateEvent (
> + EVT_SIGNAL_EXIT_BOOT_SERVICES,
> + TPL_CALLBACK,
> + UpdateAcpiOnExitBootServices,
> + NULL,
> + &ExitBootServicesEvent
> + );
> + ASSERT_EFI_ERROR (Status);
> +
> + Status = gBS->CreateEventEx (
> + EVT_NOTIFY_SIGNAL,
> + TPL_CALLBACK,
> + InstallAcpiOnReadyToBoot,
> + NULL,
> + &gEfiEventReadyToBootGuid,
> + &ReadyToBootEvent
> + );
> + ASSERT_EFI_ERROR (Status);
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
> new file mode 100644
> index 000000000000..97adb66beed3
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
> @@ -0,0 +1,378 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "AcpiPlatform.h"
> +
> +EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR PPTTProcessorTemplate = {
> + EFI_ACPI_6_3_PPTT_TYPE_PROCESSOR,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR),
> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
> + {0}, /* Flags */
> + 0, /* Parent */
> + 0, /* AcpiProcessorId */
> + 0 /* NumberOfPrivateResources */
> +};
> +
> +EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE PPTTCacheTemplate = {
> + EFI_ACPI_6_3_PPTT_TYPE_CACHE,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE),
> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
> + {0}, /* Flags */
> + 0, /* NextLevelOfCache */
> + 0, /* Size */
> + 0, /* NumberOfSets */
> + 0, /* Associativity */
> + {0}, /* Attributes */
> + 0
> +};
> +
> +EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER PPTTTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_STRUCTURE_SIGNATURE,
> + 0, /* need fill in */
> + EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_REVISION
> + ),
> +};
> +
> +STATIC EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *PpttTablePointer;
> +STATIC UINT32 PpttClusterOffset[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET];
> +STATIC UINT32 PpttSocketOffset[PLATFORM_CPU_MAX_SOCKET];
> +STATIC UINT32 PpttRootOffset;
> +STATIC UINT32 PpttL1DataCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
> +STATIC UINT32 PpttL1InstructionCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
> +STATIC UINT32 PpttL2CacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
> +STATIC UINT32 PpttSLCCacheOffset[PLATFORM_CPU_MAX_SOCKET];
> +
> +UINT32
> +AcpiPpttProcessorCoreNode (
> + VOID *EntryPointer,
> + UINT32 CpuId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
> + UINT32 *ResPointer;
> + UINTN ClusterIdPerSocket, CoreIdPerCpm, SocketId;
> +
> + CopyMem (
> + PpttProcessorEntryPointer,
> + &PPTTProcessorTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
> + );
> +
> + ClusterIdPerSocket = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) % PLATFORM_CPU_MAX_CPM;
> + SocketId = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) / PLATFORM_CPU_MAX_CPM;
> + CoreIdPerCpm = CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM;
> + PpttProcessorEntryPointer->Flags.AcpiProcessorIdValid = 1;
> + PpttProcessorEntryPointer->Flags.NodeIsALeaf = 1;
> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
> + PpttProcessorEntryPointer->AcpiProcessorId = (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) | (ClusterIdPerSocket << 8) | CoreIdPerCpm;
> + PpttProcessorEntryPointer->Parent = (UINT32)PpttClusterOffset[CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM];
> + PpttProcessorEntryPointer->NumberOfPrivateResources = 2; /* L1I + L1D */
> +
> + ResPointer = (UINT32 *)((UINT64)EntryPointer +
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
> + ResPointer[0] = PpttL1InstructionCacheOffset[CpuId];
> + ResPointer[1] = PpttL1DataCacheOffset[CpuId];
> +
> + PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32);
> +
> + return PpttProcessorEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttClusterNode (
> + VOID *EntryPointer,
> + UINT32 ClusterId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
> +
> + PpttClusterOffset[ClusterId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> +
> + CopyMem (
> + PpttProcessorEntryPointer,
> + &PPTTProcessorTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
> + );
> +
> + PpttProcessorEntryPointer->Parent = (UINT32)PpttSocketOffset[ClusterId / PLATFORM_CPU_MAX_CPM];
> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
> +
> + return PpttProcessorEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttSocketNode (
> + VOID *EntryPointer,
> + UINT32 SocketId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
> + UINT32 *ResPointer;
> +
> + PpttSocketOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> +
> + CopyMem (
> + PpttProcessorEntryPointer,
> + &PPTTProcessorTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
> + );
> +
> + PpttProcessorEntryPointer->Flags.PhysicalPackage = 1;
> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
> + PpttProcessorEntryPointer->Parent = (UINT32)PpttRootOffset;
> +
> + PpttProcessorEntryPointer->NumberOfPrivateResources = 1;
> + ResPointer = (UINT32 *)((UINT64)EntryPointer + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
> + ResPointer[0] = PpttSLCCacheOffset[SocketId];
> +
> + PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32);
> +
> + return PpttProcessorEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttRootNode (
> + VOID *EntryPointer
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
> +
> + PpttRootOffset = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> +
> + CopyMem (
> + PpttProcessorEntryPointer,
> + &PPTTProcessorTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
> + );
> +
> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
> +
> + return PpttProcessorEntryPointer->Length;
> +}
> +
> +STATIC VOID
> +AcpiPpttFillCacheSizeInfo (
> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *Node,
> + UINT32 Level
> + )
> +{
> + UINT64 CacheCCSIDR;
> + UINT32 CacheLineSize;
> + UINT32 Count;
> +
> + CacheCCSIDR = ReadCCSIDR (Level);
> +
> + CacheLineSize = 1;
> + Count = CCSIDR_LINE_SIZE (CacheCCSIDR) + 4;
> + while (Count-- > 0) {
> + CacheLineSize *= 2;
> + }
> +
> + Node->Flags.LineSizeValid = 1;
> + Node->Flags.NumberOfSetsValid = 1;
> + Node->Flags.AssociativityValid = 1;
> + Node->Flags.SizePropertyValid = 1;
> + Node->Flags.CacheTypeValid = 1;
> + Node->NumberOfSets = CCSIDR_NUMSETS (CacheCCSIDR) + 1;
> + Node->Associativity = CCSIDR_ASSOCIATIVITY (CacheCCSIDR) + 1;
> + Node->LineSize = CacheLineSize;
> + Node->Size = Node->NumberOfSets *
> + Node->Associativity *
> + Node->LineSize;
> +}
> +
> +STATIC UINT32
> +AcpiPpttL1DataCacheNode (
> + VOID *EntryPointer,
> + UINT32 CpuId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
> +
> + PpttL1DataCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> + CopyMem (
> + PpttCacheEntryPointer,
> + &PPTTCacheTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
> + );
> +
> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
> + PpttCacheEntryPointer->Attributes.CacheType = 0x0; /* Data Cache */
> + PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
> +
> + return PpttCacheEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttL1InstructionCacheNode (
> + VOID *EntryPointer,
> + UINT32 CpuId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
> +
> + PpttL1InstructionCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> + CopyMem (
> + PpttCacheEntryPointer,
> + &PPTTCacheTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
> + );
> +
> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
> + PpttCacheEntryPointer->Attributes.CacheType = 0x1; /* Instruction Cache */
> + PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
> +
> + return PpttCacheEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttL2CacheNode (
> + VOID *EntryPointer,
> + UINT32 CpuId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
> +
> + PpttL2CacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> + CopyMem (
> + PpttCacheEntryPointer,
> + &PPTTCacheTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
> + );
> +
> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 2);
> + PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
> + PpttCacheEntryPointer->NextLevelOfCache = 0;
> +
> + return PpttCacheEntryPointer->Length;
> +}
> +
> +STATIC UINT32
> +AcpiPpttSLCCacheNode (
> + VOID *EntryPointer,
> + UINT32 SocketId
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
> +
> + PpttSLCCacheOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
> + CopyMem (
> + PpttCacheEntryPointer,
> + &PPTTCacheTemplate,
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
> + );
> +
> + PpttCacheEntryPointer->Flags.LineSizeValid = 1;
> + PpttCacheEntryPointer->Flags.NumberOfSetsValid = 1;
> + PpttCacheEntryPointer->Flags.AssociativityValid = 1;
> + PpttCacheEntryPointer->Flags.SizePropertyValid = 1;
> + PpttCacheEntryPointer->Flags.CacheTypeValid = 1;
> +
> + PpttCacheEntryPointer->Size = 0x2000000; /* 32 MB */
> + PpttCacheEntryPointer->NumberOfSets = 0x400; /* 1024 sets per 1MB HN-F */
> +
> + PpttCacheEntryPointer->Associativity = 0x10; /* 16-way set-associative */
> + PpttCacheEntryPointer->LineSize = 0x40; /* 64 bytes */
> + PpttCacheEntryPointer->NextLevelOfCache = 0;
> +
> + PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
> +
> + return PpttCacheEntryPointer->Length;
> +}
> +
> +/*
> + * Install PPTT table.
> + */
> +EFI_STATUS
> +AcpiInstallPpttTable (
> + VOID
> + )
> +{
> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = NULL;
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + UINTN PpttTableKey = 0;
> + UINTN Count;
> + EFI_STATUS Status;
> + UINTN Size;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + Size = sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER) +
> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + /* Root node */
> + (PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* SLC node */
> + (PLATFORM_CPU_MAX_SOCKET * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32))) + /* Socket node */
> + (PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)) + /* Cluster node */
> + (PLATFORM_CPU_MAX_NUM_CORES * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32))) + /* Core node */
> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1I node */
> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1D node */
> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)); /* L2 node */
> +
> + PpttTablePointer =
> + (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *)AllocateZeroPool (Size);
> + if (PpttTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + PpttProcessorEntryPointer =
> + (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *)((UINT64)PpttTablePointer +
> + sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER));
> +
> + Size = 0;
> + Size += AcpiPpttRootNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size));
> +
> + for (Count = 0; Count < PLATFORM_CPU_MAX_SOCKET; Count++) {
> + Size += AcpiPpttSLCCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + Size += AcpiPpttSocketNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + }
> +
> + for (Count = 0; Count < PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET; Count++) {
> + Size += AcpiPpttClusterNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + }
> +
> + for (Count = 0; Count < PLATFORM_CPU_MAX_NUM_CORES; Count++) {
> + Size += AcpiPpttL2CacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + Size += AcpiPpttL1InstructionCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + Size += AcpiPpttL1DataCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + Size += AcpiPpttProcessorCoreNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
> + }
> +
> + CopyMem (
> + PpttTablePointer,
> + &PPTTTableHeaderTemplate,
> + sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER)
> + );
> +
> + Size += sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER);
> + PpttTablePointer->Header.Length = Size;
> +
> + AcpiTableChecksum (
> + (UINT8 *)PpttTablePointer,
> + PpttTablePointer->Header.Length
> + );
> +
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)PpttTablePointer,
> + PpttTablePointer->Header.Length,
> + &PpttTableKey
> + );
> + FreePool ((VOID *)PpttTablePointer);
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + return EFI_SUCCESS;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
> new file mode 100644
> index 000000000000..60acdb9dd5db
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
> @@ -0,0 +1,190 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include "AcpiPlatform.h"
> +
> +#define MAX_NODES_PER_SOCKET 4
> +#define SELF_DISTANCE 10
> +#define REMOTE_DISTANCE 20
> +
> +EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER SLITTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE,
> + 0, /* need fill in */
> + EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION
> + ),
> + 0,
> +};
> +
> +VOID
> +ComputeCoordinatesForNode (
> + UINTN Node,
> + UINTN *X,
> + UINTN *Y
> + )
> +{
> + switch (Node) {
> + case 0:
> + *X = 0;
> + *Y = 0;
> + break;
> + case 1:
> + *X = 1;
> + *Y = 0;
> + break;
> + case 2:
> + *X = 0;
> + *Y = 1;
> + break;
> + case 3:
> + *X = 1;
> + *Y = 1;
> + break;
> + default:
> + *X = 0;
> + *Y = 0;
> + break;
> + }
> +}
> +
> +/**
> + Compute the distance between between two nodes on socket.
> +**/
> +UINT8
> +ComputeSlitDistanceOnSocket (
> + UINTN Node1,
> + UINTN Node2
> + )
> +{
> + UINTN X1, Y1, X2, Y2;
> + UINTN XDistance, YDistance;
> +
> + ComputeCoordinatesForNode (Node1, &X1, &Y1);
> + ComputeCoordinatesForNode (Node2, &X2, &Y2);
> +
> + XDistance = ABS ((INTN)(X1 - X2));
> + YDistance = ABS ((INTN)(Y1 - Y2));
> +
> + return (UINT8)(XDistance + YDistance + SELF_DISTANCE);
> +}
> +
> +/**
> + Compute the distance between between two nodes on
> + different sockets.
> + Node1 - local socket node number
> + Node2 - remote socket node number
> +**/
> +UINT8
> +ComputeSlitDistanceOnRemoteSocket (
> + UINTN LocalNode,
> + UINTN RemoteNode
> + )
> +{
> + UINTN LocalDistance, RemoteDistance;
> +
> + //
> + // Mesh forwards traffic between sockets over both CCIX links when going from
> + // one quadrant to another. For example, memory access from Node 0 to Node 4
> + // results in traffic being split between RCA0 and 1. Hence distance is
> + // different only between upper half and lower half of sockets and not
> + // between quadrants. Hemisphere configuration is not impacted as there
> + // is no upper-half.
> + //
> + LocalDistance = 0;
> + RemoteDistance = 0;
> + if (LocalNode >= (MAX_NODES_PER_SOCKET / 2)) {
> + LocalDistance = 1;
> + }
> + if (RemoteNode >= (MAX_NODES_PER_SOCKET / 2)) {
> + RemoteDistance = 1;
> + }
> +
> + return (UINT8)(LocalDistance + RemoteDistance + REMOTE_DISTANCE);
> +}
> +
> +UINT8
> +ComputeSlitDistance (
> + UINTN Node1,
> + UINTN Node2,
> + UINTN DomainsPerSocket
> + )
> +{
> + UINT8 Distance;
> +
> + Distance = 0;
> + if ((Node1 / DomainsPerSocket) == (Node2 / DomainsPerSocket)) {
> + Distance = ComputeSlitDistanceOnSocket (
> + Node1 % DomainsPerSocket,
> + Node2 % DomainsPerSocket
> + );
> + } else {
> + Distance = ComputeSlitDistanceOnRemoteSocket (
> + Node1 % DomainsPerSocket,
> + Node2 % DomainsPerSocket
> + );
> + }
> +
> + return Distance;
> +}
> +
> +EFI_STATUS
> +AcpiInstallSlitTable (
> + VOID
> + )
> +{
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + EFI_STATUS Status;
> + UINTN NumDomain, Count, Count1;
> + EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *SlitTablePointer;
> + UINT8 *TmpPtr;
> + UINTN SlitTableKey;
> + UINTN NumDomainPerSocket;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + NumDomainPerSocket = CpuGetNumberOfSubNumaRegion ();
> + NumDomain = NumDomainPerSocket * GetNumberOfActiveSockets ();
> +
> + SlitTablePointer = (EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *)
> + AllocateZeroPool (sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain);
> + if (SlitTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> + CopyMem ((VOID *)SlitTablePointer, (VOID *)&SLITTableHeaderTemplate, sizeof (SLITTableHeaderTemplate));
> + SlitTablePointer->NumberOfSystemLocalities = NumDomain;
> + TmpPtr = (UINT8 *)SlitTablePointer + sizeof (SLITTableHeaderTemplate);
> + for (Count = 0; Count < NumDomain; Count++) {
> + for (Count1 = 0; Count1 < NumDomain; Count1++, TmpPtr++) {
> + *TmpPtr = ComputeSlitDistance (Count, Count1, NumDomainPerSocket);
> + }
> + }
> +
> + SlitTablePointer->Header.Length = sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain;
> +
> + AcpiTableChecksum (
> + (UINT8 *)SlitTablePointer,
> + SlitTablePointer->Header.Length
> + );
> +
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)SlitTablePointer,
> + SlitTablePointer->Header.Length,
> + &SlitTableKey
> + );
> + FreePool ((VOID *)SlitTablePointer);
> +
> + return Status;
> +}
> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
> new file mode 100644
> index 000000000000..5f3b7007623a
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
> @@ -0,0 +1,274 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Guid/ArmMpCoreInfo.h>
> +#include "AcpiPlatform.h"
> +
> +EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER SRATTableHeaderTemplate = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE,
> + 0, /* need fill in */
> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION
> + ),
> + 0x00000001,
> + 0x0000000000000000,
> +};
> +
> +EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE GicItsAffinityTemplate = {
> + .Type = EFI_ACPI_6_3_GIC_ITS_AFFINITY,
> + sizeof (EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE),
> + .ProximityDomain = 0, /* ProximityDomain */
> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
> + .ItsId = 0,
> +};
> +
> +STATIC
> +UINTN
> +SratCalculateNumMemoryRegion (
> + VOID
> + )
> +{
> + PLATFORM_INFO_HOB *PlatformHob;
> + UINTN Count;
> + UINT64 TmpVal;
> + VOID *Hob;
> + UINTN Result;
> +
> + /* Get the Platform HOB */
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL) {
> + return 0;
> + }
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + Result = 0;
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + TmpVal = PlatformHob->DramInfo.Size[Count];
> + if (TmpVal > 0) {
> + Result++;
> + }
> + }
> +
> + return Result;
> +}
> +
> +STATIC
> +EFI_STATUS
> +SratAddMemAffinity (
> + EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *SratMemAffinity
> + )
> +{
> + PLATFORM_INFO_HOB *PlatformHob;
> + UINTN Count, NumRegion;
> + UINT64 RegionSize, RegionBase;
> + VOID *Hob;
> + UINTN ProximityDomain;
> +
> + /* Get the Platform HOB */
> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
> + if (Hob == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
> +
> + NumRegion = 0;
> +
> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
> + RegionSize = PlatformHob->DramInfo.Size[Count];
> + RegionBase = PlatformHob->DramInfo.Base[Count];
> + ProximityDomain = PlatformHob->DramInfo.Node[Count];
> + if (RegionSize > 0) {
> + ZeroMem ((VOID *)&SratMemAffinity[NumRegion], sizeof (SratMemAffinity[NumRegion]));
> + SratMemAffinity[NumRegion].Flags = EFI_ACPI_6_3_MEMORY_ENABLED;
> + if (PlatformHob->DramInfo.NvdRegion[Count] != 0) {
> + /* Mark NVDIMM-N region as HOT_PLUGGABLE and NON-VOLATILE */
> + SratMemAffinity[NumRegion].Flags |= EFI_ACPI_6_3_MEMORY_HOT_PLUGGABLE |
> + EFI_ACPI_6_3_MEMORY_NONVOLATILE;
> + }
> + SratMemAffinity[NumRegion].LengthLow =
> + (UINT32)(RegionSize & 0xFFFFFFFF);
> + SratMemAffinity[NumRegion].LengthHigh =
> + (UINT32)((RegionSize & 0xFFFFFFFF00000000ULL) >> 32);
> + SratMemAffinity[NumRegion].AddressBaseLow =
> + (UINT32)(RegionBase & 0xFFFFFFFF);
> + SratMemAffinity[NumRegion].AddressBaseHigh =
> + (UINT32)((RegionBase & 0xFFFFFFFF00000000ULL) >> 32);
> + SratMemAffinity[NumRegion].ProximityDomain = (UINT32)(ProximityDomain);
> + SratMemAffinity[NumRegion].Type = EFI_ACPI_6_3_MEMORY_AFFINITY;
> + SratMemAffinity[NumRegion].Length = sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
> + NumRegion++;
> + }
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +STATIC
> +EFI_STATUS
> +SratAddGiccAffinity (
> + EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *SratGiccAffinity
> + )
> +{
> + ARM_PROCESSOR_TABLE *ArmProcessorTable;
> + ARM_CORE_INFO *ArmCoreInfoTable;
> + UINTN Count, NumNode, Idx;
> + UINT32 AcpiProcessorUid;
> + UINT8 Socket;
> + UINT8 Cpm;
> +
> + for (Idx = 0; Idx < gST->NumberOfTableEntries; Idx++) {
> + if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Idx].VendorGuid))) {
> + ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Idx].VendorTable;
> + ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
> + break;
> + }
> + }
> +
> + if (Idx == gST->NumberOfTableEntries) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + Count = 0;
> + NumNode = 0;
> + while (Count != ArmProcessorTable->NumberOfEntries) {
> + for (Idx = 0; Idx < ArmProcessorTable->NumberOfEntries; Idx++ ) {
> + Socket = ArmCoreInfoTable[Idx].ClusterId;
> + Cpm = (ArmCoreInfoTable[Idx].CoreId >> PLATFORM_CPM_UID_BIT_OFFSET);
> + if (CpuGetSubNumNode (Socket, Cpm) != NumNode) {
> + /* We add nodes based on ProximityDomain order */
> + continue;
> + }
> + AcpiProcessorUid = (ArmCoreInfoTable[Idx].ClusterId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
> + ArmCoreInfoTable[Idx].CoreId;
> + ZeroMem ((VOID *)&SratGiccAffinity[Count], sizeof (SratGiccAffinity[Count]));
> + SratGiccAffinity[Count].AcpiProcessorUid = AcpiProcessorUid;
> + SratGiccAffinity[Count].Flags = 1;
> + SratGiccAffinity[Count].Length = sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
> + SratGiccAffinity[Count].Type = EFI_ACPI_6_3_GICC_AFFINITY;
> + SratGiccAffinity[Count].ProximityDomain = CpuGetSubNumNode (Socket, Cpm);
> + Count++;
> + }
> + NumNode++;
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +STATIC UINT32
> +InstallGicItsAffinity (
> + VOID *EntryPointer,
> + UINT32 Index
> + )
> +{
> + EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE *ItsAffinityEntryPointer = EntryPointer;
> + UINTN Size;
> +
> + Size = sizeof (GicItsAffinityTemplate);
> + CopyMem (ItsAffinityEntryPointer, &GicItsAffinityTemplate, Size);
> + return Size;
> +}
> +
> +STATIC
> +EFI_STATUS
> +SratAddGicItsAffinity (
> + VOID *TmpPtr
> + )
> +{
> + UINTN Size = 0;
> + UINTN Index;
> +
> + /* Install Gic ITSAffinity */
> + if (!IsSlaveSocketPresent ()) {
> + for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
> + GicItsAffinityTemplate.ItsId = Index;
> + GicItsAffinityTemplate.ProximityDomain = 0;
> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
> + }
> + }
> +
> + for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
> + GicItsAffinityTemplate.ItsId = Index;
> + GicItsAffinityTemplate.ProximityDomain = 0;
> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
> + }
> +
> + if (IsSlaveSocketActive ()) {
> + for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
> + GicItsAffinityTemplate.ItsId = Index;
> + GicItsAffinityTemplate.ProximityDomain = 1;
> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
> + }
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +EFI_STATUS
> +AcpiInstallSratTable (
> + VOID
> + )
> +{
> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
> + EFI_STATUS Status;
> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *SratTablePointer;
> + UINT8 *TmpPtr;
> + UINTN SratTableKey;
> + UINTN Size;
> +
> + Status = gBS->LocateProtocol (
> + &gEfiAcpiTableProtocolGuid,
> + NULL,
> + (VOID **)&AcpiTableProtocol
> + );
> + if (EFI_ERROR (Status)) {
> + return Status;
> + }
> +
> + Size = sizeof (SRATTableHeaderTemplate) +
> + SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE) +
> + GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE) +
> + ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate));
> + if (IsSlaveSocketActive ()) {
> + Size += (SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate);
> + } else if (!IsSlaveSocketPresent ()) {
> + Size += 2 * sizeof (GicItsAffinityTemplate); /* RCA0/1 */
> + }
> +
> + SratTablePointer = (EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *)AllocateZeroPool (Size);
> + if (SratTablePointer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> + CopyMem ((VOID *)SratTablePointer, (VOID *)&SRATTableHeaderTemplate, sizeof (SRATTableHeaderTemplate));
> +
> + TmpPtr = (UINT8 *)SratTablePointer + sizeof (SRATTableHeaderTemplate);
> + Status = SratAddMemAffinity ((EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *)TmpPtr);
> + ASSERT_EFI_ERROR (Status);
> +
> + TmpPtr += SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
> + Status = SratAddGiccAffinity ((EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *)TmpPtr);
> + ASSERT_EFI_ERROR (Status);
> +
> + TmpPtr += GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
> + SratAddGicItsAffinity ((VOID *)(UINT64)TmpPtr);
> + SratTablePointer->Header.Length = Size;
> +
> + AcpiTableChecksum (
> + (UINT8 *)SratTablePointer,
> + SratTablePointer->Header.Length
> + );
> +
> + Status = AcpiTableProtocol->InstallAcpiTable (
> + AcpiTableProtocol,
> + (VOID *)SratTablePointer,
> + SratTablePointer->Header.Length,
> + &SratTableKey
> + );
> + FreePool ((VOID *)SratTablePointer);
> +
> + return Status;
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
> new file mode 100755
> index 000000000000..023509412f04
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
> @@ -0,0 +1,5639 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Device(C000) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x0)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x000, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x004, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x008, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x010, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x014, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x054, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x058, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 0, 0xFD, 2}
> + }) // Domain 0
> +}
> +
> +Device(C001) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x080, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x084, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x088, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x090, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x094, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 1, 0xFD, 2}
> + }) // Domain 1
> +}
> +
> +Device(C002) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x100, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x104, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x108, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x110, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x114, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x154, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x158, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 2, 0xFD, 2}
> + }) // Domain 2
> +}
> +
> +Device(C003) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x180, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x184, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x188, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x190, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x194, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 3, 0xFD, 2}
> + }) // Domain 3
> +}
> +
> +Device(C004) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x200, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x204, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x208, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x210, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x214, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x254, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x258, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 4, 0xFD, 2}
> + }) // Domain 4
> +}
> +
> +Device(C005) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x280, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x284, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x288, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x290, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x294, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 5, 0xFD, 2}
> + }) // Domain 5
> +}
> +
> +Device(C006) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x300, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x304, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x308, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x310, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x314, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x354, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x358, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 6, 0xFD, 2}
> + }) // Domain 6
> +}
> +
> +Device(C007) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x380, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x384, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x388, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x390, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x394, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 7, 0xFD, 2}
> + }) // Domain 7
> +}
> +
> +Device(C008) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x400, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x404, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x408, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x410, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x414, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x454, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x458, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 8, 0xFD, 2}
> + }) // Domain 8
> +}
> +
> +Device(C009) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x480, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x484, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x488, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x490, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x494, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 9, 0xFD, 2}
> + }) // Domain 9
> +}
> +
> +Device(C010) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x500, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x504, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x508, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x510, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x514, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x554, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x558, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 10, 0xFD, 2}
> + }) // Domain 10
> +}
> +
> +Device(C011) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x580, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x584, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x588, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x590, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x594, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 11, 0xFD, 2}
> + }) // Domain 11
> +}
> +
> +Device(C012) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x600, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x604, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x608, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x610, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x614, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x654, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x658, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 12, 0xFD, 2}
> + }) // Domain 12
> +}
> +
> +Device(C013) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x680, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x684, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x688, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x690, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x694, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 13, 0xFD, 2}
> + }) // Domain 13
> +}
> +
> +Device(C014) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x700, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x704, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x708, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x710, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x714, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x754, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x758, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 14, 0xFD, 2}
> + }) // Domain 14
> +}
> +
> +Device(C015) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x780, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x784, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x788, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x790, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x794, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 15, 0xFD, 2}
> + }) // Domain 15
> +}
> +
> +Device(C016) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x800, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x804, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x808, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x810, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x814, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x854, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x858, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 16, 0xFD, 2}
> + }) // Domain 16
> +}
> +
> +Device(C017) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x880, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x884, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x888, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x890, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x894, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 17, 0xFD, 2}
> + }) // Domain 17
> +}
> +
> +Device(C018) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x900, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x904, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x908, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x910, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x914, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x954, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x958, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 18, 0xFD, 2}
> + }) // Domain 18
> +}
> +
> +Device(C019) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x980, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x984, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x988, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x990, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x994, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 19, 0xFD, 2}
> + }) // Domain 19
> +}
> +
> +Device(C020) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xa00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 20, 0xFD, 2}
> + }) // Domain 20
> +}
> +
> +Device(C021) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xa01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 21, 0xFD, 2}
> + }) // Domain 21
> +}
> +
> +Device(C022) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xb00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 22, 0xFD, 2}
> + }) // Domain 22
> +}
> +
> +Device(C023) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xb01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 23, 0xFD, 2}
> + }) // Domain 23
> +}
> +
> +Device(C024) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xc00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 24, 0xFD, 2}
> + }) // Domain 24
> +}
> +
> +Device(C025) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xc01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 25, 0xFD, 2}
> + }) // Domain 25
> +}
> +
> +Device(C026) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xd00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 26, 0xFD, 2}
> + }) // Domain 26
> +}
> +
> +Device(C027) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xd01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 27, 0xFD, 2}
> + }) // Domain 27
> +}
> +
> +Device(C028) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xe00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 28, 0xFD, 2}
> + }) // Domain 28
> +}
> +
> +Device(C029) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xe01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 29, 0xFD, 2}
> + }) // Domain 29
> +}
> +
> +Device(C030) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xf00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 30, 0xFD, 2}
> + }) // Domain 30
> +}
> +
> +Device(C031) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0xf01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 31, 0xFD, 2}
> + }) // Domain 31
> +}
> +
> +Device(C032) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 32, 0xFD, 2}
> + }) // Domain 32
> +}
> +
> +Device(C033) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 33, 0xFD, 2}
> + }) // Domain 33
> +}
> +
> +Device(C034) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 34, 0xFD, 2}
> + }) // Domain 34
> +}
> +
> +Device(C035) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 35, 0xFD, 2}
> + }) // Domain 35
> +}
> +
> +Device(C036) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 36, 0xFD, 2}
> + }) // Domain 36
> +}
> +
> +Device(C037) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 37, 0xFD, 2}
> + }) // Domain 37
> +}
> +
> +Device(C038) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 38, 0xFD, 2}
> + }) // Domain 38
> +}
> +
> +Device(C039) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 39, 0xFD, 2}
> + }) // Domain 39
> +}
> +
> +Device(C040) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 40, 0xFD, 2}
> + }) // Domain 40
> +}
> +
> +Device(C041) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 41, 0xFD, 2}
> + }) // Domain 41
> +}
> +
> +Device(C042) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 42, 0xFD, 2}
> + }) // Domain 42
> +}
> +
> +Device(C043) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 43, 0xFD, 2}
> + }) // Domain 43
> +}
> +
> +Device(C044) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 44, 0xFD, 2}
> + }) // Domain 44
> +}
> +
> +Device(C045) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 45, 0xFD, 2}
> + }) // Domain 45
> +}
> +
> +Device(C046) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 46, 0xFD, 2}
> + }) // Domain 46
> +}
> +
> +Device(C047) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 47, 0xFD, 2}
> + }) // Domain 47
> +}
> +
> +Device(C048) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 48, 0xFD, 2}
> + }) // Domain 48
> +}
> +
> +Device(C049) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 49, 0xFD, 2}
> + }) // Domain 49
> +}
> +
> +Device(C050) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 50, 0xFD, 2}
> + }) // Domain 50
> +}
> +
> +Device(C051) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 51, 0xFD, 2}
> + }) // Domain 51
> +}
> +
> +Device(C052) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 52, 0xFD, 2}
> + }) // Domain 52
> +}
> +
> +Device(C053) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 53, 0xFD, 2}
> + }) // Domain 53
> +}
> +
> +Device(C054) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 54, 0xFD, 2}
> + }) // Domain 54
> +}
> +
> +Device(C055) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 55, 0xFD, 2}
> + }) // Domain 5
> +}
> +
> +Device(C056) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 56, 0xFD, 2}
> + }) // Domain 56
> +}
> +
> +Device(C057) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 57, 0xFD, 2}
> + }) // Domain 57
> +}
> +
> +Device(C058) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 58, 0xFD, 2}
> + }) // Domain 58
> +}
> +
> +Device(C059) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 59, 0xFD, 2}
> + }) // Domain 59
> +}
> +
> +Device(C060) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 60, 0xFD, 2}
> + }) // Domain 60
> +}
> +
> +Device(C061) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 61, 0xFD, 2}
> + }) // Domain 61
> +}
> +
> +Device(C062) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 62, 0xFD, 2}
> + }) // Domain 62
> +}
> +
> +Device(C063) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x1f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 63, 0xFD, 2}
> + }) // Domain 63
> +}
> +
> +Device(C064) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 64, 0xFD, 2}
> + }) // Domain 64
> +}
> +
> +Device(C065) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 65, 0xFD, 2}
> + }) // Domain 65
> +}
> +
> +Device(C066) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 66, 0xFD, 2}
> + }) // Domain 66
> +}
> +
> +Device(C067) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 67, 0xFD, 2}
> + }) // Domain 67
> +}
> +
> +Device(C068) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 68, 0xFD, 2}
> + }) // Domain 68
> +}
> +
> +Device(C069) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 69, 0xFD, 2}
> + }) // Domain 69
> +}
> +
> +Device(C070) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 70, 0xFD, 2}
> + }) // Domain 70
> +}
> +
> +Device(C071) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 71, 0xFD, 2}
> + }) // Domain 71
> +}
> +
> +Device(C072) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 72, 0xFD, 2}
> + }) // Domain 72
> +}
> +
> +Device(C073) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 73, 0xFD, 2}
> + }) // Domain 73
> +}
> +
> +Device(C074) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 74, 0xFD, 2}
> + }) // Domain 74
> +}
> +
> +Device(C075) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 75, 0xFD, 2}
> + }) // Domain 75
> +}
> +
> +Device(C076) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 76, 0xFD, 2}
> + }) // Domain 76
> +}
> +
> +Device(C077) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 77, 0xFD, 2}
> + }) // Domain 77
> +}
> +
> +Device(C078) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 78, 0xFD, 2}
> + }) // Domain 78
> +}
> +
> +Device(C079) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 79, 0xFD, 2}
> + }) // Domain 79
> +}
> +
> +Device(C080) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 80, 0xFD, 2}
> + }) // Domain 80
> +}
> +
> +Device(C081) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 81, 0xFD, 2}
> + }) // Domain 81
> +}
> +
> +Device(C082) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 82, 0xFD, 2}
> + }) // Domain 82
> +}
> +
> +Device(C083) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 83, 0xFD, 2}
> + }) // Domain 83
> +}
> +
> +Device(C084) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 84, 0xFD, 2}
> + }) // Domain 84
> +}
> +
> +Device(C085) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 85, 0xFD, 2}
> + }) // Domain 85
> +}
> +
> +Device(C086) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 86, 0xFD, 2}
> + }) // Domain 86
> +}
> +
> +Device(C087) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 87, 0xFD, 2}
> + }) // Domain 87
> +}
> +
> +Device(C088) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 88, 0xFD, 2}
> + }) // Domain 88
> +}
> +
> +Device(C089) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 89, 0xFD, 2}
> + }) // Domain 89
> +}
> +
> +Device(C090) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 90, 0xFD, 2}
> + }) // Domain 90
> +}
> +
> +Device(C091) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 91, 0xFD, 2}
> + }) // Domain 91
> +}
> +
> +Device(C092) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 92, 0xFD, 2}
> + }) // Domain 92
> +}
> +
> +Device(C093) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 93, 0xFD, 2}
> + }) // Domain 93
> +}
> +
> +Device(C094) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 94, 0xFD, 2}
> + }) // Domain 94
> +}
> +
> +Device(C095) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x2f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 95, 0xFD, 2}
> + }) // Domain 95
> +}
> +
> +Device(C096) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 96, 0xFD, 2}
> + }) // Domain 96
> +}
> +
> +Device(C097) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 97, 0xFD, 2}
> + }) // Domain 97
> +}
> +
> +Device(C098) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 98, 0xFD, 2}
> + }) // Domain 98
> +}
> +
> +Device(C099) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 99, 0xFD, 2}
> + }) // Domain 99
> +}
> +
> +Device(C100) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 100, 0xFD, 2}
> + }) // Domain 100
> +}
> +
> +Device(C101) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 101, 0xFD, 2}
> + }) // Domain 101
> +}
> +
> +Device(C102) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 102, 0xFD, 2}
> + }) // Domain 102
> +}
> +
> +Device(C103) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 103, 0xFD, 2}
> + }) // Domain 103
> +}
> +
> +Device(C104) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 104, 0xFD, 2}
> + }) // Domain 104
> +}
> +
> +Device(C105) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 105, 0xFD, 2}
> + }) // Domain 105
> +}
> +
> +Device(C106) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 106, 0xFD, 2}
> + }) // Domain 106
> +}
> +
> +Device(C107) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 107, 0xFD, 2}
> + }) // Domain 107
> +}
> +
> +Device(C108) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 108, 0xFD, 2}
> + }) // Domain 108
> +}
> +
> +Device(C109) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 109, 0xFD, 2}
> + }) // Domain 109
> +}
> +
> +Device(C110) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 110, 0xFD, 2}
> + }) // Domain 110
> +}
> +
> +Device(C111) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 111, 0xFD, 2}
> + }) // Domain 111
> +}
> +
> +Device(C112) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 112, 0xFD, 2}
> + }) // Domain 112
> +}
> +
> +Device(C113) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 113, 0xFD, 2}
> + }) // Domain 113
> +}
> +
> +Device(C114) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 114, 0xFD, 2}
> + }) // Domain 114
> +}
> +
> +Device(C115) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 115, 0xFD, 2}
> + }) // Domain 115
> +}
> +
> +Device(C116) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 116, 0xFD, 2}
> + }) // Domain 116
> +}
> +
> +Device(C117) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 117, 0xFD, 2}
> + }) // Domain 117
> +}
> +
> +Device(C118) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 118, 0xFD, 2}
> + }) // Domain 118
> +}
> +
> +Device(C119) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 119, 0xFD, 2}
> + }) // Domain 119
> +}
> +
> +Device(C120) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 120, 0xFD, 2}
> + }) // Domain 120
> +}
> +
> +Device(C121) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 121, 0xFD, 2}
> + }) // Domain 121
> +}
> +
> +Device(C122) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 122, 0xFD, 2}
> + }) // Domain 122
> +}
> +
> +Device(C123) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 123, 0xFD, 2}
> + }) // Domain 123
> +}
> +
> +Device(C124) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 124, 0xFD, 2}
> + }) // Domain 124
> +}
> +
> +Device(C125) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 125, 0xFD, 2}
> + }) // Domain 125
> +}
> +
> +Device(C126) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 126, 0xFD, 2}
> + }) // Domain 126
> +}
> +
> +Device(C127) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x3f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 127, 0xFD, 2}
> + }) // Domain 127
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
> new file mode 100755
> index 000000000000..b3cc7a1b00e4
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
> @@ -0,0 +1,5639 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Device(C128) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x000, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x004, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x008, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x010, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x014, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x054, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x058, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 128, 0xFD, 2}
> + }) // Domain 128
> +}
> +
> +Device(C129) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x080, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x084, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x088, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x090, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x094, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 1219, 0xFD, 2}
> + }) // Domain 129
> +}
> +
> +Device(C130) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x100, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x104, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x108, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x110, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x114, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x154, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x158, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 130, 0xFD, 2}
> + }) // Domain 130
> +}
> +
> +Device(C131) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x180, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x184, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x188, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x190, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x194, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 131, 0xFD, 2}
> + }) // Domain 131
> +}
> +
> +Device(C132) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x200, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x204, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x208, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x210, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x214, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x254, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x258, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 132, 0xFD, 2}
> + }) // Domain 132
> +}
> +
> +Device(C133) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x280, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x284, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x288, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x290, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x294, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 133, 0xFD, 2}
> + }) // Domain 133
> +}
> +
> +Device(C134) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x300, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x304, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x308, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x310, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x314, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x354, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x358, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 134, 0xFD, 2}
> + }) // Domain 134
> +}
> +
> +Device(C135) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x380, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x384, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x388, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x390, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x394, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 135, 0xFD, 2}
> + }) // Domain 135
> +}
> +
> +Device(C136) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x400, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x404, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x408, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x410, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x414, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x454, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x458, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 136, 0xFD, 2}
> + }) // Domain 136
> +}
> +
> +Device(C137) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x480, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x484, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x488, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x490, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x494, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 137, 0xFD, 2}
> + }) // Domain 137
> +}
> +
> +Device(C138) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x500, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x504, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x508, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x510, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x514, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x554, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x558, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 138, 0xFD, 2}
> + }) // Domain 138
> +}
> +
> +Device(C139) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x580, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x584, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x588, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x590, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x594, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 139, 0xFD, 2}
> + }) // Domain 139
> +}
> +
> +Device(C140) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x600, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x604, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x608, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x610, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x614, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x654, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x658, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 140, 0xFD, 2}
> + }) // Domain 140
> +}
> +
> +Device(C141) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x680, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x684, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x688, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x690, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x694, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 141, 0xFD, 2}
> + }) // Domain 141
> +}
> +
> +Device(C142) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x700, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x704, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x708, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x710, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x714, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x754, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x758, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 142, 0xFD, 2}
> + }) // Domain 142
> +}
> +
> +Device(C143) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x780, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x784, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x788, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x790, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x794, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 143, 0xFD, 2}
> + }) // Domain 143
> +}
> +
> +Device(C144) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x800, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x804, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x808, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x810, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x814, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x854, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x858, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 144, 0xFD, 2}
> + }) // Domain 144
> +}
> +
> +Device(C145) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x880, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x884, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x888, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x890, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x894, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 145, 0xFD, 2}
> + }) // Domain 145
> +}
> +
> +Device(C146) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x900, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x904, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x908, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x910, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x914, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x954, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x958, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 146, 0xFD, 2}
> + }) // Domain 146
> +}
> +
> +Device(C147) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x980, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x984, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x988, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x990, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x994, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 147, 0xFD, 2}
> + }) // Domain 147
> +}
> +
> +Device(C148) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 148, 0xFD, 2}
> + }) // Domain 148
> +}
> +
> +Device(C149) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 149, 0xFD, 2}
> + }) // Domain 149
> +}
> +
> +Device(C150) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 150, 0xFD, 2}
> + }) // Domain 150
> +}
> +
> +Device(C151) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 151, 0xFD, 2}
> + }) // Domain 151
> +}
> +
> +Device(C152) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 152, 0xFD, 2}
> + }) // Domain 152
> +}
> +
> +Device(C153) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 153, 0xFD, 2}
> + }) // Domain 153
> +}
> +
> +Device(C154) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 154, 0xFD, 2}
> + }) // Domain 154
> +}
> +
> +Device(C155) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 155, 0xFD, 2}
> + }) // Domain 155
> +}
> +
> +Device(C156) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 156, 0xFD, 2}
> + }) // Domain 156
> +}
> +
> +Device(C157) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 157, 0xFD, 2}
> + }) // Domain 157
> +}
> +
> +Device(C158) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 158, 0xFD, 2}
> + }) // Domain 158
> +}
> +
> +Device(C159) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x10f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 159, 0xFD, 2}
> + }) // Domain 159
> +}
> +
> +Device(C160) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 160, 0xFD, 2}
> + }) // Domain 160
> +}
> +
> +Device(C161) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 161, 0xFD, 2}
> + }) // Domain 161
> +}
> +
> +Device(C162) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 162, 0xFD, 2}
> + }) // Domain 162
> +}
> +
> +Device(C163) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 163, 0xFD, 2}
> + }) // Domain 163
> +}
> +
> +Device(C164) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 164, 0xFD, 2}
> + }) // Domain 164
> +}
> +
> +Device(C165) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 165, 0xFD, 2}
> + }) // Domain 165
> +}
> +
> +Device(C166) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 166, 0xFD, 2}
> + }) // Domain 166
> +}
> +
> +Device(C167) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 167, 0xFD, 2}
> + }) // Domain 167
> +}
> +
> +Device(C168) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 168, 0xFD, 2}
> + }) // Domain 168
> +}
> +
> +Device(C169) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 169, 0xFD, 2}
> + }) // Domain 169
> +}
> +
> +Device(C170) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 170, 0xFD, 2}
> + }) // Domain 170
> +}
> +
> +Device(C171) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 171, 0xFD, 2}
> + }) // Domain 171
> +}
> +
> +Device(C172) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 172, 0xFD, 2}
> + }) // Domain 172
> +}
> +
> +Device(C173) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 173, 0xFD, 2}
> + }) // Domain 173
> +}
> +
> +Device(C174) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 174, 0xFD, 2}
> + }) // Domain 174
> +}
> +
> +Device(C175) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 175, 0xFD, 2}
> + }) // Domain 175
> +}
> +
> +Device(C176) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 176, 0xFD, 2}
> + }) // Domain 176
> +}
> +
> +Device(C177) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 177, 0xFD, 2}
> + }) // Domain 177
> +}
> +
> +Device(C178) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 178, 0xFD, 2}
> + }) // Domain 178
> +}
> +
> +Device(C179) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 179, 0xFD, 2}
> + }) // Domain 179
> +}
> +
> +Device(C180) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 180, 0xFD, 2}
> + }) // Domain 180
> +}
> +
> +Device(C181) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 181, 0xFD, 2}
> + }) // Domain 181
> +}
> +
> +Device(C182) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 182, 0xFD, 2}
> + }) // Domain 182
> +}
> +
> +Device(C183) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 183, 0xFD, 2}
> + }) // Domain 183
> +}
> +
> +Device(C184) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 184, 0xFD, 2}
> + }) // Domain 184
> +}
> +
> +Device(C185) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 185, 0xFD, 2}
> + }) // Domain 185
> +}
> +
> +Device(C186) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 186, 0xFD, 2}
> + }) // Domain 186
> +}
> +
> +Device(C187) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 187, 0xFD, 2}
> + }) // Domain 187
> +}
> +
> +Device(C188) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 188, 0xFD, 2}
> + }) // Domain 188
> +}
> +
> +Device(C189) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 189, 0xFD, 2}
> + }) // Domain 189
> +}
> +
> +Device(C190) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 190, 0xFD, 2}
> + }) // Domain 190
> +}
> +
> +Device(C191) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x11f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 191, 0xFD, 2}
> + }) // Domain 191
> +}
> +
> +Device(C192) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 192, 0xFD, 2}
> + }) // Domain 192
> +}
> +
> +Device(C193) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 193, 0xFD, 2}
> + }) // Domain 193
> +}
> +
> +Device(C194) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 194, 0xFD, 2}
> + }) // Domain 194
> +}
> +
> +Device(C195) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 195, 0xFD, 2}
> + }) // Domain 195
> +}
> +
> +Device(C196) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 196, 0xFD, 2}
> + }) // Domain 196
> +}
> +
> +Device(C197) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 197, 0xFD, 2}
> + }) // Domain 197
> +}
> +
> +Device(C198) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 198, 0xFD, 2}
> + }) // Domain 198
> +}
> +
> +Device(C199) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 199, 0xFD, 2}
> + }) // Domain 199
> +}
> +
> +Device(C200) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 200, 0xFD, 2}
> + }) // Domain 200
> +}
> +
> +Device(C201) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 201, 0xFD, 2}
> + }) // Domain 201
> +}
> +
> +Device(C202) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 202, 0xFD, 2}
> + }) // Domain 202
> +}
> +
> +Device(C203) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 203, 0xFD, 2}
> + }) // Domain 203
> +}
> +
> +Device(C204) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 204, 0xFD, 2}
> + }) // Domain 204
> +}
> +
> +Device(C205) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 205, 0xFD, 2}
> + }) // Domain 205
> +}
> +
> +Device(C206) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 206, 0xFD, 2}
> + }) // Domain 206
> +}
> +
> +Device(C207) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 207, 0xFD, 2}
> + }) // Domain 207
> +}
> +
> +Device(C208) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 208, 0xFD, 2}
> + }) // Domain 208
> +}
> +
> +Device(C209) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 209, 0xFD, 2}
> + }) // Domain 209
> +}
> +
> +Device(C210) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 210, 0xFD, 2}
> + }) // Domain 210
> +}
> +
> +Device(C211) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 211, 0xFD, 2}
> + }) // Domain 211
> +}
> +
> +Device(C212) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 212, 0xFD, 2}
> + }) // Domain 212
> +}
> +
> +Device(C213) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 213, 0xFD, 2}
> + }) // Domain 213
> +}
> +
> +Device(C214) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 214, 0xFD, 2}
> + }) // Domain 214
> +}
> +
> +Device(C215) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 215, 0xFD, 2}
> + }) // Domain 215
> +}
> +
> +Device(C216) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 216, 0xFD, 2}
> + }) // Domain 216
> +}
> +
> +Device(C217) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 217, 0xFD, 2}
> + }) // Domain 217
> +}
> +
> +Device(C218) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 218, 0xFD, 2}
> + }) // Domain 218
> +}
> +
> +Device(C219) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 219, 0xFD, 2}
> + }) // Domain 219
> +}
> +
> +Device(C220) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 220, 0xFD, 2}
> + }) // Domain 220
> +}
> +
> +Device(C221) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 221, 0xFD, 2}
> + }) // Domain 221
> +}
> +
> +Device(C222) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 222, 0xFD, 2}
> + }) // Domain 222
> +}
> +
> +Device(C223) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x12f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 17)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 17)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 17)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 17)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 17)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 17)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 17)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 17)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 17)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 17)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 17)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 223, 0xFD, 2}
> + }) // Domain 223
> +}
> +
> +Device(C224) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13000)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 224, 0xFD, 2}
> + }) // Domain 224
> +}
> +
> +Device(C225) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13001)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 225, 0xFD, 2}
> + }) // Domain 225
> +}
> +
> +Device(C226) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13100)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 226, 0xFD, 2}
> + }) // Domain 226
> +}
> +
> +Device(C227) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13101)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 227, 0xFD, 2}
> + }) // Domain 227
> +}
> +
> +Device(C228) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13200)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 228, 0xFD, 2}
> + }) // Domain 228
> +}
> +
> +Device(C229) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13201)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 229, 0xFD, 2}
> + }) // Domain 229
> +}
> +
> +Device(C230) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13300)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 230, 0xFD, 2}
> + }) // Domain 230
> +}
> +
> +Device(C231) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13301)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 231, 0xFD, 2}
> + }) // Domain 231
> +}
> +
> +Device(C232) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13400)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 232, 0xFD, 2}
> + }) // Domain 232
> +}
> +
> +Device(C233) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13401)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 233, 0xFD, 2}
> + }) // Domain 233
> +}
> +
> +Device(C234) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13500)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 234, 0xFD, 2}
> + }) // Domain 234
> +}
> +
> +Device(C235) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13501)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 235, 0xFD, 2}
> + }) // Domain 235
> +}
> +
> +Device(C236) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13600)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 236, 0xFD, 2}
> + }) // Domain 236
> +}
> +
> +Device(C237) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13601)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 237, 0xFD, 2}
> + }) // Domain 237
> +}
> +
> +Device(C238) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13700)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 238, 0xFD, 2}
> + }) // Domain 238
> +}
> +
> +Device(C239) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13701)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 239, 0xFD, 2}
> + }) // Domain 239
> +}
> +
> +Device(C240) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13800)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 240, 0xFD, 2}
> + }) // Domain 240
> +}
> +
> +Device(C241) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13801)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 241, 0xFD, 2}
> + }) // Domain 241
> +}
> +
> +Device(C242) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13900)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 242, 0xFD, 2}
> + }) // Domain 242
> +}
> +
> +Device(C243) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13901)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 243, 0xFD, 2}
> + }) // Domain 243
> +}
> +
> +Device(C244) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13a00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 244, 0xFD, 2}
> + }) // Domain 244
> +}
> +
> +Device(C245) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13a01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 245, 0xFD, 2}
> + }) // Domain 245
> +}
> +
> +Device(C246) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13b00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 246, 0xFD, 2}
> + }) // Domain 246
> +}
> +
> +Device(C247) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13b01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 247, 0xFD, 2}
> + }) // Domain 247
> +}
> +
> +Device(C248) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13c00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 248, 0xFD, 2}
> + }) // Domain 248
> +}
> +
> +Device(C249) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13c01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 249, 0xFD, 2}
> + }) // Domain 249
> +}
> +
> +Device(C250) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13d00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 250, 0xFD, 2}
> + }) // Domain 250
> +}
> +
> +Device(C251) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13d01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 251, 0xFD, 2}
> + }) // Domain 251
> +}
> +
> +Device(C252) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13e00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 252, 0xFD, 2}
> + }) // Domain 252
> +}
> +
> +Device(C253) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13e01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 253, 0xFD, 2}
> + }) // Domain 253
> +}
> +
> +Device(C254) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13f00)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package() {
> + Package() {5, 0, 254, 0xFD, 2}
> + }) // Domain 254
> +}
> +
> +Device(C255) {
> + Name(_HID, "ACPI0007")
> + Name(_UID, 0x13f01)
> +
> + Method (_LPI, 0, NotSerialized) {
> + return(PLPI)
> + }
> +
> + Name(PCPC, Package() {
> + 23, // NumEntries
> + 3, // Revision
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
> + })
> + If (LEqual(CPCE, 0x1)) {
> + Method (_CPC, 0, NotSerialized) {
> + return(PCPC)
> + }
> + }
> + //Performance State dependency
> + Name(_PSD, Package(){
> + Package() {5, 0, 255, 0xFD, 2}
> + }) // Domain 255
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
> new file mode 100755
> index 000000000000..00c09340b957
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
> @@ -0,0 +1,127 @@
> +/** @file
> +
> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Name (CPCE, 1) // CPPC Enable
> +Name (LPIE, 0) // LPI Enable
> +
> +Method (_OSC, 4, Serialized) { // _OSC: Operating System Capabilities
> + CreateDWordField (Arg3, 0x00, STS0)
> + CreateDWordField (Arg3, 0x04, CAP0)
> + If (LEqual(Arg0, ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48")) /* Platform-wide Capabilities */) {
> + If (LNotEqual(Arg1, One)) {
> + And(STS0, 0xFFFFFFE0, STS0)
> + Or(STS0, 0x0A, STS0) // Unrecognized Revision, OSC failure
> + } Else {
> + If (LEqual(And(CAP0, 0x100), 0x100)) {
> + And(CAP0, 0xFFFFFEFF, CAP0) // No support for OS Initiated LPI
> + And(STS0, 0xFFFFFFE0, STS0)
> + Or(STS0, 0x12, STS0)
> + }
> + If (LEqual(LPIE, 0x1)) {
> + Or(CAP0, 0x80, CAP0) // Support for LPI
> + } Else {
> + And(CAP0, 0xFFFFFF7F, CAP0) // No support for LPI
> + }
> + If (LEqual(CPCE, 0x1)) {
> + Or(CAP0, 0x40, CAP0) // Support for CPPCv2
> + } Else {
> + And(CAP0, 0xFFFFFFBF, CAP0) // No support for CPPCv2
> + }
> + }
> + } Else {
> + And(STS0, 0xFFFFFFE0, STS0)
> + Or(STS0, 0x06, STS0) // Unrecognized Revision, Unrecognized UUID
> + }
> + Return (Arg3)
> +}
> +
> +Name(PLPI, Package() {
> + 0, // Version
> + 1, // Level Index
> + 2, // Count
> + // WFI for CPU (NS-WFI)
> + Package() {
> + 1, // Min residency (uS)
> + 1, // Wake latency (uS)
> + 1, // Flags
> + 0, // Arch Context Flags
> + 100, // Residency Counter Frequency
> + 0, // No parent state
> + ResourceTemplate () {
> + // Register Entry method
> + Register (FFixedHW,
> + 0x20, // Bit Width
> + 0x00, // Bit Offset
> + 0xFFFFFFFF, // Address
> + 0x03, // Access Size
> + )
> + },
> + ResourceTemplate() { // Null Residency Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + ResourceTemplate() { // Null Usage Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + "Standby",
> + },
> + // Retention state for CPU (S-WFI)
> + Package() {
> + 2, // Min residency (uS)
> + 2, // Wake latency (uS)
> + 1, // Flags
> + 0, // Arch Context Flags
> + 100, // Residency Counter Frequency
> + 1, // Parent node can be in Standby states
> + ResourceTemplate () {
> + // Register Entry method
> + Register (FFixedHW,
> + 0x20, // Bit Width
> + 0x00, // Bit Offset
> + 0x00000001, // Address
> + 0x03, // Access Size
> + )
> + },
> + ResourceTemplate() { // Null Residency Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + ResourceTemplate() { // Null Usage Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + "Standby_ATF"
> + },
> +})
> +
> +Device (SYST) { // System state
> + Name(_HID, "ACPI0010")
> + Name(_UID, 1)
> + Name (_LPI, Package() {
> + 0, // Version
> + 0, // Level Index
> + 1, // Count
> + // Retention state for Cluster
> + Package() {
> + 100, // Min residency (uS)
> + 100, // Wake latency (uS)
> + 1, // Flags
> + 0, // Arch Context Flags
> + 100, // Residency Counter Frequency
> + 0, // No Parent State
> + 0x02000100, // Integer Entry method
> + ResourceTemplate() { // Null Residency Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + ResourceTemplate() { // Null Usage Counter
> + Register (SystemMemory, 0, 0, 0, 0)
> + },
> + "Standby"
> + },
> + })
> +
> + Include ("CPU-S0.asi")
> + Include ("CPU-S1.asi")
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
> new file mode 100755
> index 000000000000..b9e2da79b5ef
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
> @@ -0,0 +1,575 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +DefinitionBlock("Dsdt.aml", "DSDT", 0x02, "Ampere", "Jade", 1) {
> + //
> + // Board Model
> + Name(\BDMD, "Jade Board")
> + Name(TPMF, 0) // TPM presence
> + Name(AERF, 0) // PCIe AER Firmware-First
> + Scope(\_SB) {
> +
> + Include ("CPU.asi")
> + Include ("PMU.asi")
> +
> + //
> + // Hardware Monitor
> + Device(HM00) {
> + Name(_HID, "APMC0D29")
> + Name(_UID, "HWM0")
> + Name(_DDN, "HWM0")
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Hardware Monitor Device"))
> + Method(_STA, 0, NotSerialized) {
> + return (0xF)
> + }
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package() {
> + Package() {"pcc-channel", 14}
> + }
> + })
> + }
> +
> + //
> + // Hardware Monitor
> + Device(HM01) {
> + Name(_HID, "APMC0D29")
> + Name(_UID, "HWM1")
> + Name(_DDN, "HWM1")
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Hardware Monitor Device"))
> + Method(_STA, 0, NotSerialized) {
> + return (0xF)
> + }
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package() {
> + Package() {"pcc-channel", 29}
> + }
> + })
> + }
> +
> + //
> + // Hardware Monitor
> + Device(HM02) {
> + Name(_HID, "AMPC0005")
> + Name(_UID, "HWM2")
> + Name(_DDN, "HWM2")
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
> + Method(_STA, 0, NotSerialized) {
> + return (0xF)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000088900000, // AddressMinimum - MIN
> + 0x000000008891FFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000020000 // RangeLength - LEN
> + )
> + })
> + }
> +
> + //
> + // Hardware Monitor
> + Device(HM03) {
> + Name(_HID, "AMPC0005")
> + Name(_UID, "HWM3")
> + Name(_DDN, "HWM3")
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
> + Method(_STA, 0, NotSerialized) {
> + return (0xF)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000088920000, // AddressMinimum - MIN
> + 0x000000008893FFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000020000 // RangeLength - LEN
> + )
> + })
> + }
> +
> + //
> + // DesignWare I2C on AHBC bus
> + Device(I2C4) {
> + Name(_HID, "APMC0D0F")
> + Name(_UID, 4)
> + Name(_STR, Unicode("Altra I2C Device"))
> + Method(_STA, 0, NotSerialized) {
> + return (0x0f)
> + }
> + Name(_CCA, ONE)
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00001000026B0000, // AddressMinimum - MIN
> + 0x00001000026BFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000010000 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 105 }
> + })
> + Device (IPI) {
> + Name(_HID, "AMPC0004")
> + Name(_CID, "IPI0001")
> + Name(_STR, Unicode("IPMI_SSIF"))
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Method(_IFT) {
> + Return(0x04) // IPMI SSIF
> + }
> + Method(_ADR) {
> + Return(0x10) // SSIF slave address
> + }
> + Method(_SRV) {
> + Return(0x0200) // IPMI Specification Revision
> + }
> + Name(_CRS, ResourceTemplate ()
> + {
> + I2cSerialBus (0x0010, ControllerInitiated, 0x00061A80,
> + AddressingMode7Bit, "\\_SB.I2C4",
> + 0x00, ResourceConsumer,,
> + )
> + })
> + }
> + Name(SSCN, Package() { 0x3E2, 0x47D, 0 })
> + Name(FMCN, Package() { 0xA4, 0x13F, 0 })
> + }
> +
> + //
> + // Report APEI Errors to GHES via SCI notification.
> + // SCI notification requires one GED and one HED Device
> + // GED = Generic Event Device (ACPI0013)
> + // HED = Hardware Error Device (PNP0C33)
> + //
> + Device(GED0) {
> + Name(_HID, "ACPI0013")
> + Name(_UID, Zero)
> + Method(_STA) {
> + Return (0xF)
> + }
> + Name(_CRS, ResourceTemplate () {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 84 } // GHES
> + })
> + Method(_EVT, 1, Serialized) {
> + Switch (ToInteger(Arg0)) {
> + Case (84) { // GHES interrupt
> + Notify (HED0, 0x80)
> + }
> + }
> + }
> + }
> +
> + // Shutdown button using GED.
> + Device(GED1) {
> + Name(_HID, "ACPI0013")
> + Name(_CID, "ACPI0013")
> + Name(_UID, One)
> + Method(_STA) {
> + Return (0xF)
> + }
> + Name(_CRS, ResourceTemplate () {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 327 }
> + })
> + OperationRegion(PDDR, SystemMemory, 0x1000027B0004, 4)
> + Field(PDDR, DWordAcc, NoLock, Preserve) {
> + STDI, 8
> + }
> +
> + OperationRegion(INTE, SystemMemory, 0x1000027B0030, 4)
> + Field(INTE, DWordAcc, NoLock, Preserve) {
> + STDE, 8
> + }
> +
> + OperationRegion(INTT, SystemMemory, 0x1000027B0034, 4)
> + Field(INTT, DWordAcc, NoLock, Preserve) {
> + TYPE, 8
> + }
> +
> + OperationRegion(INTP, SystemMemory, 0x1000027B0038, 4)
> + Field(INTP, DWordAcc, NoLock, Preserve) {
> + POLA, 8
> + }
> +
> + OperationRegion(INTS, SystemMemory, 0x1000027B003c, 4)
> + Field(INTS, DWordAcc, NoLock, Preserve) {
> + STDS, 8
> + }
> +
> + OperationRegion(INTC, SystemMemory, 0x1000027B0040, 4)
> + Field(INTC, DWordAcc, NoLock, Preserve) {
> + SINT, 8
> + }
> +
> + OperationRegion(INTM, SystemMemory, 0x1000027B0044, 4)
> + Field(INTM, DWordAcc, NoLock, Preserve) {
> + MASK, 8
> + }
> +
> + Method(_INI, 0, NotSerialized) {
> + // Set level type, low active (shutdown)
> + Store (0x00, TYPE)
> + Store (0x00, POLA)
> + // Set Input type (shutdown)
> + Store (0x00, STDI)
> + // Enable interrupt (shutdown)
> + Store (0x80, STDE)
> + // Unmask the interrupt.
> + Store (0x00, MASK)
> + }
> + Method(_EVT, 1, Serialized) {
> + Switch (ToInteger(Arg0)) {
> + Case (327) {
> + if (And (STDS, 0x80)) {
> + //Clear the interrupt.
> + Store (0x80, SINT)
> + // Notify OSPM the power button is pressed
> + Notify (\_SB.PWRB, 0x80)
> + }
> + }
> + }
> + }
> + }
> +
> + // Power button device description
> + Device(PWRB) {
> + Name(_HID, EISAID("PNP0C0C"))
> + Name(_ADR, 0)
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Method(_STA, 0, Notserialized) {
> + Return (0x0b)
> + }
> + }
> +
> + //
> + // UART0 PL011
> + Device(URT0) {
> + Name(_HID, "ARMH0011")
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Method(_STA, 0, NotSerialized) {
> + return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000100002600000, // AddressMinimum - MIN
> + 0x0000100002600FFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000001000 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 98 }
> + })
> + } // UART0
> +
> + //
> + // UART2 PL011
> + Device(URT2) {
> + Name(_HID, "ARMH0011")
> + Name(_UID, 1)
> + Name(_CCA, ONE)
> + Method(_STA, 0, NotSerialized) {
> + return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000100002620000, // AddressMinimum - MIN
> + 0x0000100002620FFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000001000 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 100 }
> + })
> + } // UART1
> +
> + Device(HED0)
> + {
> + Name(_HID, EISAID("PNP0C33"))
> + Name(_UID, Zero)
> + }
> +
> + Device(NVDR) {
> + Name(_HID, "ACPI0012")
> + Method(_STA, 0, NotSerialized) {
> + return (0xf)
> + }
> + Method (_DSM, 0x4, Serialized) {
> + // Not support any functions for now
> + Return (Buffer() {0})
> + }
> + Device (NVD1) {
> + Name(_ADR, 0x0330)
> + Name(SMRT, Buffer(13) {0})
> + CreateDWordField(SMRT, 0, BSTA)
> + CreateWordField(SMRT, 4, BHTH)
> + CreateWordField(SMRT, 6, BTMP)
> + CreateByteField(SMRT, 8, BETH)
> + CreateByteField(SMRT, 9, BWTH)
> + CreateByteField(SMRT, 10, BNLF)
> + OperationRegion(BUF1, SystemMemory, 0x88980000, 16)
> + Field (BUF1, DWordAcc, NoLock, Preserve) {
> + STAT, 32, //Status
> + HLTH, 16, //Module Health
> + CTMP, 16, //Module Current Status
> + ETHS, 8, //Error Threshold Status
> + WTHS, 8, //Warning Threshold Status
> + NVLF, 8, //NVM Lifetime
> + , 40 //Reserve
> + }
> + Method (_DSM, 0x4, Serialized) {
> + //Accept only MSF Family type NVDIMM DSM functions
> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
> + //Handle Func 0 query implemented commands
> + If(LEqual(Arg2, 0)) {
> + //Check revision and returned proper implemented commands
> + //Support only health check for now
> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
> + }
> + //Handle MSF DSM Func 11 Get Smart and Health Info
> + If(LEqual(Arg2, 11)) {
> + Store(\_SB.NVDR.NVD1.STAT, BSTA)
> + Store(\_SB.NVDR.NVD1.HLTH, BHTH)
> + Store(\_SB.NVDR.NVD1.CTMP, BTMP)
> + Store(\_SB.NVDR.NVD1.ETHS, BETH)
> + Store(\_SB.NVDR.NVD1.WTHS, BWTH)
> + Store(\_SB.NVDR.NVD1.NVLF, BNLF)
> + Return (SMRT)
> + }
> + }
> + Return (Buffer() {0})
> + }
> + Method(_STA, 0, NotSerialized) {
> + return (0xf)
> + }
> + }
> + Device (NVD2) {
> + Name(_ADR, 0x0770)
> + Name(SMRT, Buffer(13) {0})
> + CreateDWordField(SMRT, 0, BSTA)
> + CreateWordField(SMRT, 4, BHTH)
> + CreateWordField(SMRT, 6, BTMP)
> + CreateByteField(SMRT, 8, BETH)
> + CreateByteField(SMRT, 9, BWTH)
> + CreateByteField(SMRT, 10, BNLF)
> + OperationRegion(BUF1, SystemMemory, 0x88988000, 16)
> + Field (BUF1, DWordAcc, NoLock, Preserve) {
> + STAT, 32, //Status
> + HLTH, 16, //Module Health
> + CTMP, 16, //Module Current Status
> + ETHS, 8, //Error Threshold Status
> + WTHS, 8, //Warning Threshold Status
> + NVLF, 8, //NVM Lifetime
> + , 40 //Reserve
> + }
> + Method (_DSM, 0x4, Serialized) {
> + //Accept only MSF Family type NVDIMM DSM functions
> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
> + //Handle Func 0 query implemented commands
> + If(LEqual(Arg2, 0)) {
> + //Check revision and returned proper implemented commands
> + //Support only health check for now
> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
> + }
> + //Handle MSF DSM Func 11 Get Smart and Health Info
> + If(LEqual(Arg2, 11)) {
> + Store(\_SB.NVDR.NVD2.STAT, BSTA)
> + Store(\_SB.NVDR.NVD2.HLTH, BHTH)
> + Store(\_SB.NVDR.NVD2.CTMP, BTMP)
> + Store(\_SB.NVDR.NVD2.ETHS, BETH)
> + Store(\_SB.NVDR.NVD2.WTHS, BWTH)
> + Store(\_SB.NVDR.NVD2.NVLF, BNLF)
> + Return (SMRT)
> + }
> + }
> + Return (Buffer() {0})
> + }
> + Method(_STA, 0, NotSerialized) {
> + return (0xf)
> + }
> + }
> + Device (NVD3) {
> + Name(_ADR, 0x1330)
> + Name(SMRT, Buffer(13) {0})
> + CreateDWordField(SMRT, 0, BSTA)
> + CreateWordField(SMRT, 4, BHTH)
> + CreateWordField(SMRT, 6, BTMP)
> + CreateByteField(SMRT, 8, BETH)
> + CreateByteField(SMRT, 9, BWTH)
> + CreateByteField(SMRT, 10, BNLF)
> + OperationRegion(BUF1, SystemMemory, 0xC0080000, 16)
> + Field (BUF1, DWordAcc, NoLock, Preserve) {
> + STAT, 32, //Status
> + HLTH, 16, //Module Health
> + CTMP, 16, //Module Current Status
> + ETHS, 8, //Error Threshold Status
> + WTHS, 8, //Warning Threshold Status
> + NVLF, 8, //NVM Lifetime
> + , 40 //Reserve
> + }
> + Method (_DSM, 0x4, Serialized) {
> + //Accept only MSF Family type NVDIMM DSM functions
> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
> + //Handle Func 0 query implemented commands
> + If(LEqual(Arg2, 0)) {
> + //Check revision and returned proper implemented commands
> + //Support only health check for now
> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
> + }
> + //Handle MSF DSM Func 11 Get Smart and Health Info
> + If(LEqual(Arg2, 11)) {
> + Store(\_SB.NVDR.NVD3.STAT, BSTA)
> + Store(\_SB.NVDR.NVD3.HLTH, BHTH)
> + Store(\_SB.NVDR.NVD3.CTMP, BTMP)
> + Store(\_SB.NVDR.NVD3.ETHS, BETH)
> + Store(\_SB.NVDR.NVD3.WTHS, BWTH)
> + Store(\_SB.NVDR.NVD3.NVLF, BNLF)
> + Return (SMRT)
> + }
> + }
> + Return (Buffer() {0})
> + }
> + Method(_STA, 0, NotSerialized) {
> + return (0xf)
> + }
> + }
> + Device (NVD4) {
> + Name(_ADR, 0x1770)
> + Name(SMRT, Buffer(13) {0})
> + CreateDWordField(SMRT, 0, BSTA)
> + CreateWordField(SMRT, 4, BHTH)
> + CreateWordField(SMRT, 6, BTMP)
> + CreateByteField(SMRT, 8, BETH)
> + CreateByteField(SMRT, 9, BWTH)
> + CreateByteField(SMRT, 10, BNLF)
> + OperationRegion(BUF1, SystemMemory, 0xC0088000, 16)
> + Field (BUF1, DWordAcc, NoLock, Preserve) {
> + STAT, 32, //Status
> + HLTH, 16, //Module Health
> + CTMP, 16, //Module Current Status
> + ETHS, 8, //Error Threshold Status
> + WTHS, 8, //Warning Threshold Status
> + NVLF, 8, //NVM Lifetime
> + , 40 //Reserve
> + }
> + Method (_DSM, 0x4, Serialized) {
> + //Accept only MSF Family type NVDIMM DSM functions
> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
> + //Handle Func 0 query implemented commands
> + If(LEqual(Arg2, 0)) {
> + //Check revision and returned proper implemented commands
> + //Support only health check for now
> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
> + }
> + //Handle MSF DSM Func 11 Get Smart and Health Info
> + If(LEqual(Arg2, 11)) {
> + Store(\_SB.NVDR.NVD4.STAT, BSTA)
> + Store(\_SB.NVDR.NVD4.HLTH, BHTH)
> + Store(\_SB.NVDR.NVD4.CTMP, BTMP)
> + Store(\_SB.NVDR.NVD4.ETHS, BETH)
> + Store(\_SB.NVDR.NVD4.WTHS, BWTH)
> + Store(\_SB.NVDR.NVD4.NVLF, BNLF)
> + Return (SMRT)
> + }
> + }
> + Return (Buffer() {0})
> + }
> + Method(_STA, 0, NotSerialized) {
> + return (0xf)
> + }
> + }
> + }
> +
> + Device (TPM0) {
> + //
> + // TPM 2.0
> + //
> +
> + //
> + // TAG for patching TPM2.0 _HID
> + //
> + Name (_HID, "NNNN0000")
> + Name (_CID, "MSFT0101")
> + Name (_UID, 0)
> +
> + Name (CRBB, 0x10000000)
> + Name (CRBL, 0x10000000)
> +
> + Name (RBUF, ResourceTemplate () {
> + Memory32Fixed (ReadWrite, 0x88500000, 0x1000, PCRE)
> + })
> +
> + Method (_CRS, 0x0, Serialized) {
> + // Declare fields in PCRE
> + CreateDWordField(RBUF, ^PCRE._BAS, BASE)
> + CreateDWordField(RBUF, ^PCRE._LEN, LENG)
> +
> + // Store updatable values into them
> + Store(CRBB, BASE)
> + Store(CRBL, LENG)
> +
> + Return (RBUF)
> + }
> +
> + Method (_STR,0) {
> + Return (Unicode ("TPM 2.0 Device"))
> + }
> +
> + Method (_STA, 0) {
> + if (TPMF) {
> + Return (0x0f) //Enable resources
> + }
> + Return (0x0)
> + }
> + }
> +
> + Include ("PCI-S0.Rca01.asi")
> + Include ("PCI-S0.asi")
> + Include ("PCI-S1.asi")
> + Include ("PCI-PDRC.asi")
> + }
> +} // DSDT
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
> new file mode 100644
> index 000000000000..16c00c35e3fe
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
> @@ -0,0 +1,217 @@
> +/** @file
> +
> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> + // Motherboard resource consumption for PCIE resource reservation
> + // as upstream discussion "ACPI namespace details for ARM64"
> + Device (PDRC) {
> + Name (_HID, EISAID("PNP0C02"))
> + Name (_UID, 1)
> + // S0 Start here
> + Name (PDRS, ResourceTemplate() {
> + QWordMemory ( // PCIE0 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00003BFFF0000000, // AddressMinimum - MIN
> + 0x00003BFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE1 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00003FFFF0000000, // AddressMinimum - MIN
> + 0x00003FFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE2 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000023FFF0000000, // AddressMinimum - MIN
> + 0x000023FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE3 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000027FFF0000000, // AddressMinimum - MIN
> + 0x000027FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE4 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00002BFFF0000000, // AddressMinimum - MIN
> + 0x00002BFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE5 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00002FFFF0000000, // AddressMinimum - MIN
> + 0x00002FFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + // S1 Start here
> + QWordMemory ( // PCIE6 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00007BFFF0000000, // AddressMinimum - MIN
> + 0x00007BFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE7 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00007FFFF0000000, // AddressMinimum - MIN
> + 0x00007FFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE8 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000063FFF0000000, // AddressMinimum - MIN
> + 0x000063FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIE9 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000067FFF0000000, // AddressMinimum - MIN
> + 0x000067FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> + QWordMemory ( // PCIEA 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00006BFFF0000000, // AddressMinimum - MIN
> + 0x00006BFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIEB 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00006FFFF0000000, // AddressMinimum - MIN
> + 0x00006FFFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIEC 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000033FFF0000000, // AddressMinimum - MIN
> + 0x000033FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory ( // PCIED 256M CFG region for ECAM
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000037FFF0000000, // AddressMinimum - MIN
> + 0x000037FFFFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> + })
> +
> + // Current Resource Settings
> + Method (_CRS, 0, Serialized) {
> + Return (PDRS)
> + }
> + }
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
> new file mode 100755
> index 000000000000..67e1518ebf88
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
> @@ -0,0 +1,681 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> + // PCI0 RCA0
> + Device (PCI0) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 12)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI0")
> + Name (_STR, Unicode("PCIe 0 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 128/129/130/131 respectively. PCI0 RCA0
> + //
> + Package() {0x0001FFFF, 0, 0, 128},
> + Package() {0x0001FFFF, 1, 0, 129},
> + Package() {0x0001FFFF, 2, 0, 130},
> + Package() {0x0001FFFF, 3, 0, 131},
> + Package() {0x0002FFFF, 0, 0, 128},
> + Package() {0x0002FFFF, 1, 0, 129},
> + Package() {0x0002FFFF, 2, 0, 130},
> + Package() {0x0002FFFF, 3, 0, 131},
> + Package() {0x0003FFFF, 0, 0, 128},
> + Package() {0x0003FFFF, 1, 0, 129},
> + Package() {0x0003FFFF, 2, 0, 130},
> + Package() {0x0003FFFF, 3, 0, 131},
> + Package() {0x0004FFFF, 0, 0, 128},
> + Package() {0x0004FFFF, 1, 0, 129},
> + Package() {0x0004FFFF, 2, 0, 130},
> + Package() {0x0004FFFF, 3, 0, 131},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x33FFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000040000000, // AddressMinimum - MIN
> + 0x000000004FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000300000000000, // AddressMinimum - MIN
> + 0x000033FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI0 RCA0
> +
> + // PCI1 RCA1
> + Device (PCI1) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 13)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI1")
> + Name (_STR, Unicode("PCIe 1 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 132/133/134/135 respectively. PCI1 RCA1
> + //
> + Package() {0x0001FFFF, 0, 0, 132},
> + Package() {0x0001FFFF, 1, 0, 133},
> + Package() {0x0001FFFF, 2, 0, 134},
> + Package() {0x0001FFFF, 3, 0, 135},
> + Package() {0x0002FFFF, 0, 0, 132},
> + Package() {0x0002FFFF, 1, 0, 133},
> + Package() {0x0002FFFF, 2, 0, 134},
> + Package() {0x0002FFFF, 3, 0, 135},
> + Package() {0x0003FFFF, 0, 0, 132},
> + Package() {0x0003FFFF, 1, 0, 133},
> + Package() {0x0003FFFF, 2, 0, 134},
> + Package() {0x0003FFFF, 3, 0, 135},
> + Package() {0x0004FFFF, 0, 0, 132},
> + Package() {0x0004FFFF, 1, 0, 133},
> + Package() {0x0004FFFF, 2, 0, 134},
> + Package() {0x0004FFFF, 3, 0, 135},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x37FFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000050000000, // AddressMinimum - MIN
> + 0x000000005FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + Cacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000340000000000, // AddressMinimum - MIN
> + 0x000037FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI1 RCA1
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
> new file mode 100755
> index 000000000000..7c05c6768a0e
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
> @@ -0,0 +1,2078 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> + // PCI2 RCA2
> + Device (PCI2) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF)
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 1)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI2")
> + Name (_STR, Unicode("PCIe 2 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 136/137/138/139 respectively. PCI2 RCA2
> + //
> + Package() {0x0001FFFF, 0, 0, 136},
> + Package() {0x0001FFFF, 1, 0, 137},
> + Package() {0x0001FFFF, 2, 0, 138},
> + Package() {0x0001FFFF, 3, 0, 139},
> + Package() {0x0002FFFF, 0, 0, 136},
> + Package() {0x0002FFFF, 1, 0, 137},
> + Package() {0x0002FFFF, 2, 0, 138},
> + Package() {0x0002FFFF, 3, 0, 139},
> + Package() {0x0003FFFF, 0, 0, 136},
> + Package() {0x0003FFFF, 1, 0, 137},
> + Package() {0x0003FFFF, 2, 0, 138},
> + Package() {0x0003FFFF, 3, 0, 139},
> + Package() {0x0004FFFF, 0, 0, 136},
> + Package() {0x0004FFFF, 1, 0, 137},
> + Package() {0x0004FFFF, 2, 0, 138},
> + Package() {0x0004FFFF, 3, 0, 139},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x3BFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE80000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000030000000, // AddressMinimum - MIN
> + 0x0000000037FFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000380000000000, // AddressMinimum - MIN
> + 0x00003BFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP, 0) // PCI _OSC Support Field value
> + Name (CTRL, 0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3,0,CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI2 RCA2
> +
> + // PCI3 RCA3
> + Device (PCI3) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF)
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 0)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI3")
> + Name (_STR, Unicode("PCIe 3 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 140/141/142/143 respectively. PCI3 RCA3
> + //
> + Package() {0x0001FFFF, 0, 0, 140},
> + Package() {0x0001FFFF, 1, 0, 141},
> + Package() {0x0001FFFF, 2, 0, 142},
> + Package() {0x0001FFFF, 3, 0, 143},
> + Package() {0x0002FFFF, 0, 0, 140},
> + Package() {0x0002FFFF, 1, 0, 141},
> + Package() {0x0002FFFF, 2, 0, 142},
> + Package() {0x0002FFFF, 3, 0, 143},
> + Package() {0x0003FFFF, 0, 0, 140},
> + Package() {0x0003FFFF, 1, 0, 141},
> + Package() {0x0003FFFF, 2, 0, 142},
> + Package() {0x0003FFFF, 3, 0, 143},
> + Package() {0x0004FFFF, 0, 0, 140},
> + Package() {0x0004FFFF, 1, 0, 141},
> + Package() {0x0004FFFF, 2, 0, 142},
> + Package() {0x0004FFFF, 3, 0, 143},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x3FFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to Return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE00000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000038000000, // AddressMinimum - MIN
> + 0x000000003FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00003C0000000000, // AddressMinimum - MIN
> + 0x00003FFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP, 0) // PCI _OSC Support Field value
> + Name (CTRL, 0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI3 RCA3
> +
> + // PCI4 RCB0
> + Device (PCI4) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 2)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI4")
> + Name (_STR, Unicode("PCIe 4 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 144/145/146/147 respectively. PCI4 RCB0
> + //
> + Package() {0x0001FFFF, 0, 0, 144},
> + Package() {0x0001FFFF, 1, 0, 145},
> + Package() {0x0001FFFF, 2, 0, 146},
> + Package() {0x0001FFFF, 3, 0, 147},
> + Package() {0x0002FFFF, 0, 0, 144},
> + Package() {0x0002FFFF, 1, 0, 145},
> + Package() {0x0002FFFF, 2, 0, 146},
> + Package() {0x0002FFFF, 3, 0, 147},
> + Package() {0x0003FFFF, 0, 0, 144},
> + Package() {0x0003FFFF, 1, 0, 145},
> + Package() {0x0003FFFF, 2, 0, 146},
> + Package() {0x0003FFFF, 3, 0, 147},
> + Package() {0x0004FFFF, 0, 0, 144},
> + Package() {0x0004FFFF, 1, 0, 145},
> + Package() {0x0004FFFF, 2, 0, 146},
> + Package() {0x0004FFFF, 3, 0, 147},
> + Package() {0x0005FFFF, 0, 0, 144},
> + Package() {0x0005FFFF, 1, 0, 145},
> + Package() {0x0005FFFF, 2, 0, 146},
> + Package() {0x0005FFFF, 3, 0, 147},
> + Package() {0x0006FFFF, 0, 0, 144},
> + Package() {0x0006FFFF, 1, 0, 145},
> + Package() {0x0006FFFF, 2, 0, 146},
> + Package() {0x0006FFFF, 3, 0, 147},
> + Package() {0x0007FFFF, 0, 0, 144},
> + Package() {0x0007FFFF, 1, 0, 145},
> + Package() {0x0007FFFF, 2, 0, 146},
> + Package() {0x0007FFFF, 3, 0, 147},
> + Package() {0x0008FFFF, 0, 0, 144},
> + Package() {0x0008FFFF, 1, 0, 145},
> + Package() {0x0008FFFF, 2, 0, 146},
> + Package() {0x0008FFFF, 3, 0, 147},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x23FFF0000000)
> + }
> +
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FEC0000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000001000000, // AddressMinimum - MIN
> + 0x0000000007FFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000007000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000200000000000, // AddressMinimum - MIN
> + 0x000023FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2))
> + {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI4 RCB0
> +
> + // PCI5 RCB1
> + Device (PCI5) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF)
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID,"PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 3)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI5")
> + Name (_STR, Unicode("PCIe 5 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 148/149/150/151 respectively. PCI5 RCB1
> + //
> + Package() {0x0001FFFF, 0, 0, 148},
> + Package() {0x0001FFFF, 1, 0, 149},
> + Package() {0x0001FFFF, 2, 0, 150},
> + Package() {0x0001FFFF, 3, 0, 151},
> + Package() {0x0002FFFF, 0, 0, 148},
> + Package() {0x0002FFFF, 1, 0, 149},
> + Package() {0x0002FFFF, 2, 0, 150},
> + Package() {0x0002FFFF, 3, 0, 151},
> + Package() {0x0003FFFF, 0, 0, 148},
> + Package() {0x0003FFFF, 1, 0, 149},
> + Package() {0x0003FFFF, 2, 0, 150},
> + Package() {0x0003FFFF, 3, 0, 151},
> + Package() {0x0004FFFF, 0, 0, 148},
> + Package() {0x0004FFFF, 1, 0, 149},
> + Package() {0x0004FFFF, 2, 0, 150},
> + Package() {0x0004FFFF, 3, 0, 151},
> + Package() {0x0005FFFF, 0, 0, 148},
> + Package() {0x0005FFFF, 1, 0, 149},
> + Package() {0x0005FFFF, 2, 0, 150},
> + Package() {0x0005FFFF, 3, 0, 151},
> + Package() {0x0006FFFF, 0, 0, 148},
> + Package() {0x0006FFFF, 1, 0, 149},
> + Package() {0x0006FFFF, 2, 0, 150},
> + Package() {0x0006FFFF, 3, 0, 151},
> + Package() {0x0007FFFF, 0, 0, 148},
> + Package() {0x0007FFFF, 1, 0, 149},
> + Package() {0x0007FFFF, 2, 0, 150},
> + Package() {0x0007FFFF, 3, 0, 151},
> + Package() {0x0008FFFF, 0, 0, 148},
> + Package() {0x0008FFFF, 1, 0, 149},
> + Package() {0x0008FFFF, 2, 0, 150},
> + Package() {0x0008FFFF, 3, 0, 151},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x27FFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FF00000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000008000000, // AddressMinimum - MIN
> + 0x000000000FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000240000000000, // AddressMinimum - MIN
> + 0x000027FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP, 0) // PCI _OSC Support Field value
> + Name (CTRL, 0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2))
> + {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI5 RCB1
> +
> +
> + // PCI6 RCB2
> + Device (PCI6) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID,"PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID,"PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 4)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI6")
> + Name (_STR, Unicode("PCIe 6 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 152/153/154/155 respectively. PCI6 RCB2
> + //
> + Package() {0x0001FFFF, 0, 0, 152},
> + Package() {0x0001FFFF, 1, 0, 153},
> + Package() {0x0001FFFF, 2, 0, 154},
> + Package() {0x0001FFFF, 3, 0, 155},
> + Package() {0x0002FFFF, 0, 0, 152},
> + Package() {0x0002FFFF, 1, 0, 153},
> + Package() {0x0002FFFF, 2, 0, 154},
> + Package() {0x0002FFFF, 3, 0, 155},
> + Package() {0x0003FFFF, 0, 0, 152},
> + Package() {0x0003FFFF, 1, 0, 153},
> + Package() {0x0003FFFF, 2, 0, 154},
> + Package() {0x0003FFFF, 3, 0, 155},
> + Package() {0x0004FFFF, 0, 0, 152},
> + Package() {0x0004FFFF, 1, 0, 153},
> + Package() {0x0004FFFF, 2, 0, 154},
> + Package() {0x0004FFFF, 3, 0, 155},
> + Package() {0x0005FFFF, 0, 0, 152},
> + Package() {0x0005FFFF, 1, 0, 153},
> + Package() {0x0005FFFF, 2, 0, 154},
> + Package() {0x0005FFFF, 3, 0, 155},
> + Package() {0x0006FFFF, 0, 0, 152},
> + Package() {0x0006FFFF, 1, 0, 153},
> + Package() {0x0006FFFF, 2, 0, 154},
> + Package() {0x0006FFFF, 3, 0, 155},
> + Package() {0x0007FFFF, 0, 0, 152},
> + Package() {0x0007FFFF, 1, 0, 153},
> + Package() {0x0007FFFF, 2, 0, 154},
> + Package() {0x0007FFFF, 3, 0, 155},
> + Package() {0x0008FFFF, 0, 0, 152},
> + Package() {0x0008FFFF, 1, 0, 153},
> + Package() {0x0008FFFF, 2, 0, 154},
> + Package() {0x0008FFFF, 3, 0, 155},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x2BFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000010000000, // AddressMinimum - MIN
> + 0x0000000017FFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000280000000000, // AddressMinimum - MIN
> + 0x00002BFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3,0,CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3,4,CDW2)
> + CreateDWordField (Arg3,8,CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2,SUPP)
> + Store (CDW3,CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL,0x1E,CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1,One)) {
> + Or (CDW1,0x08,CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3,CTRL)) {
> + Or (CDW1,0x10,CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL,CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1,4,CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI6 RCB2
> +
> + // PCI7 RCB3
> + Device (PCI7) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID,"PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID,"PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 5)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCI7")
> + Name (_STR, Unicode("PCIe 7 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 156/157/158/159 respectively. PCI7 RCB3
> + //
> + Package() {0x0001FFFF, 0, 0, 156},
> + Package() {0x0001FFFF, 1, 0, 157},
> + Package() {0x0001FFFF, 2, 0, 158},
> + Package() {0x0001FFFF, 3, 0, 159},
> + Package() {0x0002FFFF, 0, 0, 156},
> + Package() {0x0002FFFF, 1, 0, 157},
> + Package() {0x0002FFFF, 2, 0, 158},
> + Package() {0x0002FFFF, 3, 0, 159},
> + Package() {0x0003FFFF, 0, 0, 156},
> + Package() {0x0003FFFF, 1, 0, 157},
> + Package() {0x0003FFFF, 2, 0, 158},
> + Package() {0x0003FFFF, 3, 0, 159},
> + Package() {0x0004FFFF, 0, 0, 156},
> + Package() {0x0004FFFF, 1, 0, 157},
> + Package() {0x0004FFFF, 2, 0, 158},
> + Package() {0x0004FFFF, 3, 0, 159},
> + Package() {0x0005FFFF, 0, 0, 156},
> + Package() {0x0005FFFF, 1, 0, 157},
> + Package() {0x0005FFFF, 2, 0, 158},
> + Package() {0x0005FFFF, 3, 0, 159},
> + Package() {0x0006FFFF, 0, 0, 156},
> + Package() {0x0006FFFF, 1, 0, 157},
> + Package() {0x0006FFFF, 2, 0, 158},
> + Package() {0x0006FFFF, 3, 0, 159},
> + Package() {0x0007FFFF, 0, 0, 156},
> + Package() {0x0007FFFF, 1, 0, 157},
> + Package() {0x0007FFFF, 2, 0, 158},
> + Package() {0x0007FFFF, 3, 0, 159},
> + Package() {0x0008FFFF, 0, 0, 156},
> + Package() {0x0008FFFF, 1, 0, 157},
> + Package() {0x0008FFFF, 2, 0, 158},
> + Package() {0x0008FFFF, 3, 0, 159},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x2FFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000018000000, // AddressMinimum - MIN
> + 0x000000001FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00002C0000000000, // AddressMinimum - MIN
> + 0x00002FFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3,0,CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3,4,CDW2)
> + CreateDWordField (Arg3,8,CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2,SUPP)
> + Store (CDW3,CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL,0x1E,CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1,One)) {
> + Or (CDW1,0x08,CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3,CTRL)) {
> + Or (CDW1,0x10,CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL,CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1,4,CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCI7 RCB3
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
> new file mode 100755
> index 000000000000..2757f3124b83
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
> @@ -0,0 +1,2087 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> + //
> + // S1 Start here
> + //
> +
> + // PCIE6 S1 RCA2
> + Device (PCIA) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID,"PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF)
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID,"PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 6)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCIA")
> + Name (_STR, Unicode("PCIe 10 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 136/137/138/139 + 320 respectively. PCIA RCA2
> + //
> + Package() {0x0001FFFF, 0, 0, 456},
> + Package() {0x0001FFFF, 1, 0, 457},
> + Package() {0x0001FFFF, 2, 0, 458},
> + Package() {0x0001FFFF, 3, 0, 459},
> + Package() {0x0002FFFF, 0, 0, 456},
> + Package() {0x0002FFFF, 1, 0, 457},
> + Package() {0x0002FFFF, 2, 0, 458},
> + Package() {0x0002FFFF, 3, 0, 459},
> + Package() {0x0003FFFF, 0, 0, 456},
> + Package() {0x0003FFFF, 1, 0, 457},
> + Package() {0x0003FFFF, 2, 0, 458},
> + Package() {0x0003FFFF, 3, 0, 459},
> + Package() {0x0004FFFF, 0, 0, 456},
> + Package() {0x0004FFFF, 1, 0, 457},
> + Package() {0x0004FFFF, 2, 0, 458},
> + Package() {0x0004FFFF, 3, 0, 459},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x7BFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FF80000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000070000000, // AddressMinimum - MIN
> + 0x0000000077FFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000780000000000, // AddressMinimum - MIN
> + 0x00007BFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3,0,CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3,4,CDW2)
> + CreateDWordField (Arg3,8,CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2,SUPP)
> + Store (CDW3,CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL,0x1E,CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1,One)) {
> + Or (CDW1,0x08,CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3,CTRL)) {
> + Or (CDW1,0x10,CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL,CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1,4,CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCIA RCA2
> +
> + // PCIEB RCA3
> + Device (PCIB) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID,"PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF)
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID,"PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 7)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCIB")
> + Name (_STR, Unicode("PCIe 11 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 140/141/142/143 + 320 respectively. PCIB RCA3
> + //
> + Package() {0x0001FFFF, 0, 0, 460},
> + Package() {0x0001FFFF, 1, 0, 461},
> + Package() {0x0001FFFF, 2, 0, 462},
> + Package() {0x0001FFFF, 3, 0, 463},
> + Package() {0x0002FFFF, 0, 0, 460},
> + Package() {0x0002FFFF, 1, 0, 461},
> + Package() {0x0002FFFF, 2, 0, 462},
> + Package() {0x0002FFFF, 3, 0, 463},
> + Package() {0x0003FFFF, 0, 0, 460},
> + Package() {0x0003FFFF, 1, 0, 461},
> + Package() {0x0003FFFF, 2, 0, 462},
> + Package() {0x0003FFFF, 3, 0, 463},
> + Package() {0x0004FFFF, 0, 0, 460},
> + Package() {0x0004FFFF, 1, 0, 461},
> + Package() {0x0004FFFF, 2, 0, 462},
> + Package() {0x0004FFFF, 3, 0, 463},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x7FFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FFC0000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000078000000, // AddressMinimum - MIN
> + 0x000000007FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00007C0000000000, // AddressMinimum - MIN
> + 0x00007FFFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3,0,CDW1)
> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3,4,CDW2)
> + CreateDWordField (Arg3,8,CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2,SUPP)
> + Store (CDW3,CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL,0x1E,CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1,One)) {
> + Or (CDW1,0x08,CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3,CTRL)) {
> + Or (CDW1,0x10,CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL,CDW3)
> + Return (Arg3)
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1,4,CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCIB RCA3
> +
> + // PCIC RCB0
> + Device (PCIC) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 8)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCIC")
> + Name (_STR, Unicode("PCIe 12 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 144/145/146/147 + 320 respectively. PCIC RCB0
> + //
> + Package() {0x0001FFFF, 0, 0, 464},
> + Package() {0x0001FFFF, 1, 0, 465},
> + Package() {0x0001FFFF, 2, 0, 466},
> + Package() {0x0001FFFF, 3, 0, 467},
> + Package() {0x0002FFFF, 0, 0, 464},
> + Package() {0x0002FFFF, 1, 0, 465},
> + Package() {0x0002FFFF, 2, 0, 466},
> + Package() {0x0002FFFF, 3, 0, 467},
> + Package() {0x0003FFFF, 0, 0, 464},
> + Package() {0x0003FFFF, 1, 0, 465},
> + Package() {0x0003FFFF, 2, 0, 466},
> + Package() {0x0003FFFF, 3, 0, 467},
> + Package() {0x0004FFFF, 0, 0, 464},
> + Package() {0x0004FFFF, 1, 0, 465},
> + Package() {0x0004FFFF, 2, 0, 466},
> + Package() {0x0004FFFF, 3, 0, 467},
> + Package() {0x0005FFFF, 0, 0, 464},
> + Package() {0x0005FFFF, 1, 0, 465},
> + Package() {0x0005FFFF, 2, 0, 466},
> + Package() {0x0005FFFF, 3, 0, 467},
> + Package() {0x0006FFFF, 0, 0, 464},
> + Package() {0x0006FFFF, 1, 0, 465},
> + Package() {0x0006FFFF, 2, 0, 466},
> + Package() {0x0006FFFF, 3, 0, 467},
> + Package() {0x0007FFFF, 0, 0, 464},
> + Package() {0x0007FFFF, 1, 0, 465},
> + Package() {0x0007FFFF, 2, 0, 466},
> + Package() {0x0007FFFF, 3, 0, 467},
> + Package() {0x0008FFFF, 0, 0, 464},
> + Package() {0x0008FFFF, 1, 0, 465},
> + Package() {0x0008FFFF, 2, 0, 466},
> + Package() {0x0008FFFF, 3, 0, 467},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x63FFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000040000000, // AddressMinimum - MIN
> + 0x0000000047FFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000600000000000, // AddressMinimum - MIN
> + 0x000063FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCIC RCB0
> +
> + // PCID RCB1
> + Device (PCID) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 9)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCID")
> + Name (_STR, Unicode("PCIe 13 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 148/149/150/151 + 320 respectively. PCID RCB1
> + //
> + Package() {0x0001FFFF, 0, 0, 468},
> + Package() {0x0001FFFF, 1, 0, 469},
> + Package() {0x0001FFFF, 2, 0, 470},
> + Package() {0x0001FFFF, 3, 0, 471},
> + Package() {0x0002FFFF, 0, 0, 468},
> + Package() {0x0002FFFF, 1, 0, 469},
> + Package() {0x0002FFFF, 2, 0, 470},
> + Package() {0x0002FFFF, 3, 0, 471},
> + Package() {0x0003FFFF, 0, 0, 468},
> + Package() {0x0003FFFF, 1, 0, 469},
> + Package() {0x0003FFFF, 2, 0, 470},
> + Package() {0x0003FFFF, 3, 0, 471},
> + Package() {0x0004FFFF, 0, 0, 468},
> + Package() {0x0004FFFF, 1, 0, 469},
> + Package() {0x0004FFFF, 2, 0, 470},
> + Package() {0x0004FFFF, 3, 0, 471},
> + Package() {0x0005FFFF, 0, 0, 468},
> + Package() {0x0005FFFF, 1, 0, 469},
> + Package() {0x0005FFFF, 2, 0, 470},
> + Package() {0x0005FFFF, 3, 0, 471},
> + Package() {0x0006FFFF, 0, 0, 468},
> + Package() {0x0006FFFF, 1, 0, 469},
> + Package() {0x0006FFFF, 2, 0, 470},
> + Package() {0x0006FFFF, 3, 0, 471},
> + Package() {0x0007FFFF, 0, 0, 468},
> + Package() {0x0007FFFF, 1, 0, 469},
> + Package() {0x0007FFFF, 2, 0, 470},
> + Package() {0x0007FFFF, 3, 0, 471},
> + Package() {0x0008FFFF, 0, 0, 468},
> + Package() {0x0008FFFF, 1, 0, 469},
> + Package() {0x0008FFFF, 2, 0, 470},
> + Package() {0x0008FFFF, 3, 0, 471},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x67FFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000048000000, // AddressMinimum - MIN
> + 0x000000004FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000640000000000, // AddressMinimum - MIN
> + 0x000067FFDFFFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCID RCB1
> +
> + // PCIE RCB2
> + Device (PCIE) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 10)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCIE")
> + Name (_STR, Unicode("PCIe 14 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 152/153/154/155 + 320 respectively. PCIE RCB2
> + //
> + Package() {0x0001FFFF, 0, 0, 472},
> + Package() {0x0001FFFF, 1, 0, 473},
> + Package() {0x0001FFFF, 2, 0, 474},
> + Package() {0x0001FFFF, 3, 0, 475},
> + Package() {0x0002FFFF, 0, 0, 472},
> + Package() {0x0002FFFF, 1, 0, 473},
> + Package() {0x0002FFFF, 2, 0, 474},
> + Package() {0x0002FFFF, 3, 0, 475},
> + Package() {0x0003FFFF, 0, 0, 472},
> + Package() {0x0003FFFF, 1, 0, 473},
> + Package() {0x0003FFFF, 2, 0, 474},
> + Package() {0x0003FFFF, 3, 0, 475},
> + Package() {0x0004FFFF, 0, 0, 472},
> + Package() {0x0004FFFF, 1, 0, 473},
> + Package() {0x0004FFFF, 2, 0, 474},
> + Package() {0x0004FFFF, 3, 0, 475},
> + Package() {0x0005FFFF, 0, 0, 472},
> + Package() {0x0005FFFF, 1, 0, 473},
> + Package() {0x0005FFFF, 2, 0, 474},
> + Package() {0x0005FFFF, 3, 0, 475},
> + Package() {0x0006FFFF, 0, 0, 472},
> + Package() {0x0006FFFF, 1, 0, 473},
> + Package() {0x0006FFFF, 2, 0, 474},
> + Package() {0x0006FFFF, 3, 0, 475},
> + Package() {0x0007FFFF, 0, 0, 472},
> + Package() {0x0007FFFF, 1, 0, 473},
> + Package() {0x0007FFFF, 2, 0, 474},
> + Package() {0x0007FFFF, 3, 0, 475},
> + Package() {0x0008FFFF, 0, 0, 472},
> + Package() {0x0008FFFF, 1, 0, 473},
> + Package() {0x0008FFFF, 2, 0, 474},
> + Package() {0x0008FFFF, 3, 0, 475},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x6BFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000050000000, // AddressMinimum - MIN
> + 0x0000000057FFFFFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000680000000000, // AddressMinimum - MIN
> + 0x00006BFFDFFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCIE RCB2
> +
> + // PCIF RCB3
> + Device (PCIF) {
> + //
> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
> + // Section 6.1.5
> + //
> +
> + Name (_HID, "PNP0A08")
> + Name (_CCA, ONE)
> +
> + Method (_STA, 0, NotSerialized) {
> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
> + // run-time patching as the representation of 0 is special
> + // encoding and cannot be patched to expand with extra bytes
> + // easily. As such, we default to 0xF and patch this based
> + // on whether the port was enabled or not by the BIOS.
> + }
> +
> + //
> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
> + // root complex for use with pre-PCIe operating systems.
> + // Section 6.1.2
> + //
> +
> + Name (_CID, "PNP0A03")
> +
> + //
> + // Declare the segment number of this root complex. Most systems only
> + // have one segment, which is numbered 0.
> + // Section 6.5.6
> + //
> +
> + Name (_SEG, 11)
> +
> + //
> + // Declare the base bus number, which is the bus number of the root
> + // bus in this root complex. This is usually 0, but need not be.
> + // For root complexes supporting multiple root busses, this should
> + // be the lowest numbered root bus.
> + // Section 6.5.5
> + //
> +
> + Name (_BBN, 0)
> +
> + //
> + // The _UID value provides a way of uniquely identifying a device
> + // in the case where more than one instance of a specific device
> + // is implemented with the same _HID/_CID. For systems with a
> + // single root complex, this is usually just 0. For systems with
> + // multiple root complexes, this should be different for each
> + // root complex.
> + // Section 6.1.12
> + //
> +
> + Name (_UID, "PCIF")
> + Name (_STR, Unicode("PCIe 15 Device"))
> +
> + //
> + // Declare the PCI Routing Table.
> + // This defines SPI mappings of the four line-based interrupts
> + // associated with the root complex and hierarchy below it.
> + // Section 6.2.12
> + //
> +
> + Name (_PRT, Package() {
> +
> + //
> + // Routing for device 0, all functions.
> + // Note: ARM doesn't support LNK nodes, so the third param
> + // is 0 and the fourth param is the SPI number of the interrupt
> + // line. In this example, the A/B/C/D interrupts are wired to
> + // SPI lines 156/157/158/159 + 320 respectively. PCIF RCB3
> + //
> + Package() {0x0001FFFF, 0, 0, 476},
> + Package() {0x0001FFFF, 1, 0, 477},
> + Package() {0x0001FFFF, 2, 0, 478},
> + Package() {0x0001FFFF, 3, 0, 479},
> + Package() {0x0002FFFF, 0, 0, 476},
> + Package() {0x0002FFFF, 1, 0, 477},
> + Package() {0x0002FFFF, 2, 0, 478},
> + Package() {0x0002FFFF, 3, 0, 479},
> + Package() {0x0003FFFF, 0, 0, 476},
> + Package() {0x0003FFFF, 1, 0, 477},
> + Package() {0x0003FFFF, 2, 0, 478},
> + Package() {0x0003FFFF, 3, 0, 479},
> + Package() {0x0004FFFF, 0, 0, 476},
> + Package() {0x0004FFFF, 1, 0, 477},
> + Package() {0x0004FFFF, 2, 0, 478},
> + Package() {0x0004FFFF, 3, 0, 479},
> + Package() {0x0005FFFF, 0, 0, 476},
> + Package() {0x0005FFFF, 1, 0, 477},
> + Package() {0x0005FFFF, 2, 0, 478},
> + Package() {0x0005FFFF, 3, 0, 479},
> + Package() {0x0006FFFF, 0, 0, 476},
> + Package() {0x0006FFFF, 1, 0, 477},
> + Package() {0x0006FFFF, 2, 0, 478},
> + Package() {0x0006FFFF, 3, 0, 479},
> + Package() {0x0007FFFF, 0, 0, 476},
> + Package() {0x0007FFFF, 1, 0, 477},
> + Package() {0x0007FFFF, 2, 0, 478},
> + Package() {0x0007FFFF, 3, 0, 479},
> + Package() {0x0008FFFF, 0, 0, 476},
> + Package() {0x0008FFFF, 1, 0, 477},
> + Package() {0x0008FFFF, 2, 0, 478},
> + Package() {0x0008FFFF, 3, 0, 479},
> + })
> +
> + //
> + // Declare the resources assigned to this root complex.
> + // Section 6.2.2
> + //
> + Method (_CBA, 0, Serialized) {
> + Return (0x6FFFF0000000)
> + }
> +
> + //
> + // Declare a ResourceTemplate buffer to return the resource
> + // requirements from _CRS.
> + // Section 19.5.109
> + //
> +
> + Name (RBUF, ResourceTemplate () {
> +
> + //
> + // Declare the range of bus numbers assigned to this root
> + // complex. In this example, the minimum bus number will be
> + // 0, the maximum bus number will be 0xFF, supporting
> + // 256 busses total.
> + // Section 19.5.141
> + //
> +
> + WordBusNumber (
> + ResourceProducer,
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + PosDecode, // Decode
> + 0, // AddressGranularity
> + 0, // AddressMinimum - Minimum Bus Number
> + 255, // AddressMaximum - Maximum Bus Number
> + 0, // AddressTranslation - Set to 0
> + 256) // RangeLength - Number of Busses
> +
> + //
> + // Declare the memory range to be used for BAR memory
> + // windows. This declares a 4GB region starting at
> + // 0x4000000000.
> + // Section 19.5.80
> + //
> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000000058000000, // AddressMinimum - MIN
> + 0x000000005FFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000008000000 // RangeLength - LEN
> + )
> +
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // NonCacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x00006C0000000000, // AddressMinimum - MIN
> + 0x00006FFFDFFFFFFF, // AddressMinimum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x000003FFE0000000 // RangeLength - LEN
> + )
> + })
> +
> + Method (_CRS, 0, Serialized) {
> + Return (RBUF)
> + }
> +
> + //
> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
> + //
> + // Argments:
> + // Arg0 A Buffer containing a UUID
> + // Arg1 An Integer containing a Revision ID of the buffer format
> + // Arg2 An Integer containing a count of entries in Arg3
> + // Arg3 A Buffer containing a list of DWORD capabilities
> + // Return Value:
> + // A Buffer containing a list of capabilities
> + // See the APCI spec, Section 6.2.10,
> + // and the PCI FW spec, Section 4.5.
> + //
> + // The following is an example, and may need modification for
> + // specific implementations.
> + //
> +
> + Name (SUPP,0) // PCI _OSC Support Field value
> + Name (CTRL,0) // PCI _OSC Control Field value
> +
> + Method (_OSC, 4) {
> +
> + //
> + // Look for the PCI Host Bridge Interface UUID.
> + // Section 6.2.10.3
> + //
> +
> + //
> + // Create DWord-adressable fields from the Capabilities Buffer
> + // Create CDW1 outside the test as it's used in the else clause.
> + //
> +
> + CreateDWordField (Arg3, 0, CDW1)
> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
> +
> + CreateDWordField (Arg3, 4, CDW2)
> + CreateDWordField (Arg3, 8, CDW3)
> +
> + //
> + // Save Capabilities DWord 2 & 3
> + //
> +
> + Store (CDW2, SUPP)
> + Store (CDW3, CTRL)
> +
> + //
> + // Only allow native hot plug control if OS supports:
> + // ASPM
> + // Clock PM
> + // MSI/MSI-X
> + //
> +
> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
> +
> + //
> + // Mask bit 0 (and undefined bits)
> + //
> +
> + And (CTRL, 0x1E, CTRL)
> + }
> +
> + //
> + // Never allow native Hot plug, PME.
> + // Never allow SHPC (no SHPC controller in this system).
> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
> + // Allows PCI Express Capability Structure control
> + //
> +
> + If (AERF) {
> + And (CTRL, 0x10, CTRL)
> + } Else {
> + And (CTRL, 0x18, CTRL)
> + }
> +
> + //
> + // Check for unknown revision.
> + //
> +
> + If (LNotEqual (Arg1, One)) {
> + Or (CDW1, 0x08, CDW1)
> + }
> +
> + //
> + // Check if capabilities bits were masked.
> + //
> +
> + If (LNotEqual (CDW3, CTRL)) {
> + Or (CDW1, 0x10, CDW1)
> + }
> +
> + //
> + // Update DWORD3 in the buffer.
> + //
> +
> + Store (CTRL, CDW3)
> + Return (Arg3)
> +
> + } Else {
> +
> + //
> + // Unrecognized UUID
> + //
> +
> + Or (CDW1, 4, CDW1)
> + Return (Arg3)
> + }
> + } // End _OSC
> +
> + //
> + // Declare a _DSM method for various functions called by the OS.
> + // See the APCI spec, Section 9.14.1,
> + // and the PCI FW spec, Section 4.6.
> + // See also:
> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
> + //
> +
> + Method (_DSM, 0x4, Serialized) {
> +
> + //
> + // Match against the _DSM PCI GUID.
> + //
> +
> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
> +
> + Switch (ToInteger(Arg2)) {
> + //
> + // Function 0: Return supported functions as a bitfield
> + // with one bit for each supported function.
> + // Bit 0 must always be set, as that represents
> + // function 0 (which is what is being called here).
> + // Support for different functions may depend on
> + // the revision ID of the interface, passed as Arg1.
> + //
> +
> + Case (0) {
> +
> + //
> + // Functions 0-7 are supported.
> + //
> +
> + Return (Buffer() {0x01})
> + }
> + }
> + }
> +
> + //
> + // If not one of the function identifiers we recognize, then return a buffer
> + // with bit 0 set to 0 indicating no functions supported.
> + //
> +
> + Return (Buffer() {0})
> + }
> +
> + //
> + // Root Port 0 Device within the Root Complex.
> + //
> + Device (RP0) {
> + //
> + // Device 0, Function 0.
> + //
> +
> + Name (_ADR, 0x00000000)
> + }
> +
> + Method (_PXM, 0, NotSerialized) {
> + // Patch by code
> + Return(0xFF)
> + }
> + } // PCIF RCB3
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
> new file mode 100755
> index 000000000000..0e9db557d925
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
> @@ -0,0 +1,1303 @@
> +/** @file
> +
> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Device(CMN0) {
> + Name(_HID, "ARMHC600") // Device Identification Objects
> + Name(_CID, "ARMHC600")
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("CMN0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceConsumer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000100010000000, // AddressMinimum - MIN
> + 0x000010001fffffff, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> + QWordMemory (
> + ResourceConsumer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000100012500000, // AddressMinimum - MIN
> + 0x00001000164fffff, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000004000000 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 314 }
> + })
> +}
> +
> +Device(MC00) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008C000A00, // AddressMinimum - MIN
> + 0x000010008C000BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC01) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 1)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008C400A00, // AddressMinimum - MIN
> + 0x000010008C400BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC02) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 2)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU2"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008C800A00, // AddressMinimum - MIN
> + 0x000010008C800BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC03) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 3)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU3"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008CC00A00, // AddressMinimum - MIN
> + 0x000010008CC00BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC04) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 4)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU4"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008D000A00, // AddressMinimum - MIN
> + 0x000010008D000BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC05) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 5)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU5"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008D400A00, // AddressMinimum - MIN
> + 0x000010008D400BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC06) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 6)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU6"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008D800A00, // AddressMinimum - MIN
> + 0x000010008D800BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(MC07) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 7)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 0: MCU7"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000010008DC00A00, // AddressMinimum - MIN
> + 0x000010008DC00BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
> + })
> +}
> +
> +Device(DU00) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 64 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x000000,
> + 0x000100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU01) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 65 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x010000,
> + 0x010100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU02) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x2)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x2 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 66 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x020000,
> + 0x020100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU03) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x3)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x3 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 67 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x030000,
> + 0x030100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU04) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 68 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x040000,
> + 0x040100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU05) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 69 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x050000,
> + 0x050100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU06) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x6)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x6 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 71 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x060000,
> + 0x060100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU07) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x7)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x7 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 80 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x070000,
> + 0x070100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU08) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x8)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x8 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 81 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x080000,
> + 0x080100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU09) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x9)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x9 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 82 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x090000,
> + 0x090100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0A) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xA)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xA Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 83 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0A0000,
> + 0x0A0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0B) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xB)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xB Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 115 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0B0000,
> + 0x0B0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0C) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xC)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xC Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 116 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0C0000,
> + 0x0C0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0D) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xD)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xD Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 221 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0D0000,
> + 0x0D0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0E) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xE)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xE Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 222 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0E0000,
> + 0x0E0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU0F) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0xF)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0xF Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 223 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x0F0000,
> + 0x0F0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU10) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x10)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x10 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 248 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100000,
> + 0x100100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU11) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x11)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x11 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 249 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x110000,
> + 0x110100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU12) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x12)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x12 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 250 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x120000,
> + 0x120100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU13) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x13)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x13 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 251 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x130000,
> + 0x130100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU14) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x14)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x14 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 252 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x140000,
> + 0x140100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU15) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x15)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x15 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 253 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x150000,
> + 0x150100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU16) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x16)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x16 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 254 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x160000,
> + 0x160100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU17) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x17)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x17 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 255 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x170000,
> + 0x170100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU18) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x18)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x18 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 297 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x180000,
> + 0x180100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU19) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x19)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x19 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 298 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x190000,
> + 0x190100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1A) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1A)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1A Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 299 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1A0000,
> + 0x1A0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1B) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1B)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1B Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 300 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1B0000,
> + 0x1B0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1C) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1C)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1C Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 301 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1C0000,
> + 0x1C0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1D) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1D)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1D Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 313 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1D0000,
> + 0x1D0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1E) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1E)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1E Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 316 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1E0000,
> + 0x1E0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU1F) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x1F)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x1F Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 317 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1F0000,
> + 0x1F0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU20) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x20)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x20 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 318 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x200000,
> + 0x200100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU21) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x21)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x21 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 319 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x210000,
> + 0x210100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU22) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x22)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x22 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 344 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x220000,
> + 0x220100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU23) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x23)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x23 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 345 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x230000,
> + 0x230100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU24) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x24)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x24 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 346 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x240000,
> + 0x240100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU25) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x25)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x25 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 347 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x250000,
> + 0x250100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU26) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x26)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x26 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 348 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x260000,
> + 0x260100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU27) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x27)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x27 Socket 0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 349 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x270000,
> + 0x270100
> + }
> + }
> + }
> + })
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
> new file mode 100755
> index 000000000000..1ae1bac8098b
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
> @@ -0,0 +1,1303 @@
> +/** @file
> +
> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Device(CMN1) {
> + Name(_HID, "ARMHC600") // Device Identification Objects
> + Name(_CID, "ARMHC600")
> + Name(_UID, 1)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("CMN1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceConsumer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000500010000000, // AddressMinimum - MIN
> + 0x000050001fffffff, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000010000000 // RangeLength - LEN
> + )
> + QWordMemory (
> + ResourceConsumer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x0000500012500000, // AddressMinimum - MIN
> + 0x00005000164fffff, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000004000000 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 634 }
> + })
> +}
> +
> +Device(MC10) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 8)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU0"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008C000A00, // AddressMinimum - MIN
> + 0x000050008C000BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC11) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 9)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008C400A00, // AddressMinimum - MIN
> + 0x000050008C400BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC12) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xa)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU2"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008C800A00, // AddressMinimum - MIN
> + 0x000050008C800BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC13) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xb)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU3"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008CC00A00, // AddressMinimum - MIN
> + 0x000050008CC00BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC14) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xc)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU4"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008D000A00, // AddressMinimum - MIN
> + 0x000050008D000BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC15) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xd)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU5"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008D400A00, // AddressMinimum - MIN
> + 0x000050008D400BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC16) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xe)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU6"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008D800A00, // AddressMinimum - MIN
> + 0x000050008D800BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(MC17) {
> + Name(_HID, "ARMHD620")
> + Name(_CID, "ARMHD620")
> + Name(_UID, 0xf)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("Socket 1: MCU7"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + QWordMemory (
> + ResourceProducer, // ResourceUsage
> + PosDecode, // Decode
> + MinFixed, // IsMinFixed
> + MaxFixed, // IsMaxFixed
> + NonCacheable, // Cacheable
> + ReadWrite, // ReadAndWrite
> + 0x0000000000000000, // AddressGranularity - GRA
> + 0x000050008DC00A00, // AddressMinimum - MIN
> + 0x000050008DC00BFF, // AddressMaximum - MAX
> + 0x0000000000000000, // AddressTranslation - TRA
> + 0x0000000000000200 // RangeLength - LEN
> + )
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
> + })
> +}
> +
> +Device(DU40) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x40)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x40 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 384 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100000000,
> + 0x100000100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU41) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x41)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x41 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 385 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100010000,
> + 0x100010100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU42) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x42)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x42 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 386 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100020000,
> + 0x100020100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU43) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x43)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x43 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 387 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100030000,
> + 0x100030100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU44) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x44)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x44 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 388 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100040000,
> + 0x100040100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU45) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x45)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x45 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 389 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100050000,
> + 0x100050100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU46) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x46)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x46 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 391 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100060000,
> + 0x100060100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU47) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x47)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x47 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 400 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100070000,
> + 0x100070100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU48) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x48)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x48 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 401 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100080000,
> + 0x100080100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU49) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x49)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x49 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 402 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100090000,
> + 0x100090100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4A) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4A)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4A Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 403 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000A0000,
> + 0x1000A0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4B) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4B)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4B Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 435 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000B0000,
> + 0x1000B0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4C) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4C)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4C Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 436 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000C0000,
> + 0x1000C0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4D) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4D)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4D Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 541 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000D0000,
> + 0x1000D0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4E) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4E)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4E Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 542 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000E0000,
> + 0x1000E0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU4F) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x4F)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x4F Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 543 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1000F0000,
> + 0x1000F0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU50) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x50)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x50 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 568 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100100000,
> + 0x100100100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU51) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x51)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x51 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 569 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100110000,
> + 0x100110100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU52) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x52)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x52 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 570 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100120000,
> + 0x100120100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU53) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x53)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x53 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 571 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100130000,
> + 0x100130100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU54) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x54)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x54 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 572 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100140000,
> + 0x100140100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU55) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x55)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x55 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 573 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100150000,
> + 0x100150100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU56) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x56)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x56 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 574 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100160000,
> + 0x100160100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU57) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x57)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x57 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 575 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100170000,
> + 0x100170100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU58) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x58)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x58 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 617 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100180000,
> + 0x100180100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU59) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x59)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x59 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 618 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100190000,
> + 0x100190100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5A) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5A)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5A Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 619 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001A0000,
> + 0x1001A0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5B) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5B)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5B Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 620 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001B0000,
> + 0x1001B0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5C) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5C)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5C Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 621 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001C0000,
> + 0x1001C0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5D) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5D)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5D Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 633 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001D0000,
> + 0x1001D0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5E) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5E)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5E Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 636 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001E0000,
> + 0x1001E0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU5F) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x5F)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x5F Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 637 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x1001F0000,
> + 0x1001F0100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU60) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x60)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x60 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 638 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100200000,
> + 0x100200100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU61) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x61)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x61 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 639 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100210000,
> + 0x100210100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU62) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x62)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x62 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 664 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100220000,
> + 0x100220100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU63) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x63)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x63 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 665 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100230000,
> + 0x100230100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU64) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x64)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x64 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 666 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100240000,
> + 0x100240100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU65) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x65)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x65 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 667 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100250000,
> + 0x100250100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU66) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x66)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x66 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 668 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100260000,
> + 0x100260100
> + }
> + }
> + }
> + })
> +}
> +
> +Device(DU67) {
> + Name(_HID, "ARMHD500")
> + Name(_CID, "ARMHD500")
> + Name(_UID, 0x67)
> + Name(_CCA, ONE)
> + Name(_STR, Unicode("DSU CPM 0x67 Socket 1"))
> + Method(_STA, 0, NotSerialized) {
> + Return (0x0f)
> + }
> + Name(_CRS, ResourceTemplate() {
> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 669 }
> + })
> + Name (_DSD, Package () {
> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
> + Package () {
> + Package (2) {
> + "cpus",
> + Package (2) {
> + 0x100270000,
> + 0x100270100
> + }
> + }
> + }
> + })
> +}
> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
> new file mode 100644
> index 000000000000..0d177de8696d
> --- /dev/null
> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
> @@ -0,0 +1,10 @@
> +/** @file
> +
> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +Include ("PMU-S0.asi")
> +Include ("PMU-S1.asi")
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
> new file mode 100644
> index 000000000000..a80f1e81b24f
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
> @@ -0,0 +1,33 @@
> +/** @file
> +
> + Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <IndustryStandard/Acpi.h>
> +#include <AcpiHeader.h>
> +
> +#define BOOT_ERROR_REGION_LENGTH 0x50000
> +#define BOOT_ERROR_REGION_BASE 0x0000000088230000
> +
> +#pragma pack(1)
> +
> +EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER Bert = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE,
> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER,
> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_REVISION
> + ),
> + BOOT_ERROR_REGION_LENGTH,
> + BOOT_ERROR_REGION_BASE
> +};
> +
> +#pragma pack()
> +
> +//
> +// Reference the table being generated to prevent the optimizer from removing
> +// the data structure from the executable
> +//
> +VOID* CONST ReferenceAcpiTable = &Bert;
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
> new file mode 100644
> index 000000000000..bc2bbded11fd
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
> @@ -0,0 +1,87 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Library/AcpiLib.h>
> +#include <Library/ArmLib.h>
> +#include <Library/PcdLib.h>
> +#include <IndustryStandard/Acpi.h>
> +#include <IndustryStandard/DebugPort2Table.h>
> +#include <AcpiHeader.h>
> +
> +#pragma pack(1)
> +
> +#define DBG2_NUM_DEBUG_PORTS 1
> +#define DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS 1
> +#define DBG2_NAMESPACESTRING_FIELD_SIZE 10
> +#define SERIAL_PORT_PL011_UART_ADDR_SIZE 0x8
> +
> +#define NAME_STR_UART2 {'\\', '_', 'S', 'B', '.', 'U', 'R', 'T', '2', '\0'}
> +
> +typedef struct {
> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT Dbg2Device;
> + EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister;
> + UINT32 AddressSize;
> + UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE];
> +} DBG2_DEBUG_DEVICE_INFORMATION;
> +
> +typedef struct {
> + EFI_ACPI_DEBUG_PORT_2_DESCRIPTION_TABLE Description;
> + DBG2_DEBUG_DEVICE_INFORMATION Dbg2DeviceInfo[DBG2_NUM_DEBUG_PORTS];
> +} DBG2_TABLE;
> +
> +
> +#define DBG2_DEBUG_PORT_DDI(NumReg, SubType, UartBase, UartAddrLen, UartNameStr) { \
> + { \
> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION, /* UINT8 Revision */ \
> + sizeof (DBG2_DEBUG_DEVICE_INFORMATION), /* UINT16 Length */ \
> + NumReg, /* UINT8 NumberofGenericAddressRegisters */ \
> + DBG2_NAMESPACESTRING_FIELD_SIZE, /* UINT16 NameSpaceStringLength */ \
> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, NameSpaceString), /* UINT16 NameSpaceStringOffset */ \
> + 0, /* UINT16 OemDataLength */ \
> + 0, /* UINT16 OemDataOffset */ \
> + EFI_ACPI_DBG2_PORT_TYPE_SERIAL, /* UINT16 Port Type */ \
> + SubType, /* UINT16 Port Subtype */ \
> + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}, /* UINT8 Reserved[2] */ \
> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, BaseAddressRegister), /* UINT16 BaseAddressRegister Offset */ \
> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, AddressSize) /* UINT16 AddressSize Offset */ \
> + }, \
> + ARM_GAS32 (UartBase), /* EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister */ \
> + UartAddrLen, /* UINT32 AddressSize */ \
> + UartNameStr /* UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE] */ \
> + }
> +
> +
> +STATIC DBG2_TABLE Dbg2 = {
> + {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_DEBUG_PORT_2_TABLE_SIGNATURE,
> + DBG2_TABLE,
> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION
> + ),
> + OFFSET_OF (DBG2_TABLE, Dbg2DeviceInfo),
> + DBG2_NUM_DEBUG_PORTS /* UINT32 NumberDbgDeviceInfo */
> + },
> + {
> + // Kernel Debug Port
> + DBG2_DEBUG_PORT_DDI (
> + DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS,
> + EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_SBSA_GENERIC_UART,
> + FixedPcdGet64 (PcdSerialDbgRegisterBase),
> + SERIAL_PORT_PL011_UART_ADDR_SIZE,
> + NAME_STR_UART2
> + ),
> + }
> +};
> +
> +#pragma pack()
> +
> +//
> +// Reference the table being generated to prevent the optimizer from removing
> +// the data structure from the executable
> +//
> +VOID* CONST ReferenceAcpiTable = &Dbg2;
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
> new file mode 100755
> index 000000000000..9607b2e403e0
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
> @@ -0,0 +1,165 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +[0004] Signature : "EINJ" [Error Injection table]
> +[0004] Table Length : 00000150
> +[0001] Revision : 01
> +[0001] Checksum : 09
> +[0006] Oem ID : "Ampere"
> +[0008] Oem Table ID : "Altra "
> +[0004] Oem Revision : 00000001
> +[0004] Asl Compiler ID : "INTL"
> +[0004] Asl Compiler Revision : 20100528
> +
> +[0004] Injection Header Length : 00000030
> +[0001] Flags : 00
> +[0003] Reserved : 000000
> +[0004] Injection Entry Count : 00000009
> +
> +[0001] Action : 00 [Begin Operation]
> +[0001] Instruction : 00 [Read Register]
> +[0001] Flags (decoded below) : 00
> + Preserve Register Bits : 0
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088220000
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 01 [Get Trigger Table]
> +[0001] Instruction : 00 [Read Register]
> +[0001] Flags (decoded below) : 00
> + Preserve Register Bits : 0
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088220040
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 08 [Set Error Type With Address]
> +[0001] Instruction : 02 [Write Register]
> +[0001] Flags (decoded below) : 01
> + Preserve Register Bits : 1
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 20
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 03 [DWord Access:32]
> +[0008] Address : 0000000088221000
> +
> +[0008] Value : 00000000
> +[0008] Mask : FFFFFFFF
> +
> +[0001] Action : 02 [Set Error Type]
> +[0001] Instruction : 02 [Write Register]
> +[0001] Flags (decoded below) : 01
> + Preserve Register Bits : 1
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 20
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [DWord Access:64]
> +[0008] Address : 0000000088220080
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 03 [Get Error Type]
> +[0001] Instruction : 00 [Read Register]
> +[0001] Flags (decoded below) : 00
> + Preserve Register Bits : 0
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 00000000882200c0
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 04 [End Operation]
> +[0001] Instruction : 03 [Write Register Value]
> +[0001] Flags (decoded below) : 01
> + Preserve Register Bits : 1
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088220100
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 05 [Execute Operation]
> +[0001] Instruction : 03 [Write Register Value]
> +[0001] Flags (decoded below) : 01
> + Preserve Register Bits : 1
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 20
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 03 [DWord Access:32]
> +[0008] Address : 0000100000543010
> +
> +[0008] Value : B1A00000
> +[0008] Mask : FFFFFFFF
> +
> +[0001] Action : 06 [Check Busy Status]
> +[0001] Instruction : 01 [Read Register Value]
> +[0001] Flags (decoded below) : 00
> + Preserve Register Bits : 0
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088220140
> +
> +[0008] Value : 0000000000000001
> +[0008] Mask : FFFFFFFFFFFFFFFF
> +
> +[0001] Action : 07 [Get Command Status]
> +[0001] Instruction : 00 [Read Register]
> +[0001] Flags (decoded below) : 01
> + Preserve Register Bits : 1
> +[0001] Reserved : 00
> +
> +[0012] Register Region : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088220180
> +
> +[0008] Value : 0000000000000000
> +[0008] Mask : FFFFFFFFFFFFFFFF
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
> new file mode 100644
> index 000000000000..5be828f1cdf0
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
> @@ -0,0 +1,87 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Library/AcpiLib.h>
> +#include <IndustryStandard/Acpi63.h>
> +#include <AcpiHeader.h>
> +
> +//
> +// This macro defines the FADT flag options.
> +//
> +#define FADT_FLAGS (EFI_ACPI_6_3_HW_REDUCED_ACPI | \
> + EFI_ACPI_6_3_PWR_BUTTON)
> +
> +
> +EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE Fadt = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE,
> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE,
> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_REVISION
> + ),
> + 0, // UINT32 FirmwareCtrl
> + 0, // UINT32 Dsdt
> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved0
> + EFI_ACPI_6_3_PM_PROFILE_PERFORMANCE_SERVER, // UINT8 PreferredPmProfile
> + 0, // UINT16 SciInt
> + 0, // UINT32 SmiCmd
> + 0, // UINT8 AcpiEnable
> + 0, // UINT8 AcpiDisable
> + 0, // UINT8 S4BiosReq
> + 0, // UINT8 PstateCnt
> + 0, // UINT32 Pm1aEvtBlk
> + 0, // UINT32 Pm1bEvtBlk
> + 0, // UINT32 Pm1aCntBlk
> + 0, // UINT32 Pm1bCntBlk
> + 0, // UINT32 Pm2CntBlk
> + 0, // UINT32 PmTmrBlk
> + 0, // UINT32 Gpe0Blk
> + 0, // UINT32 Gpe1Blk
> + 0, // UINT8 Pm1EvtLen
> + 0, // UINT8 Pm1CntLen
> + 0, // UINT8 Pm2CntLen
> + 0, // UINT8 PmTmrLen
> + 0, // UINT8 Gpe0BlkLen
> + 0, // UINT8 Gpe1BlkLen
> + 0, // UINT8 Gpe1Base
> + 0, // UINT8 CstCnt
> + 0, // UINT16 PLvl2Lat
> + 0, // UINT16 PLvl3Lat
> + 0, // UINT16 FlushSize
> + 0, // UINT16 FlushStride
> + 0, // UINT8 DutyOffset
> + 0, // UINT8 DutyWidth
> + 0, // UINT8 DayAlrm
> + 0, // UINT8 MonAlrm
> + 0, // UINT8 Century
> + 0, // UINT16 IaPcBootArch
> + 0, // UINT8 Reserved1
> + FADT_FLAGS, // UINT32 Flags
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE ResetReg
> + 0, // UINT8 ResetValue
> + EFI_ACPI_6_3_ARM_PSCI_COMPLIANT, // UINT16 ArmBootArchFlags
> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION, // UINT8 MinorRevision
> + 0, // UINT64 XFirmwareCtrl
> + 0, // UINT64 XDsdt
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aEvtBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bEvtBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aCntBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bCntBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm2CntBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPmTmrBlk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe0Blk
> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe1Blk
> + ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepControlReg
> + ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepStatusReg
> + 0 // UINT64 HypervisorVendorIdentity
> +};
> +
> +//
> +// Reference the table being generated to prevent the optimizer from removing the
> +// data structure from the executable
> +//
> +VOID* CONST ReferenceAcpiTable = &Fadt;
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
> new file mode 100644
> index 000000000000..3824bd6bb956
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
> @@ -0,0 +1,180 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Library/PcdLib.h>
> +#include <Library/AcpiLib.h>
> +#include <IndustryStandard/Acpi63.h>
> +#include <AcpiHeader.h>
> +
> +#define SYSTEM_TIMER_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
> +#define CNT_READ_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
> +
> +#define SECURE_TIMER_EL1_GSIV 0x1D
> +#define NON_SECURE_TIMER_EL1_GSIV 0x1E
> +#define VIRTUAL_TIMER_GSIV 0x1B
> +#define NON_SECURE_EL2_GSIV 0x1A
> +
> +#define GTDT_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE
> +#define GTDT_TIMER_LEVEL_TRIGGERED 0
> +#define GTDT_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
> +#define GTDT_TIMER_ACTIVE_HIGH 0
> +#define GTDT_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY
> +#define GTDT_TIMER_LOSE_CONTEXT 0
> +
> +#define GTDT_GTIMER_FLAGS (GTDT_TIMER_LOSE_CONTEXT | GTDT_TIMER_ACTIVE_HIGH | GTDT_TIMER_LEVEL_TRIGGERED)
> +
> +#define WATCHDOG_COUNT FixedPcdGet32 (PcdWatchdogCount)
> +#define PLATFORM_TIMER_COUNT (WATCHDOG_COUNT + 1)
> +#define TIMER_FRAMES_COUNT 3
> +
> +#define GT_BLOCK_CTL_BASE 0x0000100002700000
> +#define GT_BLOCK_FRAME0_CTL_BASE 0x0000100002710000
> +#define GT_BLOCK_FRAME0_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
> +#define GT_BLOCK_FRAME0_GSIV 0x58
> +
> +#define GT_BLOCK_FRAME1_CTL_BASE 0x0000100002720000
> +#define GT_BLOCK_FRAME1_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
> +#define GT_BLOCK_FRAME1_GSIV 0x59
> +
> +#define GT_BLOCK_FRAME2_CTL_BASE 0x0000100002730000
> +#define GT_BLOCK_FRAME2_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
> +#define GT_BLOCK_FRAME2_GSIV 0x5A
> +
> +#define GTX_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE
> +#define GTX_TIMER_LEVEL_TRIGGERED 0
> +#define GTX_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
> +#define GTX_TIMER_ACTIVE_HIGH 0
> +
> +#define GTX_TIMER_FLAGS (GTX_TIMER_ACTIVE_HIGH | GTX_TIMER_LEVEL_TRIGGERED)
> +
> +#define GTX_TIMER_SECURE EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER
> +#define GTX_TIMER_NON_SECURE 0
> +#define GTX_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY
> +#define GTX_TIMER_LOSE_CONTEXT 0
> +
> +#define GTX_COMMON_FLAGS_S (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_SECURE)
> +#define GTX_COMMON_FLAGS_NS (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_NON_SECURE)
> +
> +#define SBSA_WATCHDOG_REFRESH_BASE 0x00001000027D0000
> +#define SBSA_WATCHDOG_CONTROL_BASE 0x00001000027C0000
> +#define SBSA_WATCHDOG_GSIV 0x5C
> +
> +#define SBSA_WATCHDOG_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE
> +#define SBSA_WATCHDOG_LEVEL_TRIGGERED 0
> +#define SBSA_WATCHDOG_ACTIVE_LOW EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY
> +#define SBSA_WATCHDOG_ACTIVE_HIGH 0
> +#define SBSA_WATCHDOG_SECURE EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER
> +#define SBSA_WATCHDOG_NON_SECURE 0
> +
> +#define SBSA_WATCHDOG_FLAGS (SBSA_WATCHDOG_NON_SECURE | SBSA_WATCHDOG_ACTIVE_HIGH | SBSA_WATCHDOG_LEVEL_TRIGGERED)
> +
> +#pragma pack (1)
> +
> +typedef struct {
> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE Gtdt;
> + EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE GtBlock;
> + EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE Frames[TIMER_FRAMES_COUNT];
> +#if (WATCHDOG_COUNT != 0)
> + EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE Watchdogs[WATCHDOG_COUNT];
> +#endif
> +} EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES;
> +
> +#pragma pack ()
> +
> +EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES Gtdt = {
> + {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE,
> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES,
> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION
> + ),
> + SYSTEM_TIMER_BASE_ADDRESS, // UINT64 CntControlBasePhysicalAddress
> + EFI_ACPI_RESERVED_DWORD, // UINT32 Reserved
> + SECURE_TIMER_EL1_GSIV, // UINT32 SecurePL1TimerGSIV
> + GTDT_GTIMER_FLAGS, // UINT32 SecurePL1TimerFlags
> + NON_SECURE_TIMER_EL1_GSIV, // UINT32 NonSecurePL1TimerGSIV
> + GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL1TimerFlags
> + VIRTUAL_TIMER_GSIV, // UINT32 VirtualTimerGSIV
> + GTDT_GTIMER_FLAGS, // UINT32 VirtualTimerFlags
> + NON_SECURE_EL2_GSIV, // UINT32 NonSecurePL2TimerGSIV
> + GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL2TimerFlags
> + CNT_READ_BASE_ADDRESS, // UINT64 CntReadBasePhysicalAddress
> + PLATFORM_TIMER_COUNT, // UINT32 PlatformTimerCount
> + sizeof (EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE), // UINT32 PlatformTimerOffset
> + },
> + {
> + EFI_ACPI_6_3_GTDT_GT_BLOCK, // UINT8 Type
> + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT16 Length
> + + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE) *
> + TIMER_FRAMES_COUNT,
> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
> + GT_BLOCK_CTL_BASE, // UINT64 CntCtlBase
> + TIMER_FRAMES_COUNT, // UINT32 GTBlockTimerCount
> + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT32 GTBlockTimerOffset
> + },
> + {
> + {
> + 0, // UINT8 GTFrameNumber
> + {EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
> + GT_BLOCK_FRAME0_CTL_BASE, // UINT64 CntBaseX
> + GT_BLOCK_FRAME0_CTL_EL0_BASE, // UINT64 CntEL0BaseX
> + GT_BLOCK_FRAME0_GSIV, // UINT32 GTxPhysicalTimerGSIV
> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
> + 0, // UINT32 GTxVirtualTimerGSIV
> + 0, // UINT32 GTxVirtualTimerFlags
> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
> + },
> + {
> + 1, // UINT8 GTFrameNumber
> + {EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
> + GT_BLOCK_FRAME1_CTL_BASE, // UINT64 CntBaseX
> + GT_BLOCK_FRAME1_CTL_EL0_BASE, // UINT64 CntEL0BaseX
> + GT_BLOCK_FRAME1_GSIV, // UINT32 GTxPhysicalTimerGSIV
> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
> + 0, // UINT32 GTxVirtualTimerGSIV
> + 0, // UINT32 GTxVirtualTimerFlags
> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
> + },
> + {
> + 2, // UINT8 GTFrameNumber
> + {EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
> + GT_BLOCK_FRAME2_CTL_BASE, // UINT64 CntBaseX
> + GT_BLOCK_FRAME2_CTL_EL0_BASE, // UINT64 CntEL0BaseX
> + GT_BLOCK_FRAME2_GSIV, // UINT32 GTxPhysicalTimerGSIV
> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
> + 0, // UINT32 GTxVirtualTimerGSIV
> + 0, // UINT32 GTxVirtualTimerFlags
> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
> + },
> + },
> +#if (WATCHDOG_COUNT != 0)
> + {
> + {
> + EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG, // UINT8 Type
> + sizeof(EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE), // UINT16 Length
> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
> + SBSA_WATCHDOG_REFRESH_BASE, // UINT64 RefreshFramePhysicalAddress
> + SBSA_WATCHDOG_CONTROL_BASE, // UINT64 WatchdogControlFramePhysicalAddress
> + SBSA_WATCHDOG_GSIV, // UINT32 WatchdogTimerGSIV
> + SBSA_WATCHDOG_FLAGS // UINT32 WatchdogTimerFlags
> + }
> + }
> +#endif
> +};
> +
> +//
> +// Reference the table being generated to prevent the optimizer from removing the
> +// data structure from the executable
> +//
> +VOID* CONST ReferenceAcpiTable = &Gtdt;
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
> new file mode 100644
> index 000000000000..4413428719b8
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
> @@ -0,0 +1,330 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +[0004] Signature : "HEST" [Hardware Error Source Table]
> +[0004] Table Length : 00000308
> +[0001] Revision : 01
> +[0001] Checksum : 20
> +[0006] Oem ID : "Ampere"
> +[0008] Oem Table ID : "Altra "
> +[0004] Oem Revision : 00000001
> +[0004] Asl Compiler ID : "INTL"
> +[0004] Asl Compiler Revision : 20100528
> +
> +[0004] Error Source Count : 00000008
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0000
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200000
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000100000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1D00000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0001
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200008
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 00 [Polled]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000100000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1C00000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0002
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200010
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000100000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1F00000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0006
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200030
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000100000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1900000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0007
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200038
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000100000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1900001
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0003
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200018
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000500000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1D00000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0004
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200020
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 00 [Polled]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000500000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1C00000
> +
> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
> +[0002] Source Id : 0005
> +[0002] Related Source Id : FFFF
> +[0001] Reserved : 00
> +[0001] Enabled : 01
> +[0004] Records To Preallocate : 00000001
> +[0004] Max Sections Per Record : 00000001
> +[0004] Max Raw Data Length : 00001000
> +
> +[0012] Error Status Address : [Generic Address Structure]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000000088200028
> +
> +[0028] Notify : [Hardware Error Notification Structure]
> +[0001] Notify Type : 03 [SCI]
> +[0001] Notify Length : 1C
> +[0002] Configuration Write Enable : 0000
> +[0004] PollInterval : 00000BB8
> +[0004] Vector : 00000000
> +[0004] Polling Threshold Value : 00000000
> +[0004] Polling Threshold Window : 00000000
> +[0004] Error Threshold Value : 00000000
> +[0004] Error Threshold Window : 00000000
> +
> +[0004] Error Status Block Length : 00001000
> +
> +[0012] Read Ack Register : [Generic Address Structure v2]
> +[0001] Space ID : 00 [SystemMemory]
> +[0001] Bit Width : 40
> +[0001] Bit Offset : 00
> +[0001] Encoded Access Width : 04 [QWord Access:64]
> +[0008] Address : 0000500000543010
> +
> +[0008] Read Ack Preserve : 00000000
> +[0008] Read Ack Write : B1F00000
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
> new file mode 100644
> index 000000000000..3c0a048552cf
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
> @@ -0,0 +1,17 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +[0004] Signature : "SDEI"
> +[0004] Table Length : 0000003E
> +[0001] Revision : 01
> +[0001] Checksum : 59
> +[0006] Oem ID : "Ampere"
> +[0008] Oem Table ID : "Altra "
> +[0004] Oem Revision : 00000001
> +[0004] Asl Compiler ID : "INTL"
> +[0004] Asl Compiler Revision : 20160930
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
> new file mode 100644
> index 000000000000..42042f8a3474
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
> @@ -0,0 +1,81 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +#include <Library/PcdLib.h>
> +#include <Library/AcpiLib.h>
> +#include <IndustryStandard/Acpi63.h>
> +#include <IndustryStandard/SerialPortConsoleRedirectionTable.h>
> +#include <AcpiHeader.h>
> +
> +STATIC EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE Spcr = {
> + __ACPI_HEADER (
> + EFI_ACPI_6_3_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE,
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE,
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_REVISION
> + ),
> + // UINT8 InterfaceType;
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_PL011_UART,
> + // UINT8 Reserved1[3];
> + {
> + EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE,
> + EFI_ACPI_RESERVED_BYTE
> + },
> + // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddress;
> + ARM_GAS32 (FixedPcdGet64 (PcdSerialRegisterBase)),
> + // UINT8 InterruptType;
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_GIC,
> + // UINT8 Irq;
> + 0, // Not used on ARM
> + // UINT32 GlobalSystemInterrupt;
> + FixedPcdGet32 (PL011UartInterrupt),
> + // UINT8 BaudRate;
> +#if (FixedPcdGet64 (PcdUartDefaultBaudRate) == 9600)
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_9600,
> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 19200)
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_19200,
> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 57600)
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_57600,
> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 115200)
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_115200,
> +#else
> +#error Unsupported SPCR Baud Rate
> +#endif
> + // UINT8 Parity;
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_PARITY_NO_PARITY,
> + // UINT8 StopBits;
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_STOP_BITS_1,
> + // UINT8 FlowControl;
> + 0,
> + // UINT8 TerminalType;
> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT_UTF8,
> + // UINT8 Reserved2;
> + EFI_ACPI_RESERVED_BYTE,
> + // UINT16 PciDeviceId;
> + 0xFFFF,
> + // UINT16 PciVendorId;
> + 0xFFFF,
> + // UINT8 PciBusNumber;
> + 0x00,
> + // UINT8 PciDeviceNumber;
> + 0x00,
> + // UINT8 PciFunctionNumber;
> + 0x00,
> + // UINT32 PciFlags;
> + 0x00000000,
> + // UINT8 PciSegment;
> + 0x00,
> + // UINT32 Reserved3;
> + EFI_ACPI_RESERVED_DWORD
> +};
> +
> +//
> +// Reference the table being generated to prevent the optimizer from removing the
> +// data structure from the executable
> +//
> +VOID* CONST ReferenceAcpiTable = &Spcr;
> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
> new file mode 100755
> index 000000000000..cdb4bf5de9bf
> --- /dev/null
> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
> @@ -0,0 +1,15 @@
> +/** @file
> +
> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
> +
> + SPDX-License-Identifier: BSD-2-Clause-Patent
> +
> +**/
> +
> +DefinitionBlock("Ssdt.aml", "SSDT", 2, "Ampere", "Altra ", 0x00000001)
> +{
> + Method (MAIN, 0, NotSerialized)
> + {
> + Return (Zero)
> + }
> +}
> --
> 2.17.1
>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#76094): https://edk2.groups.io/g/devel/message/76094
Mute This Topic: https://groups.io/mt/83097115/1787277
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org]
-=-=-=-=-=-=-=-=-=-=-=-
On 6/5/21 06:50, Leif Lindholm wrote:
> On Wed, May 26, 2021 at 17:07:05 +0700, Nhi Pham wrote:
>> Add various ACPI tables for the Mt. Jade platform including: DSDT, SPCR,
>> DBG2, GTDT, FACP, SSDT, MADT, PPTT, PCCT, SLIT, SRAT, and NFIT.
>>
>> Cc: Thang Nguyen <thang@os.amperecomputing.com>
>> Cc: Chuong Tran <chuong@os.amperecomputing.com>
>> Cc: Phong Vo <phong@os.amperecomputing.com>
>> Cc: Leif Lindholm <leif@nuviainc.com>
>> Cc: Michael D Kinney <michael.d.kinney@intel.com>
>> Cc: Ard Biesheuvel <ardb+tianocore@kernel.org>
>> Cc: Nate DeSimone <nathaniel.l.desimone@intel.com>
>>
>> Signed-off-by: Nhi Pham <nhi@os.amperecomputing.com>
> Contents of ACPI tables not reviewed.
> Creation modes on many of these files are incorrect (as commented on
> cover letter).
Thanks for catching that. Will correct them in the v3.
Best regards,
Nhi
> Address this, and you can have:
> Acked-by: Leif Lindholm <leif@nuviainc.com>
>
> /
> Leif
>
>> ---
>> Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc | 8 +
>> Platform/Ampere/JadePkg/Jade.dsc | 23 +
>> Platform/Ampere/JadePkg/Jade.fdf | 8 +
>> Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf | 20 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf | 75 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf | 44 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h | 121 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h | 49 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h | 76 +
>> Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h | 37 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c | 457 ++
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c | 445 ++
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c | 351 ++
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c | 599 +++
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c | 196 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c | 178 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c | 378 ++
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c | 190 +
>> Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c | 274 +
>> Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi | 5639 ++++++++++++++++++++
>> Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi | 5639 ++++++++++++++++++++
>> Platform/Ampere/JadePkg/AcpiTables/CPU.asi | 127 +
>> Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl | 575 ++
>> Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi | 217 +
>> Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi | 681 +++
>> Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi | 2078 ++++++++
>> Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi | 2087 ++++++++
>> Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi | 1303 +++++
>> Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi | 1303 +++++
>> Platform/Ampere/JadePkg/AcpiTables/PMU.asi | 10 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc | 33 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc | 87 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl | 165 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc | 87 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc | 180 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl | 330 ++
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl | 17 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc | 81 +
>> Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl | 15 +
>> 39 files changed, 24183 insertions(+)
>>
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
>> index 3c47099b8edc..11f50f2f09cd 100755
>> --- a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc
>> @@ -466,6 +466,14 @@ [PcdsFixedAtBuild.common]
>> #
>> gEfiMdeModulePkgTokenSpaceGuid.PcdBootManagerMenuFile|{ 0x21, 0xaa, 0x2c, 0x46, 0x14, 0x76, 0x03, 0x45, 0x83, 0x6e, 0x8a, 0xb6, 0xf4, 0x66, 0x23, 0x31 }
>>
>> + #
>> + # ACPI table
>> + #
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId|"Ampere"
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId|0x2020206172746C41 # Altra
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId|0x2E504D41 # AMP.
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision|0x01000013
>> +
>> #
>> # Enable strict image permissions for all images. (This applies
>> # only to images that were built with >= 4 KB section alignment.)
>> diff --git a/Platform/Ampere/JadePkg/Jade.dsc b/Platform/Ampere/JadePkg/Jade.dsc
>> index 9b9a5d0bad0f..0f9d0adbd34e 100755
>> --- a/Platform/Ampere/JadePkg/Jade.dsc
>> +++ b/Platform/Ampere/JadePkg/Jade.dsc
>> @@ -81,12 +81,24 @@ [LibraryClasses]
>> #
>> FailSafeLib|Platform/Ampere/AmperePlatformPkg/Library/FailSafeLib/FailSafeLib.inf
>>
>> + #
>> + # ACPI Libraries
>> + #
>> + AcpiLib|EmbeddedPkg/Library/AcpiLib/AcpiLib.inf
>> + AcpiHelperLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiHelperLib/AcpiHelperLib.inf
>> + AcpiPccLib|Platform/Ampere/AmperePlatformPkg/Library/AcpiPccLib/AcpiPccLib.inf
>> +
>> ################################################################################
>> #
>> # Specific Platform Pcds
>> #
>> ################################################################################
>> [PcdsFeatureFlag.common]
>> + #
>> + # Activate AcpiSdtProtocol
>> + #
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdInstallAcpiSdtProtocol|TRUE
>> +
>> [PcdsFixedAtBuild.common]
>>
>> !if $(SECURE_BOOT_ENABLE) == TRUE
>> @@ -108,3 +120,14 @@ [Components.common]
>> # FailSafe and Watchdog Timer
>> #
>> Platform/Ampere/AmperePlatformPkg/Drivers/FailSafeDxe/FailSafeDxe.inf
>> +
>> + #
>> + # ACPI
>> + #
>> + MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf {
>> + <PcdsFixedAtBuild>
>> + gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2B
>> + }
>> + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
>> + Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
>> + Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
>> diff --git a/Platform/Ampere/JadePkg/Jade.fdf b/Platform/Ampere/JadePkg/Jade.fdf
>> index 375455086d0b..2c6f9fac76fd 100755
>> --- a/Platform/Ampere/JadePkg/Jade.fdf
>> +++ b/Platform/Ampere/JadePkg/Jade.fdf
>> @@ -289,4 +289,12 @@ [FV.FvMain]
>> #
>> !include NetworkPkg/Network.fdf.inc
>>
>> + #
>> + # ACPI
>> + #
>> + INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf
>> + INF Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
>> + INF RuleOverride=ACPITABLE Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
>> + INF RuleOverride=ACPITABLE Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
>> +
>> !include Platform/Ampere/AmperePlatformPkg/FvRules.fdf.inc
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
>> new file mode 100644
>> index 000000000000..1cf632f8a406
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf
>> @@ -0,0 +1,20 @@
>> +## @file
>> +#
>> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +#
>> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>> +#
>> +##
>> +
>> +[Defines]
>> + INF_VERSION = 0x0001001B
>> + BASE_NAME = JadeAcpiTables
>> + FILE_GUID = 5ADDBC13-8634-480C-9B94-671B7855CDB8
>> + MODULE_TYPE = USER_DEFINED
>> + VERSION_STRING = 1.0
>> +
>> +[Sources]
>> + Dsdt.asl
>> +
>> +[Packages]
>> + MdePkg/MdePkg.dec
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
>> new file mode 100644
>> index 000000000000..a1a323eee472
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf
>> @@ -0,0 +1,75 @@
>> +## @file
>> +#
>> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +#
>> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>> +#
>> +##
>> +
>> +[Defines]
>> + INF_VERSION = 0x0001001B
>> + BASE_NAME = AcpiPlatformDxe
>> + FILE_GUID = CDA4ED56-6960-4092-885D-FEF37D29093E
>> + MODULE_TYPE = DXE_DRIVER
>> + VERSION_STRING = 1.0
>> + ENTRY_POINT = AcpiPlatformDxeInitialize
>> +
>> +[Sources.common]
>> + AcpiApei.c
>> + AcpiApei.h
>> + AcpiDsdt.c
>> + AcpiMadt.c
>> + AcpiNfit.c
>> + AcpiPcct.c
>> + AcpiPptt.c
>> + AcpiPlatform.h
>> + AcpiPlatformDxe.c
>> + AcpiSlit.c
>> + AcpiSrat.c
>> +
>> +[Packages]
>> + ArmPkg/ArmPkg.dec
>> + ArmPlatformPkg/ArmPlatformPkg.dec
>> + EmbeddedPkg/EmbeddedPkg.dec
>> + MdeModulePkg/MdeModulePkg.dec
>> + MdePkg/MdePkg.dec
>> + Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
>> + Silicon/Ampere/AmpereSiliconPkg/AmpereSiliconPkg.dec
>> +
>> +[LibraryClasses]
>> + AcpiHelperLib
>> + AcpiLib
>> + AcpiPccLib
>> + AmpereCpuLib
>> + BaseLib
>> + DebugLib
>> + FlashLib
>> + UefiBootServicesTableLib
>> + UefiDriverEntryPoint
>> + UefiLib
>> + UefiRuntimeServicesTableLib
>> +
>> +[Pcd]
>> + gArmPlatformTokenSpaceGuid.PcdCoreCount
>> + gArmPlatformTokenSpaceGuid.PcdClusterCount
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision
>> + gAmpereTokenSpaceGuid.PcdPmproDbBaseReg
>> + gAmpereTokenSpaceGuid.PcdSmproDbBaseReg
>> +
>> +[Guids]
>> + gArmMpCoreInfoGuid
>> + gEfiAcpiTableGuid
>> + gEfiEventReadyToBootGuid
>> + gPlatformHobGuid
>> +
>> +[Protocols]
>> + gEfiAcpiTableProtocolGuid ## ALWAYS_CONSUMED
>> + gEfiAcpiSdtProtocolGuid
>> + gEfiPciRootBridgeIoProtocolGuid
>> +
>> +[Depex]
>> + gEfiAcpiTableProtocolGuid
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
>> new file mode 100644
>> index 000000000000..acc4092c650d
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf
>> @@ -0,0 +1,44 @@
>> +## @file
>> +#
>> +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +#
>> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>> +#
>> +##
>> +
>> +[Defines]
>> + INF_VERSION = 0x0001001B
>> + BASE_NAME = AcpiCommonTables
>> + FILE_GUID = CEFA2AEB-357E-4F48-8066-EA950853056E
>> + MODULE_TYPE = USER_DEFINED
>> + VERSION_STRING = 1.0
>> +
>> +[Sources]
>> + Bert.aslc
>> + Dbg2.aslc
>> + Einj.asl
>> + Fadt.aslc
>> + Gtdt.aslc
>> + Hest.asl
>> + Sdei.asl
>> + Spcr.aslc
>> + Ssdt.asl
>> +
>> +[Packages]
>> + ArmPkg/ArmPkg.dec
>> + ArmPlatformPkg/ArmPlatformPkg.dec
>> + EmbeddedPkg/EmbeddedPkg.dec
>> + MdeModulePkg/MdeModulePkg.dec
>> + MdePkg/MdePkg.dec
>> + Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dec
>> +
>> +[FixedPcd]
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdSerialRegisterBase ## CONSUMES
>> + gArmPlatformTokenSpaceGuid.PL011UartInterrupt ## CONSUMES
>> + gArmPlatformTokenSpaceGuid.PcdWatchdogCount ## CONSUMES
>> +
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision ## CONSUMES
>> + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision ## CONSUMES
>> +
>> + gArmPlatformTokenSpaceGuid.PcdSerialDbgRegisterBase ## CONSUMES
>> + gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate ## CONSUMES
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
>> new file mode 100644
>> index 000000000000..c207142459ad
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h
>> @@ -0,0 +1,121 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#ifndef ACPI_APEI_H_
>> +#define ACPI_APEI_H_
>> +
>> +#include <Base.h>
>> +#include <IndustryStandard/Acpi63.h>
>> +#include <Library/AcpiHelperLib.h>
>> +#include <Library/AmpereCpuLib.h>
>> +#include <Library/BaseLib.h>
>> +#include <Library/BaseMemoryLib.h>
>> +#include <Library/DebugLib.h>
>> +#include <Library/MemoryAllocationLib.h>
>> +#include <Library/UefiBootServicesTableLib.h>
>> +#include <Library/UefiRuntimeServicesTableLib.h>
>> +#include <Platform/Ac01.h>
>> +#include <Protocol/AcpiTable.h>
>> +
>> +#pragma pack(1)
>> +#define BERT_MSG_SIZE 0x2C
>> +#define BERT_ERROR_TYPE 0x7F
>> +#define BERT_UEFI_FAILURE 5
>> +#define RAS_2P_TYPE 0x03
>> +#define BERT_DEFAULT_ERROR_SEVERITY 0x1
>> +#define GENERIC_ERROR_DATA_REVISION 0x300
>> +
>> +
>> +#define PLAT_CRASH_ITERATOR_SIZE 0x398
>> +#define SMPRO_CRASH_SIZE 0x800
>> +#define PMPRO_CRASH_SIZE 0x800
>> +#define HEST_NUM_ENTRIES_PER_SOC 3
>> +
>> +#define CURRENT_BERT_VERSION 0x10
>> +#define BERT_FLASH_OFFSET 0x91B30000ULL
>> +#define BERT_DDR_OFFSET 0x88230000ULL
>> +#define BERT_DDR_LENGTH 0x50000
>> +
>> +typedef struct {
>> + UINT8 Type;
>> + UINT8 SubType;
>> + UINT16 Instance;
>> + CHAR8 Msg[BERT_MSG_SIZE];
>> +} APEI_BERT_ERROR_DATA;
>> +
>> +typedef struct {
>> + APEI_BERT_ERROR_DATA Vendor;
>> + UINT8 BertRev;
>> + UINT8 S0PmproRegisters[PMPRO_CRASH_SIZE];
>> + UINT8 S0SmproRegisters[SMPRO_CRASH_SIZE];
>> + UINT8 S1PmproRegisters[PMPRO_CRASH_SIZE];
>> + UINT8 S1SmproRegisters[SMPRO_CRASH_SIZE];
>> + UINT8 AtfDump[PLATFORM_CPU_MAX_NUM_CORES * PLAT_CRASH_ITERATOR_SIZE];
>> +} APEI_CRASH_DUMP_DATA;
>> +
>> +typedef struct {
>> + EFI_ACPI_6_3_GENERIC_ERROR_STATUS_STRUCTURE Ges;
>> + EFI_ACPI_6_3_GENERIC_ERROR_DATA_ENTRY_STRUCTURE Ged;
>> + APEI_CRASH_DUMP_DATA Bed;
>> +} APEI_CRASH_DUMP_BERT_ERROR;
>> +#pragma pack()
>> +
>> +VOID
>> +EFIAPI
>> +CreateDefaultBertData (
>> + APEI_BERT_ERROR_DATA *Data
>> + );
>> +
>> +VOID
>> +EFIAPI
>> +WrapBertErrorData (
>> + APEI_CRASH_DUMP_BERT_ERROR *WrappedError
>> + );
>> +
>> +VOID
>> +EFIAPI
>> +PullBertSpinorData (
>> + APEI_CRASH_DUMP_DATA *BertErrorData
>> + );
>> +
>> +VOID
>> +EFIAPI
>> +AdjustBERTRegionLen (
>> + UINT32 Len
>> + );
>> +
>> +BOOLEAN
>> +EFIAPI
>> +IsBertEnabled (
>> + VOID
>> + );
>> +
>> +VOID
>> +EFIAPI
>> +WriteDDRBertTable (
>> + APEI_CRASH_DUMP_BERT_ERROR *Data
>> + );
>> +
>> +VOID
>> +WriteSpinorDefaultBertTable (
>> + APEI_CRASH_DUMP_DATA *SpiRefrenceData
>> + );
>> +
>> +EFI_STATUS
>> +EFIAPI
>> +AcpiApeiUpdate (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +EFIAPI
>> +AcpiPopulateBert (
>> + VOID
>> + );
>> +
>> +#endif /* ACPI_APEI_H_ */
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
>> new file mode 100644
>> index 000000000000..920579281dd5
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h
>> @@ -0,0 +1,49 @@
>> +/** @file
>> +
>> + Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#ifndef ACPI_NFIT_H_
>> +#define ACPI_NFIT_H_
>> +
>> +#include <Platform/Ac01.h>
>> +
>> +#define NVDIMM_SK0 0
>> +#define NVDIMM_SK1 1
>> +#define NVDIMM_NUM_PER_SK (PLATFORM_NVDIMM_MCU_MAX_PER_SK * PLATFORM_NVDIMM_NUM_MAX_PER_MCU)
>> +#define ONE_GB (1024 * 1024 * 1024)
>> +
>> +enum NvdimmMode {
>> + NVDIMM_DISABLED = 0,
>> + NVDIMM_NON_HASHED = 1,
>> + NVDIMM_HASHED = 2
>> +};
>> +
>> +typedef struct {
>> + BOOLEAN Enabled;
>> + UINT64 NvdSize;
>> + UINT32 DeviceHandle;
>> + UINT16 PhysId;
>> + UINT8 InterleaveWays;
>> + UINT64 RegionOffset;
>> + UINT16 VendorId;
>> + UINT16 DeviceId;
>> + UINT16 RevisionId;
>> + UINT16 SubVendorId;
>> + UINT16 SubDeviceId;
>> + UINT16 SubRevisionId;
>> + UINT32 SerialNumber;
>> +} NVDIMM_INFO;
>> +
>> +typedef struct {
>> + UINT8 NvdRegionNum;
>> + UINT8 NvdRegionId[PLATFORM_NVDIMM_REGION_MAX_PER_SK];
>> + UINT8 NvdMode;
>> + UINT8 NvdNum;
>> + NVDIMM_INFO NvdInfo[NVDIMM_NUM_PER_SK];
>> +} NVDIMM_DATA;
>> +
>> +#endif
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
>> new file mode 100644
>> index 000000000000..ce4d9b8440b8
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h
>> @@ -0,0 +1,76 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#ifndef ACPI_PLATFORM_H_
>> +#define ACPI_PLATFORM_H_
>> +
>> +#include <Uefi.h>
>> +
>> +#include <AcpiHeader.h>
>> +#include <Guid/EventGroup.h>
>> +#include <Guid/PlatformInfoHobGuid.h>
>> +#include <IndustryStandard/Acpi63.h>
>> +#include <Library/ArmLib/ArmLibPrivate.h>
>> +#include <Library/AcpiHelperLib.h>
>> +#include <Library/AcpiLib.h>
>> +#include <Library/AmpereCpuLib.h>
>> +#include <Library/BaseMemoryLib.h>
>> +#include <Library/DebugLib.h>
>> +#include <Library/DevicePathLib.h>
>> +#include <Library/HobLib.h>
>> +#include <Library/MemoryAllocationLib.h>
>> +#include <Library/PcdLib.h>
>> +#include <Library/PrintLib.h>
>> +#include <Library/UefiBootServicesTableLib.h>
>> +#include <Library/UefiLib.h>
>> +#include <Library/UefiRuntimeServicesTableLib.h>
>> +#include <Platform/Ac01.h>
>> +#include <PlatformInfoHob.h>
>> +#include <Protocol/AcpiTable.h>
>> +
>> +EFI_STATUS
>> +AcpiPatchDsdtTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallMadtTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallNfitTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiPcctInit (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallPcctTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallPpttTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallSlitTable (
>> + VOID
>> + );
>> +
>> +EFI_STATUS
>> +AcpiInstallSratTable (
>> + VOID
>> + );
>> +
>> +#endif /* ACPI_PLATFORM_H_ */
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
>> new file mode 100644
>> index 000000000000..d604b712d8c8
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h
>> @@ -0,0 +1,37 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#ifndef ACPI_HEADER_H_
>> +#define ACPI_HEADER_H_
>> +
>> +#include <IndustryStandard/Acpi.h>
>> +
>> +//
>> +// ACPI table information used to initialize tables.
>> +//
>> +#define EFI_ACPI_OEM_ID {'A','m','p','e','r','e'}
>> +#define EFI_ACPI_OEM_TABLE_ID SIGNATURE_64('A','l','t','r','a',' ',' ',' ')
>> +#define EFI_ACPI_OEM_REVISION FixedPcdGet32 (PcdAcpiDefaultOemRevision)
>> +#define EFI_ACPI_CREATOR_ID SIGNATURE_32('A','M','P','.')
>> +#define EFI_ACPI_CREATOR_REVISION FixedPcdGet32 (PcdAcpiDefaultCreatorRevision)
>> +
>> +// A macro to initialise the common header part of EFI ACPI tables as defined by
>> +// EFI_ACPI_DESCRIPTION_HEADER structure.
>> +#define __ACPI_HEADER(Signature, Type, Revision) { \
>> + Signature, /* UINT32 Signature */ \
>> + sizeof (Type), /* UINT32 Length */ \
>> + Revision, /* UINT8 Revision */ \
>> + 0, /* UINT8 Checksum */ \
>> + EFI_ACPI_OEM_ID, /* UINT8 OemId[6] */ \
>> + EFI_ACPI_OEM_TABLE_ID, /* UINT64 OemTableId */ \
>> + EFI_ACPI_OEM_REVISION, /* UINT32 OemRevision */ \
>> + EFI_ACPI_CREATOR_ID, /* UINT32 CreatorId */ \
>> + EFI_ACPI_CREATOR_REVISION /* UINT32 CreatorRevision */ \
>> + }
>> +
>> +#endif /* ACPI_HEADER_H_ */
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
>> new file mode 100644
>> index 000000000000..fa188c7776db
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c
>> @@ -0,0 +1,457 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Uefi.h>
>> +
>> +#include <Library/AcpiHelperLib.h>
>> +#include <Library/FlashLib.h>
>> +#include <Library/NVParamLib.h>
>> +#include <NVParamDef.h>
>> +
>> +#include "AcpiApei.h"
>> +
>> +UINT8 AMPERE_GUID[16] = {0x8d, 0x89, 0xed, 0xe8, 0x16, 0xdf, 0xcc, 0x43, 0x8e, 0xcc, 0x54, 0xf0, 0x60, 0xef, 0x15, 0x7f};
>> +CHAR8 DEFAULT_BERT_REBOOT_MSG[BERT_MSG_SIZE] = "Unknown reboot reason";
>> +
>> +STATIC VOID
>> +AcpiApeiUninstallTable (
>> + UINT32 Signature
>> + )
>> +{
>> + EFI_STATUS Status;
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol;
>> + EFI_ACPI_SDT_HEADER *Table;
>> + EFI_ACPI_TABLE_VERSION TableVersion;
>> + UINTN TableKey;
>> + UINTN Idx;
>> +
>> + /*
>> + * Get access to ACPI tables
>> + */
>> + Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **)&AcpiTableProtocol);
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table protocol\n", __FUNCTION__, __LINE__));
>> + return;
>> + }
>> +
>> + Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table support protocol\n", __FUNCTION__, __LINE__));
>> + return;
>> + }
>> +
>> + /*
>> + * Search for ACPI Table Signature
>> + */
>> + for (Idx = 0; ; Idx++) {
>> + Status = AcpiTableSdtProtocol->GetAcpiTable (Idx, &Table, &TableVersion, &TableKey);
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to get ACPI table index %d \n", __FUNCTION__, __LINE__, Idx));
>> + return;
>> + } else if (Table->Signature == Signature) {
>> + break;
>> + }
>> + }
>> +
>> + /*
>> + * Uninstall ACPI Table
>> + */
>> + Status = AcpiTableProtocol->UninstallAcpiTable (AcpiTableProtocol, TableKey);
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to uninstall table\n", __FUNCTION__, __LINE__));
>> + }
>> +}
>> +
>> +VOID
>> +AdjustBERTRegionLen (
>> + UINT32 Len
>> + )
>> +{
>> + UINT32 Signature = EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE;
>> + EFI_STATUS Status;
>> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
>> + EFI_ACPI_TABLE_VERSION TableVersion;
>> + UINTN TableKey;
>> + UINTN Idx;
>> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER *Table;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiSdtProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableSdtProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
>> + return;
>> + }
>> +
>> + /*
>> + * Search for ACPI Table Signature
>> + */
>> + for (Idx = 0; ; Idx++) {
>> + Status = AcpiTableSdtProtocol->GetAcpiTable (
>> + Idx,
>> + (EFI_ACPI_SDT_HEADER **)&Table,
>> + &TableVersion,
>> + &TableKey
>> + );
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "APEI: Unable to get ACPI table index:%d\n", Idx));
>> + return;
>> + } else if (Table->Header.Signature == Signature) {
>> + break;
>> + }
>> + }
>> +
>> + /*
>> + * Adjust Boot Error Region Length
>> + */
>> + Table->BootErrorRegionLength = Len;
>> +
>> + AcpiTableChecksum ((UINT8 *)Table, Table->Header.Length);
>> +}
>> +
>> +/*
>> + * Retrieve Bert data from SPI NOR
>> + */
>> +VOID
>> +PullBertSpinorData (
>> + APEI_CRASH_DUMP_DATA *BertErrorData
>> + )
>> +{
>> + UINTN Length;
>> +
>> + Length = sizeof (*BertErrorData);
>> +
>> + FlashReadCommand (
>> + (UINT8 *)BERT_FLASH_OFFSET,
>> + (UINT8 *)BertErrorData,
>> + &Length
>> + );
>> +}
>> +
>> +/*
>> + * wrap raw bert error data
>> + *
>> + * @param IN BertErrorData Bert Error record to be wrapped
>> + * @param OUT WrappedError Generic error data for OS to consume.
>> + */
>> +VOID
>> +WrapBertErrorData (
>> + APEI_CRASH_DUMP_BERT_ERROR *WrappedError
>> + )
>> +{
>> + UINT32 CrashSize;
>> +
>> + CrashSize = PLAT_CRASH_ITERATOR_SIZE *
>> + GetNumberOfSupportedSockets () *
>> + GetMaximumNumberOfCores ();
>> + CrashSize += 2 * (SMPRO_CRASH_SIZE + PMPRO_CRASH_SIZE);
>> + CrashSize += sizeof (WrappedError->Bed.Vendor) + sizeof (WrappedError->Bed.BertRev);
>> +
>> + WrappedError->Ges.BlockStatus.ErrorDataEntryCount = 1;
>> + WrappedError->Ges.BlockStatus.UncorrectableErrorValid = 1;
>> + WrappedError->Ged.ErrorSeverity = BERT_DEFAULT_ERROR_SEVERITY;
>> + WrappedError->Ged.Revision = GENERIC_ERROR_DATA_REVISION;
>> +
>> + if (WrappedError->Bed.Vendor.Type == RAS_2P_TYPE ||
>> + (WrappedError->Bed.Vendor.Type == BERT_ERROR_TYPE &&
>> + (WrappedError->Bed.Vendor.SubType == 0 ||
>> + WrappedError->Bed.Vendor.SubType == BERT_UEFI_FAILURE)))
>> + {
>> + WrappedError->Ged.ErrorDataLength = sizeof (WrappedError->Bed.Vendor) +
>> + sizeof (WrappedError->Bed.BertRev);
>> + WrappedError->Ges.DataLength = sizeof (WrappedError->Bed.Vendor) +
>> + sizeof (WrappedError->Bed.BertRev) +
>> + sizeof (WrappedError->Ged);
>> + AdjustBERTRegionLen (
>> + sizeof (WrappedError->Bed.Vendor) +
>> + sizeof (WrappedError->Bed.BertRev) +
>> + sizeof (WrappedError->Ged) +
>> + sizeof (WrappedError->Ges)
>> + );
>> + } else {
>> + WrappedError->Ged.ErrorDataLength = CrashSize;
>> + WrappedError->Ges.DataLength = CrashSize + sizeof (WrappedError->Ged);
>> + AdjustBERTRegionLen (
>> + CrashSize +
>> + sizeof (WrappedError->Ged) +
>> + sizeof (WrappedError->Ges)
>> + );
>> + }
>> + CopyMem (
>> + WrappedError->Ged.SectionType,
>> + AMPERE_GUID,
>> + sizeof (AMPERE_GUID)
>> + );
>> +}
>> +
>> +
>> +/*
>> + * create default bert error
>> + * Msg: Unknown reboot reason
>> + */
>> +VOID
>> +CreateDefaultBertData (
>> + APEI_BERT_ERROR_DATA *Data
>> + )
>> +{
>> + Data->Type = BERT_ERROR_TYPE;
>> + AsciiStrCpyS (
>> + Data->Msg,
>> + BERT_MSG_SIZE,
>> + DEFAULT_BERT_REBOOT_MSG
>> + );
>> +}
>> +
>> +/*
>> + * Ensures BertErrorData In SPINOR matches
>> + * the record produced by CreateDefaultBertData.
>> + * @param Bed Crash dump Data
>> + */
>> +VOID
>> +WriteSpinorDefaultBertTable (
>> + APEI_CRASH_DUMP_DATA *Bed
>> + )
>> +{
>> + UINT8 BertRev;
>> + UINTN Length;
>> + UINT64 Offset;
>> + UINT32 MsgDiff;
>> + APEI_BERT_ERROR_DATA DefaultData = {0};
>> +
>> + CreateDefaultBertData (&DefaultData);
>> + if ((Bed->Vendor.Type != DefaultData.Type)) {
>> + Offset = BERT_FLASH_OFFSET +
>> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
>> + OFFSET_OF (APEI_BERT_ERROR_DATA, Type);
>> + Length = sizeof (DefaultData.Type);
>> + FlashEraseCommand ((UINT8 *)Offset, Length);
>> + FlashProgramCommand (
>> + (UINT8 *)Offset,
>> + (UINT8 *)&(DefaultData.Type),
>> + &Length
>> + );
>> + }
>> +
>> + if ((Bed->Vendor.SubType != DefaultData.SubType)) {
>> + Offset = BERT_FLASH_OFFSET +
>> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
>> + OFFSET_OF (APEI_BERT_ERROR_DATA, SubType);
>> + Length = sizeof (DefaultData.SubType);
>> + FlashEraseCommand ((UINT8 *)Offset, Length);
>> + FlashProgramCommand (
>> + (UINT8 *)Offset,
>> + (UINT8 *)&(DefaultData.SubType),
>> + &Length
>> + );
>> + }
>> +
>> + if ((Bed->Vendor.Instance != DefaultData.Instance)) {
>> + Offset = BERT_FLASH_OFFSET +
>> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
>> + OFFSET_OF (APEI_BERT_ERROR_DATA, Instance);
>> + Length = sizeof (DefaultData.Instance);
>> + FlashEraseCommand ((UINT8 *)Offset, Length);
>> + FlashProgramCommand (
>> + (UINT8 *)Offset,
>> + (UINT8 *)&(DefaultData.Instance),
>> + &Length
>> + );
>> + }
>> +
>> + MsgDiff = AsciiStrnCmp (Bed->Vendor.Msg, DefaultData.Msg, BERT_MSG_SIZE);
>> + if (MsgDiff != 0) {
>> + Offset = BERT_FLASH_OFFSET +
>> + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) +
>> + OFFSET_OF (APEI_BERT_ERROR_DATA, Msg);
>> + Length = sizeof (DefaultData.Msg);
>> + FlashEraseCommand ((UINT8 *)Offset, Length);
>> + FlashProgramCommand (
>> + (UINT8 *)Offset,
>> + (UINT8 *)&(DefaultData.Msg),
>> + &Length
>> + );
>> + }
>> +
>> + if (Bed->BertRev != CURRENT_BERT_VERSION) {
>> + Offset = BERT_FLASH_OFFSET + OFFSET_OF (APEI_CRASH_DUMP_DATA, BertRev);
>> + Length = sizeof (Bed->BertRev);
>> + BertRev = CURRENT_BERT_VERSION;
>> + FlashEraseCommand ((UINT8 *)Offset, Length);
>> + FlashProgramCommand ((UINT8 *)Offset, (UINT8 *)&BertRev, &Length);
>> + }
>> +
>> +}
>> +
>> +/*
>> + * Checks Status of NV_SI_RAS_BERT_ENABLED
>> + * Returns TRUE if enabled and FALSE if disabled
>> + */
>> +BOOLEAN
>> +IsBertEnabled (
>> + VOID
>> + )
>> +{
>> + EFI_STATUS Status;
>> + UINT32 Value;
>> +
>> + Status = NVParamGet (
>> + NV_SI_RAS_BERT_ENABLED,
>> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
>> + &Value
>> + );
>> + if (EFI_ERROR (Status)) {
>> + // BERT is enabled by default
>> + return TRUE;
>> + }
>> +
>> + return (Value != 0) ? TRUE : FALSE;
>> +}
>> +
>> +/*
>> + * Write bert table to DDR
>> + */
>> +VOID
>> +WriteDDRBertTable (
>> + APEI_CRASH_DUMP_BERT_ERROR *Data
>> + )
>> +{
>> + VOID *Blk = (VOID *)BERT_DDR_OFFSET;
>> +
>> + /*
>> + * writing sizeof data to ddr produces alignment error
>> + * this is a temporary workaround
>> + */
>> + CopyMem (Blk, Data, BERT_DDR_LENGTH);
>> +}
>> +
>> +/*
>> + * Update Bert Table
>> + */
>> +EFI_STATUS
>> +AcpiPopulateBert (
>> + VOID
>> + )
>> +{
>> + APEI_CRASH_DUMP_BERT_ERROR *DDRError;
>> +
>> + DDRError =
>> + (APEI_CRASH_DUMP_BERT_ERROR *)
>> + AllocateZeroPool (sizeof (APEI_CRASH_DUMP_BERT_ERROR));
>> +
>> + if (DDRError == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> +
>> + if (IsBertEnabled ()) {
>> + PullBertSpinorData (&(DDRError->Bed));
>> + if ((DDRError->Bed.BertRev == CURRENT_BERT_VERSION)) {
>> + WrapBertErrorData (DDRError);
>> + WriteDDRBertTable (DDRError);
>> + }
>> + WriteSpinorDefaultBertTable (&(DDRError->Bed));
>> + }
>> +
>> + FreePool (DDRError);
>> + return EFI_SUCCESS;
>> +}
>> +
>> +/*
>> + * Checks Status of NV_SI_RAS_SDEI_ENABLED
>> + * Returns TRUE if enabled and FALSE if disabled or error occurred
>> + */
>> +BOOLEAN
>> +IsSdeiEnabled (
>> + VOID
>> + )
>> +{
>> + EFI_STATUS Status;
>> + UINT32 Value;
>> +
>> + Status = NVParamGet (
>> + NV_SI_RAS_SDEI_ENABLED,
>> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
>> + &Value
>> + );
>> + if (EFI_ERROR (Status)) {
>> + // SDEI is disabled by default
>> + return FALSE;
>> + }
>> +
>> + return (Value != 0) ? TRUE : FALSE;
>> +}
>> +
>> +STATIC
>> +VOID
>> +AcpiApeiHestUpdateTable1P (
>> + VOID
>> + )
>> +{
>> + EFI_STATUS Status;
>> + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol = NULL;
>> + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_HEADER *HestTablePointer;
>> + EFI_ACPI_TABLE_VERSION TableVersion;
>> + UINTN TableKey;
>> + UINTN Idx;
>> +
>> + Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&AcpiTableSdtProtocol);
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protocol\n"));
>> + return;
>> + }
>> +
>> + /*
>> + * Search for ACPI Table Signature
>> + */
>> + for (Idx = 0; ; Idx++) {
>> + Status = AcpiTableSdtProtocol->GetAcpiTable (
>> + Idx,
>> + (EFI_ACPI_SDT_HEADER **)&HestTablePointer,
>> + &TableVersion,
>> + &TableKey
>> + );
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "APEI: Unable to get HEST table"));
>> + return;
>> + } else if (HestTablePointer->Header.Signature ==
>> + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE)
>> + {
>> + break;
>> + }
>> + }
>> +
>> + HestTablePointer->ErrorSourceCount -= HEST_NUM_ENTRIES_PER_SOC;
>> + HestTablePointer->Header.Length -=
>> + (HEST_NUM_ENTRIES_PER_SOC *
>> + sizeof (EFI_ACPI_6_3_GENERIC_HARDWARE_ERROR_SOURCE_VERSION_2_STRUCTURE));
>> +
>> + AcpiTableChecksum ((UINT8 *)HestTablePointer, HestTablePointer->Header.Length);
>> +}
>> +
>> +/*
>> + * Update APEI
>> + *
>> + */
>> +EFI_STATUS
>> +EFIAPI
>> +AcpiApeiUpdate (
>> + VOID
>> + )
>> +{
>> + if (!IsSlaveSocketActive ()) {
>> + AcpiApeiHestUpdateTable1P ();
>> + }
>> +
>> + if (!IsSdeiEnabled ()) {
>> + AcpiApeiUninstallTable (EFI_ACPI_6_3_SOFTWARE_DELEGATED_EXCEPTIONS_INTERFACE_TABLE_SIGNATURE);
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
>> new file mode 100644
>> index 000000000000..7881044104e4
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c
>> @@ -0,0 +1,445 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Protocol/PciRootBridgeIo.h>
>> +#include <Library/NVParamLib.h>
>> +#include <NVParamDef.h>
>> +
>> +#include "AcpiNfit.h"
>> +#include "AcpiPlatform.h"
>> +
>> +#define PCIE_DEVICE_CONTROL_OFFSET 0x078
>> +#define PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN 0x08
>> +#define PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN 0x04
>> +#define PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN 0x02
>> +#define PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN 0x01
>> +
>> +#define PCIE_ROOT_ERR_CMD_OFFSET 0x12C
>> +#define PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN 0x4
>> +#define PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN 0x2
>> +#define PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN 0x1
>> +
>> +#define PCIE_MAX_DEVICE_PER_ROOT_PORT 8
>> +
>> +STATIC VOID
>> +AcpiPatchCmn600 (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINTN Index;
>> +
>> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.CMN%1X._STA", Index);
>> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
>> + } else {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> +}
>> +
>> +STATIC VOID
>> +AcpiPatchDmc620 (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINTN Index, Index1;
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + UINT32 McuMask;
>> + VOID *Hob;
>> +
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL) {
>> + return;
>> + }
>> +
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
>> + McuMask = PlatformHob->DramInfo.McuMask[Index];
>> + for (Index1 = 0; Index1 < sizeof (McuMask) * 8; Index1++) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.MC%1X%1X._STA", Index, Index1);
>> + if (McuMask & (0x1 << Index1)) {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
>> + } else {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> + }
>> +}
>> +
>> +STATIC VOID
>> +AcpiPatchNvdimm (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINTN NvdRegionNumSK0, NvdRegionNumSK1, NvdRegionNum, Count;
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + VOID *Hob;
>> +
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL) {
>> + return;
>> + }
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + NvdRegionNumSK0 = 0;
>> + NvdRegionNumSK1 = 0;
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0) {
>> + if (PlatformHob->DramInfo.Socket[Count] == 0) {
>> + NvdRegionNumSK0++;
>> + } else {
>> + NvdRegionNumSK1++;
>> + }
>> + }
>> + }
>> + NvdRegionNum = NvdRegionNumSK0 + NvdRegionNumSK1;
>> +
>> + /* Disable NVDIMM Root Device */
>> + if (NvdRegionNum == 0) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + /* Update NVDIMM Device _STA for SK0 */
>> + if (NvdRegionNumSK0 == 0) {
>> + /* Disable NVD1/2 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + } else if (NvdRegionNumSK0 == 1) {
>> + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK0] == NVDIMM_NON_HASHED) {
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
>> + PlatformHob->DramInfo.Socket[Count] == 0)
>> + {
>> + if (PlatformHob->DramInfo.Base[Count] ==
>> + PLATFORM_NVDIMM_SK0_NHASHED_REGION0)
>> + {
>> + /* Disable NVD2 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + } else if (PlatformHob->DramInfo.Base[Count] ==
>> + PLATFORM_NVDIMM_SK0_NHASHED_REGION1)
>> + {
>> + /* Disable NVD1 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> + }
>> + }
>> + }
>> + /* Update NVDIMM Device _STA for SK1 */
>> + if (NvdRegionNumSK1 == 0) {
>> + /* Disable NVD3/4 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + } else if (NvdRegionNumSK1 == 1) {
>> + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK1] == NVDIMM_NON_HASHED) {
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 &&
>> + PlatformHob->DramInfo.Socket[Count] == 1)
>> + {
>> + if (PlatformHob->DramInfo.Base[Count] ==
>> + PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
>> + {
>> + /* Disable NVD4 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + } else if (PlatformHob->DramInfo.Base[Count] ==
>> + PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
>> + {
>> + /* Disable NVD3 */
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA");
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> + }
>> + }
>> + }
>> +}
>> +
>> +STATIC VOID
>> +AcpiPatchHwmon (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINT8 Index;
>> +
>> + // PCC Hardware Monitor Devices
>> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index);
>> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
>> + } else {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> +
>> + // Ampere Altra SoC Hardware Monitor Devices
>> + for (Index = 0; Index < GetNumberOfSupportedSockets (); Index++) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index + 2);
>> + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
>> + } else {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> +}
>> +
>> +STATIC VOID
>> +AcpiPatchDsu (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINTN Index;
>> +
>> + for (Index = 0; Index < PLATFORM_CPU_MAX_NUM_CORES; Index += PLATFORM_CPU_NUM_CORES_PER_CPM) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.DU%2X._STA", Index / PLATFORM_CPU_NUM_CORES_PER_CPM);
>> + if (IsCpuEnabled (Index)) {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0xf);
>> + } else {
>> + AcpiDSDTSetNodeStatusValue (NodePath, 0x0);
>> + }
>> + }
>> +}
>> +
>> +VOID
>> +AcpiPatchPcieNuma (
>> + VOID
>> + )
>> +{
>> + CHAR8 NodePath[MAX_ACPI_NODE_PATH];
>> + UINTN Index;
>> + UINTN NumaIdx;
>> + UINTN NumPciePort;
>> + UINTN NumaAssignment[3][16] = {
>> + { 0, 0, 0, 0, 0, 0, 0, 0, // Monolithic Node 0 (S0)
>> + 1, 1, 1, 1, 1, 1, 1, 1 }, // Monolithic Node 1 (S1)
>> + { 0, 1, 0, 1, 0, 0, 1, 1, // Hemisphere Node 0, 1 (S0)
>> + 2, 3, 2, 3, 2, 2, 3, 3 }, // Hemisphere Node 2, 3 (S1)
>> + { 0, 2, 1, 3, 1, 1, 3, 3, // Quadrant Node 0, 1, 2, 3 (S0)
>> + 4, 6, 5, 7, 5, 5, 7, 7 }, // Quadrant Node 4, 5, 6, 7 (S1)
>> + };
>> +
>> + switch (CpuGetSubNumaMode ()) {
>> + case SUBNUMA_MODE_MONOLITHIC:
>> + NumaIdx = 0;
>> + break;
>> +
>> + case SUBNUMA_MODE_HEMISPHERE:
>> + NumaIdx = 1;
>> + break;
>> +
>> + case SUBNUMA_MODE_QUADRANT:
>> + NumaIdx = 2;
>> + break;
>> +
>> + default:
>> + NumaIdx = 0;
>> + break;
>> + }
>> +
>> + if (IsSlaveSocketActive ()) {
>> + NumPciePort = 16; // 16 ports total (8 per socket)
>> + } else {
>> + NumPciePort = 8; // 8 ports total
>> + }
>> +
>> + for (Index = 0; Index < NumPciePort; Index++) {
>> + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.PCI%X._PXM", Index);
>> + AcpiDSDTSetNodeStatusValue (NodePath, NumaAssignment[NumaIdx][Index]);
>> + }
>> +}
>> +
>> +EFI_STATUS
>> +AcpiPatchPcieAerFwFirst (
>> + VOID
>> + )
>> +{
>> + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS Address;
>> + EFI_ACPI_SDT_PROTOCOL *AcpiTableProtocol;
>> + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
>> + EFI_HANDLE *HandleBuffer;
>> + UINTN HandleCount;
>> + EFI_ACPI_HANDLE TableHandle;
>> + EFI_ACPI_HANDLE ChildHandle;
>> + EFI_ACPI_DATA_TYPE DataType;
>> + UINTN DataSize;
>> + CHAR8 ObjectPath[8];
>> + EFI_STATUS Status;
>> + UINT32 AerFwFirstConfigValue;
>> + UINT32 RegData;
>> + UINT16 Device;
>> + UINT32 Index;
>> + UINT8 *Data;
>> +
>> + //
>> + // Check if PCIe AER Firmware First should be enabled
>> + //
>> + Status = NVParamGet (
>> + NV_SI_RAS_PCIE_AER_FW_FIRST,
>> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
>> + &AerFwFirstConfigValue
>> + );
>> + if (EFI_ERROR (Status)) {
>> + Status = NVParamGet (
>> + NV_SI_RO_BOARD_PCIE_AER_FW_FIRST,
>> + NV_PERM_ATF | NV_PERM_BIOS | NV_PERM_MANU | NV_PERM_BMC,
>> + &AerFwFirstConfigValue
>> + );
>> + if (EFI_ERROR (Status)) {
>> + AerFwFirstConfigValue = 0;
>> + }
>> + }
>> +
>> + if (AerFwFirstConfigValue == 0) {
>> + //
>> + // By default, the PCIe AER FW-First (ACPI Object "AERF") is set to 0
>> + // in the DSDT table.
>> + //
>> + return EFI_SUCCESS;
>> + }
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiSdtProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "Unable to locate ACPI table protocol\n"));
>> + return Status;
>> + }
>> +
>> + Status = AcpiOpenDSDT (AcpiTableProtocol, &TableHandle);
>> + if (EFI_ERROR (Status)) {
>> + AcpiTableProtocol->Close (TableHandle);
>> + return Status;
>> + }
>> +
>> + //
>> + // Update Name Object "AERF" (PCIe AER Firmware-First) if it is enabled.
>> + //
>> + AsciiSPrint (ObjectPath, sizeof (ObjectPath), "\\AERF");
>> + Status = AcpiTableProtocol->FindPath (TableHandle, ObjectPath, &ChildHandle);
>> + ASSERT_EFI_ERROR (Status);
>> + if (!EFI_ERROR (Status)) {
>> + Status = AcpiTableProtocol->GetOption (
>> + ChildHandle,
>> + 0,
>> + &DataType,
>> + (VOID *)&Data,
>> + &DataSize
>> + );
>> + ASSERT_EFI_ERROR (Status);
>> + if (!EFI_ERROR (Status)
>> + && Data[0] == AML_NAME_OP
>> + && (Data[5] == AML_ZERO_OP || Data[5] == AML_ONE_OP))
>> + {
>> + Data[5] = 1; // Enable PCIe AER Firmware-First
>> + }
>> + }
>> +
>> + AcpiTableProtocol->Close (TableHandle);
>> + AcpiDSDTUpdateChecksum (AcpiTableProtocol);
>> +
>> + //
>> + // For PCIe AER Firmware First, PCIe capability registers need
>> + // to be updated to allow Firmware to detect AER errors.
>> + //
>> +
>> + HandleCount = 0;
>> + HandleBuffer = NULL;
>> + PciRootBridgeIo = NULL;
>> +
>> + Status = gBS->LocateHandleBuffer (
>> + ByProtocol,
>> + &gEfiPciRootBridgeIoProtocolGuid,
>> + NULL,
>> + &HandleCount,
>> + &HandleBuffer
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + //
>> + // Loop through each root complex
>> + //
>> + for (Index = 0; Index < HandleCount; Index++) {
>> + Status = gBS->HandleProtocol (
>> + HandleBuffer[Index],
>> + &gEfiPciRootBridgeIoProtocolGuid,
>> + (VOID **)&PciRootBridgeIo
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + //
>> + // Loop through each root port
>> + //
>> + for (Device = 1; Device <= PCIE_MAX_DEVICE_PER_ROOT_PORT; Device++) {
>> + Address.Bus = 0;
>> + Address.Device = Device;
>> + Address.Function = 0;
>> + Address.Register = 0;
>> +
>> + Address.ExtendedRegister = PCIE_DEVICE_CONTROL_OFFSET;
>> + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
>> +
>> + if (RegData == 0xFFFFFFFF) {
>> + continue;
>> + }
>> +
>> + RegData |= PCIE_DEVICE_CONTROL_UNSUPPORT_REQ_REP_EN
>> + | PCIE_DEVICE_CONTROL_FATAL_ERR_REPORT_EN
>> + | PCIE_DEVICE_CONTROL_NON_FATAL_ERR_REPORT_EN
>> + | PCIE_DEVICE_CONTROL_CORR_ERR_REPORT_EN;
>> +
>> + PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
>> +
>> + RegData = 0;
>> + Address.ExtendedRegister = PCIE_ROOT_ERR_CMD_OFFSET;
>> + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
>> +
>> + RegData |= PCIE_ROOT_ERR_CMD_FATAL_ERR_REPORTING_EN
>> + | PCIE_ROOT_ERR_CMD_NON_FATAL_ERR_REPORTING_EN
>> + | PCIE_ROOT_ERR_CMD_CORR_ERR_REPORTING_EN;
>> +
>> + PciRootBridgeIo->Pci.Write (PciRootBridgeIo, EfiPciWidthUint32, *((UINT64 *)&Address), 1, &RegData);
>> + }
>> + }
>> +
>> + return Status;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiPatchDsdtTable (
>> + VOID
>> + )
>> +{
>> + AcpiPatchCmn600 ();
>> + AcpiPatchDmc620 ();
>> + AcpiPatchDsu ();
>> + AcpiPatchHwmon ();
>> + AcpiPatchNvdimm ();
>> + AcpiPatchPcieNuma ();
>> + AcpiPatchPcieAerFwFirst ();
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
>> new file mode 100644
>> index 000000000000..1d1643abd299
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c
>> @@ -0,0 +1,351 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include "AcpiPlatform.h"
>> +
>> +EFI_ACPI_6_3_GIC_ITS_STRUCTURE GicItsTemplate = {
>> + EFI_ACPI_6_3_GIC_ITS,
>> + sizeof (EFI_ACPI_6_3_GIC_ITS_STRUCTURE),
>> + EFI_ACPI_RESERVED_WORD,
>> + 0, /* GicItsId */
>> + 0, /* PhysicalBaseAddress */
>> + 0, /* Reserved2 */
>> +};
>> +
>> +EFI_ACPI_6_3_GICR_STRUCTURE GicRTemplate = {
>> + EFI_ACPI_6_3_GICR,
>> + sizeof (EFI_ACPI_6_3_GICR_STRUCTURE),
>> + EFI_ACPI_RESERVED_WORD,
>> + GICR_MASTER_BASE_REG, /* DiscoveryRangeBaseAddress */
>> + 0x1000000, /* DiscoveryRangeLength */
>> +};
>> +
>> +EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE GicDTemplate = {
>> + EFI_ACPI_6_3_GICD,
>> + sizeof (EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE),
>> + EFI_ACPI_RESERVED_WORD,
>> + 0, /* GicDistHwId */
>> + GICD_BASE_REG, /* GicDistBase */
>> + 0, /* GicDistVector */
>> + 0x3, /* GicVersion */
>> + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}
>> +};
>> +
>> +EFI_ACPI_6_3_GIC_STRUCTURE GiccTemplate = {
>> + EFI_ACPI_6_3_GIC,
>> + sizeof (EFI_ACPI_6_3_GIC_STRUCTURE),
>> + EFI_ACPI_RESERVED_WORD,
>> + 0, /* GicId */
>> + 0, /* AcpiCpuUid */
>> + 0, /* Flags */
>> + 0,
>> + 23, /* PmuIrq */
>> + 0,
>> + 0,
>> + 0,
>> + 0,
>> + 25, /* GsivId */
>> + 0, /* GicRBase */
>> + 0, /* Mpidr */
>> + 0, /* ProcessorPowerEfficiencyClass */
>> + 0, /* Reserved2 */
>> + 21, /* SPE irq */
>> +};
>> +
>> +EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER MADTTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE,
>> + 0, /* need fill in */
>> + EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION
>> + ),
>> +};
>> +
>> +UINT32 Ac01CoreOrderMonolithic[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
>> + 36, 52, 40, 56, 32, 48, 44, 60,
>> + 20, 68, 24, 72, 16, 64, 28, 76,
>> + 4, 8, 0, 12, 38, 54, 42, 58,
>> + 34, 50, 46, 62, 22, 70, 26, 74,
>> + 18, 66, 30, 78, 6, 10, 2, 14,
>> + 37, 53, 41, 57, 33, 49, 45, 61,
>> + 21, 69, 25, 73, 17, 65, 29, 77,
>> + 5, 9, 1, 13, 39, 55, 43, 59,
>> + 35, 51, 47, 63, 23, 71, 27, 75,
>> + 19, 67, 31, 79, 7, 11, 3, 15,
>> +};
>> +
>> +UINT32 Ac01CoreOrderHemisphere[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
>> + 32, 48, 16, 64, 36, 52, 0, 20,
>> + 68, 4, 34, 50, 18, 66, 38, 54,
>> + 2, 22, 70, 6, 33, 49, 17, 65,
>> + 37, 53, 1, 21, 69, 5, 35, 51,
>> + 19, 67, 39, 55, 3, 23, 71, 7,
>> + 44, 60, 28, 76, 40, 56, 12, 24,
>> + 72, 8, 46, 62, 30, 78, 42, 58,
>> + 14, 26, 74, 10, 45, 61, 29, 77,
>> + 41, 57, 13, 25, 73, 9, 47, 63,
>> + 31, 79, 43, 59, 15, 27, 75, 11,
>> +};
>> +
>> +UINT32 Ac01CoreOrderQuadrant[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM] = {
>> + 16, 32, 0, 20, 4, 18, 34, 2,
>> + 22, 6, 17, 33, 1, 21, 5, 19,
>> + 35, 3, 23, 7, 48, 64, 52, 68,
>> + 36, 50, 66, 54, 70, 38, 49, 65,
>> + 53, 69, 37, 51, 67, 55, 71, 39,
>> + 28, 44, 12, 24, 8, 30, 46, 14,
>> + 26, 10, 29, 45, 13, 25, 9, 31,
>> + 47, 15, 27, 11, 60, 76, 56, 72,
>> + 40, 62, 78, 58, 74, 42, 61, 77,
>> + 57, 73, 41, 63, 79, 59, 75, 43,
>> +};
>> +
>> +EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *MadtTablePointer;
>> +
>> +UINT32 *
>> +CpuGetCoreOrder (
>> + VOID
>> + )
>> +{
>> + UINT8 SubNumaMode;
>> +
>> + SubNumaMode = CpuGetSubNumaMode ();
>> + switch (SubNumaMode) {
>> + case SUBNUMA_MODE_MONOLITHIC:
>> + return (UINT32 *)&Ac01CoreOrderMonolithic;
>> +
>> + case SUBNUMA_MODE_HEMISPHERE:
>> + return (UINT32 *)&Ac01CoreOrderHemisphere;
>> +
>> + case SUBNUMA_MODE_QUADRANT:
>> + return (UINT32 *)&Ac01CoreOrderQuadrant;
>> +
>> + default:
>> + // Should never reach here
>> + ASSERT (FALSE);
>> + return NULL;
>> + }
>> +
>> + return NULL;
>> +}
>> +
>> +UINT32
>> +AcpiInstallMadtProcessorNode (
>> + VOID *EntryPointer,
>> + UINT32 CpuId
>> + )
>> +{
>> + EFI_ACPI_6_3_GIC_STRUCTURE *MadtProcessorEntryPointer = EntryPointer;
>> + UINT32 SocketId;
>> + UINT32 ClusterId;
>> + UINTN Size;
>> +
>> + Size = sizeof (GiccTemplate);
>> + CopyMem (MadtProcessorEntryPointer, &GiccTemplate, Size);
>> +
>> + SocketId = SOCKET_ID (CpuId);
>> + ClusterId = CLUSTER_ID (CpuId);
>> +
>> + //
>> + // GICv2 compatibility mode is not supported.
>> + // Hence, set GIC's CPU Interface Number to 0.
>> + //
>> + MadtProcessorEntryPointer->CPUInterfaceNumber = 0;
>> + MadtProcessorEntryPointer->AcpiProcessorUid =
>> + (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
>> + (ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM);
>> + MadtProcessorEntryPointer->Flags = 1;
>> + MadtProcessorEntryPointer->MPIDR =
>> + (((ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM)) << 8);
>> + MadtProcessorEntryPointer->MPIDR += (((UINT64)SocketId) << 32);
>> +
>> + return Size;
>> +}
>> +
>> +UINT32
>> +AcpiInstallMadtGicD (
>> + VOID *EntryPointer
>> + )
>> +{
>> + EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE *GicDEntryPointer = EntryPointer;
>> + UINTN Size;
>> +
>> + Size = sizeof (GicDTemplate);
>> + CopyMem (GicDEntryPointer, &GicDTemplate, Size);
>> +
>> + return Size;
>> +}
>> +
>> +UINT32
>> +AcpiInstallMadtGicR (
>> + VOID *EntryPointer,
>> + UINT32 SocketId
>> + )
>> +{
>> + EFI_ACPI_6_3_GICR_STRUCTURE *GicREntryPointer = EntryPointer;
>> + UINTN Size;
>> +
>> + /*
>> + * If the Slave socket is not present, discard the Slave socket
>> + * GIC redistributor region
>> + */
>> + if (SocketId == 1 && !IsSlaveSocketActive ()) {
>> + return 0;
>> + }
>> +
>> + Size = sizeof (GicRTemplate);
>> + CopyMem (GicREntryPointer, &GicRTemplate, Size);
>> +
>> + if (SocketId == 1) {
>> + GicREntryPointer->DiscoveryRangeBaseAddress = GICR_SLAVE_BASE_REG;
>> + }
>> +
>> + return Size;
>> +}
>> +
>> +UINT32
>> +AcpiInstallMadtGicIts (
>> + VOID *EntryPointer,
>> + UINT32 Index
>> + )
>> +{
>> + EFI_ACPI_6_3_GIC_ITS_STRUCTURE *GicItsEntryPointer = EntryPointer;
>> + UINTN Size, Offset;
>> + UINT64 GicBase = GICD_BASE_REG;
>> + UINT32 ItsId = Index;
>> +
>> + if (Index > SOCKET0_LAST_RC) { /* Socket 1, Index: 8-15 */
>> + GicBase = GICD_SLAVE_BASE_REG;
>> + Index -= (SOCKET0_LAST_RC + 1); /* Socket 1, Index:8 -> RCA0 */
>> + }
>> + Size = sizeof (GicItsTemplate);
>> + CopyMem (GicItsEntryPointer, &GicItsTemplate, Size);
>> + Offset = 0x40000 + Index * 0x20000;
>> + GicItsEntryPointer->GicItsId = ItsId;
>> + GicItsEntryPointer->PhysicalBaseAddress = Offset + GicBase;
>> +
>> + return Size;
>> +}
>> +
>> +/*
>> + * Install MADT table.
>> + */
>> +EFI_STATUS
>> +AcpiInstallMadtTable (
>> + VOID
>> + )
>> +{
>> + EFI_ACPI_6_3_GIC_STRUCTURE *GiccEntryPointer = NULL;
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + UINTN MadtTableKey = 0;
>> + INTN Index;
>> + EFI_STATUS Status;
>> + UINTN Size;
>> + UINT32 *CoreOrder;
>> + UINT32 SktMaxCoreNum;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + Size = sizeof (MADTTableHeaderTemplate) +
>> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (GiccTemplate)) +
>> + sizeof (GicDTemplate) +
>> + (PLATFORM_CPU_MAX_SOCKET * sizeof (GicRTemplate)) +
>> + ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsTemplate));
>> + if (IsSlaveSocketActive ()) {
>> + Size += ((SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsTemplate));
>> + } else if (!IsSlaveSocketPresent ()) {
>> + Size += 2 * sizeof (GicItsTemplate); /* RCA0/1 */
>> + }
>> +
>> + MadtTablePointer =
>> + (EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)AllocateZeroPool (Size);
>> + if (MadtTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> +
>> + GiccEntryPointer =
>> + (EFI_ACPI_6_3_GIC_STRUCTURE *)((UINT64)MadtTablePointer +
>> + sizeof (MADTTableHeaderTemplate));
>> +
>> + /* Install Gic interface for each processor */
>> + Size = 0;
>> + CoreOrder = CpuGetCoreOrder ();
>> + ASSERT (CoreOrder != NULL);
>> + SktMaxCoreNum = PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM;
>> + for (Index = 0; Index < SktMaxCoreNum; Index++) {
>> + if (IsCpuEnabled (CoreOrder[Index])) {
>> + Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index]);
>> + }
>> + }
>> +
>> + for (Index = 0; Index < SktMaxCoreNum; Index++) {
>> + if (IsCpuEnabled (CoreOrder[Index] + SktMaxCoreNum)) {
>> + Size += AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPointer + Size), CoreOrder[Index] + SktMaxCoreNum);
>> + }
>> + }
>> +
>> + /* Install Gic Distributor */
>> + Size += AcpiInstallMadtGicD ((VOID *)((UINT64)GiccEntryPointer + Size));
>> +
>> + /* Install Gic Redistributor */
>> + for (Index = 0; Index < PLATFORM_CPU_MAX_SOCKET; Index++) {
>> + Size += AcpiInstallMadtGicR ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
>> + }
>> +
>> + /* Install Gic ITS */
>> + if (!IsSlaveSocketPresent ()) {
>> + for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
>> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
>> + }
>> + }
>> + for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
>> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
>> + }
>> + if (IsSlaveSocketActive ()) {
>> + for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
>> + Size += AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + Size), Index);
>> + }
>> + }
>> + CopyMem (
>> + MadtTablePointer,
>> + &MADTTableHeaderTemplate,
>> + sizeof (MADTTableHeaderTemplate)
>> + );
>> +
>> + Size += sizeof (MADTTableHeaderTemplate);
>> + MadtTablePointer->Header.Length = Size;
>> + CopyMem (
>> + MadtTablePointer->Header.OemId,
>> + PcdGetPtr (PcdAcpiDefaultOemId),
>> + sizeof (MadtTablePointer->Header.OemId)
>> + );
>> +
>> + AcpiTableChecksum (
>> + (UINT8 *)MadtTablePointer,
>> + MadtTablePointer->Header.Length
>> + );
>> +
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)MadtTablePointer,
>> + MadtTablePointer->Header.Length,
>> + &MadtTableKey
>> + );
>> + FreePool ((VOID *)MadtTablePointer);
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
>> new file mode 100644
>> index 000000000000..d13ac3514e11
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c
>> @@ -0,0 +1,599 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include "AcpiNfit.h"
>> +#include "AcpiPlatform.h"
>> +
>> +EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE NfitSPATemplate = {
>> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE,
>> + sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE),
>> + 0, // The uniue index - need to be filled.
>> + 0, // The flags - need to be filled.
>> + 0, // Reserved.
>> + 0, // Proximity domain - need to be filled.
>> + EFI_ACPI_6_3_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION, // PM range type.
>> + 0, // Start address - need to be filled.
>> + 0, // Size - need to be filled.
>> + EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB |
>> + EFI_MEMORY_WP | EFI_MEMORY_UCE, // attribute - need to be filled.
>> +};
>> +
>> +EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE NvdimmControlRegionTemplate = {
>> + EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE_TYPE,
>> + sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE),
>> + 0, // The unique index - need to be filled.
>> + 0, // The vendor id - need to be filled.
>> + 0, // The device id - need to be filled.
>> + 0, // The revision - need to be filled.
>> + 0, // The subsystem nvdimm id - need to be filled.
>> + 0, // The subsystem nvdimm device id - need to be filled.
>> + 0, // The subsystem revision - need to be filled.
>> + 0, // The valid field.
>> + 0, // The manufacturing location - not valid.
>> + 0, // The manufacturing date - not valid.
>> + {0}, // Reserved.
>> + 0, // The serial number - need to be filled.
>> + 0, // The region format interface code - dummy value.
>> + 0, // The number of block control windows.
>> + 0, // The size of block control windows.
>> + 0, // The Command Register Offset in Block Control Window.
>> + 0, // The Size of Command Register in Block Control Windows.
>> + 0, // The Status Register Offset in Block Control Window.
>> + 0, // Size of Status Register in Block Control Windows.
>> + 0, // The NVDIMM Control Region Flag.
>> + {0}, // Reserved.
>> +};
>> +
>> +EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE NvdimmRegionMappingTemplate = {
>> + EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE_TYPE,
>> + sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE),
>> + {0}, // _ADR of the NVDIMM device - need to be filled.
>> + 0, // Dimm smbios handle index - need to be filled.
>> + 0, // The unique region index - need to be filled.
>> + 0, // The SPA range index - need to be filled.
>> + 0, // The control region index - need to be filled.
>> + 0, // The region size - need to be filled.
>> + 0, // The region offset - need to be filled.
>> + 0, // The region base - need to be filled.
>> + 0, // The interleave structure index - need to be filled.
>> + 0, // The interleave ways - need to be filled.
>> + 0, // NVDIMM flags - need to be filled.
>> + 0, // Reserved.
>> +};
>> +
>> +EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE NFITTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE,
>> + 0, /* need fill in */
>> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION
>> + ),
>> + 0x00000000, // Reserved
>> +};
>> +
>> +NVDIMM_DATA NvdData[PLATFORM_CPU_MAX_SOCKET] = { 0 };
>> +
>> +EFI_STATUS
>> +AcpiNvdInfoInit (
>> + IN OUT NVDIMM_INFO *NvdInfoPtr,
>> + IN UINTN NvdId
>> + )
>> +{
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + VOID *Hob;
>> +
>> + /* Get the Platform HOB */
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL || NvdInfoPtr == NULL) {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> +
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + NvdInfoPtr->Enabled = TRUE;
>> + NvdInfoPtr->PhysId = NvdId;
>> + NvdInfoPtr->NvdSize = PlatformHob->DimmList.Dimm[NvdId].Info.DimmSize * ONE_GB;
>> + NvdInfoPtr->VendorId =
>> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[320]);
>> + NvdInfoPtr->DeviceId =
>> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[192]);
>> + NvdInfoPtr->RevisionId =
>> + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[349];
>> + NvdInfoPtr->SubVendorId =
>> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[194]);
>> + NvdInfoPtr->SubDeviceId =
>> + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[196]);
>> + NvdInfoPtr->SubRevisionId =
>> + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[198];
>> + NvdInfoPtr->SerialNumber =
>> + *((UINT32 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[325]);
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiNvdDataInit (
>> + IN UINTN Socket
>> + )
>> +{
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + NVDIMM_INFO *NvdInfo;
>> + UINTN Count;
>> + VOID *Hob;
>> + UINTN NvdRegionNum, RegionId;
>> +
>> + /* Get the Platform HOB */
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL) {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + NvdRegionNum = 0;
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + if (PlatformHob->DramInfo.NvdRegion[Count] != 0
>> + && (PlatformHob->DramInfo.Socket[Count] == Socket))
>> + {
>> + NvdData[Socket].NvdRegionId[NvdRegionNum] = Count;
>> + NvdRegionNum++;
>> + }
>> + }
>> + if (NvdRegionNum == 0) {
>> + return EFI_SUCCESS;
>> + }
>> +
>> + NvdData[Socket].NvdRegionNum = NvdRegionNum;
>> + NvdData[Socket].NvdMode = PlatformHob->DramInfo.NvdimmMode[Socket];
>> + if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
>> + NvdInfo = &NvdData[Socket].NvdInfo[NVDIMM_SK0];
>> + NvdInfo->DeviceHandle =
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
>> + PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
>> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
>> + NvdInfo->RegionOffset = 0;
>> + AcpiNvdInfoInit (
>> + NvdInfo,
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
>> + PLATFORM_NVDIMM_NVD3_DIMM_ID
>> + );
>> +
>> + NvdInfo = &NvdData[Socket].NvdInfo[1];
>> + NvdInfo->DeviceHandle =
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
>> + PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
>> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_HASHED_INTERLEAVE_WAYS;
>> + NvdInfo->RegionOffset = PLATFORM_NVDIMM_HASHED_REGION_OFFSET;
>> + AcpiNvdInfoInit (
>> + NvdInfo,
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
>> + PLATFORM_NVDIMM_NVD4_DIMM_ID
>> + );
>> +
>> + /* Update NvdNum */
>> + NvdData[Socket].NvdNum = 0;
>> + for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
>> + if (NvdData[Socket].NvdInfo[Count].Enabled) {
>> + NvdData[Socket].NvdNum++;
>> + }
>> + }
>> + return EFI_SUCCESS;
>> + }
>> + /* NVDIMM_NON_HASHED */
>> + NvdData[Socket].NvdNum = 0;
>> + for (Count = 0; Count < NvdData[Socket].NvdRegionNum; Count++) {
>> + RegionId = NvdData[Socket].NvdRegionId[Count];
>> + if (PlatformHob->DramInfo.Base[RegionId] ==
>> + PLATFORM_NVDIMM_SK0_NHASHED_REGION0 ||
>> + PlatformHob->DramInfo.Base[RegionId] ==
>> + PLATFORM_NVDIMM_SK1_NHASHED_REGION0)
>> + {
>> + NvdInfo = &NvdData[Socket].NvdInfo[0];
>> + NvdInfo->DeviceHandle =
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DEVICE_HANDLE :
>> + PLATFORM_NVDIMM_NVD3_DEVICE_HANDLE;
>> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
>> + NvdInfo->RegionOffset = 0;
>> + AcpiNvdInfoInit (
>> + NvdInfo,
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD1_DIMM_ID :
>> + PLATFORM_NVDIMM_NVD3_DIMM_ID
>> + );
>> +
>> + } else if (PlatformHob->DramInfo.Base[RegionId] ==
>> + PLATFORM_NVDIMM_SK0_NHASHED_REGION1 ||
>> + PlatformHob->DramInfo.Base[RegionId] ==
>> + PLATFORM_NVDIMM_SK1_NHASHED_REGION1)
>> + {
>> + NvdInfo = &NvdData[Socket].NvdInfo[1];
>> + NvdInfo->DeviceHandle =
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DEVICE_HANDLE :
>> + PLATFORM_NVDIMM_NVD4_DEVICE_HANDLE;
>> + NvdInfo->InterleaveWays = PLATFORM_NVDIMM_NHASHED_INTERLEAVE_WAYS;
>> + NvdInfo->RegionOffset = 0;
>> + AcpiNvdInfoInit (
>> + NvdInfo,
>> + (Socket == 0) ? PLATFORM_NVDIMM_NVD2_DIMM_ID :
>> + PLATFORM_NVDIMM_NVD4_DIMM_ID
>> + );
>> + }
>> + }
>> + /* Update NvdNum */
>> + NvdData[Socket].NvdNum = 0;
>> + for (Count = 0; Count < NVDIMM_NUM_PER_SK; Count++) {
>> + if (NvdData[Socket].NvdInfo[Count].Enabled) {
>> + NvdData[Socket].NvdNum++;
>> + }
>> + }
>> + return EFI_SUCCESS;
>> +}
>> +
>> +/*
>> + * Fill in SPA structure
>> + */
>> +VOID
>> +AcpiNfitFillSPA (
>> + IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
>> + IN UINTN NvdRegionIndex,
>> + IN UINT64 NvdRegionBase,
>> + IN UINT64 NvdRegionSize
>> + )
>> +{
>> + ASSERT (NfitSpaPointer != NULL);
>> +
>> + NfitSpaPointer->Flags = 0;
>> + NfitSpaPointer->SPARangeStructureIndex = NvdRegionIndex;
>> + NfitSpaPointer->SystemPhysicalAddressRangeBase = NvdRegionBase;
>> + NfitSpaPointer->SystemPhysicalAddressRangeLength = NvdRegionSize;
>> +}
>> +
>> +VOID
>> +NfitFillControlRegion (
>> + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
>> + IN NVDIMM_INFO *NvdInfo,
>> + IN UINTN NvdControlRegionIndex
>> + )
>> +{
>> + ASSERT (
>> + NfitControlRegionPointer != NULL
>> + && NvdInfo != NULL
>> + );
>> +
>> + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex =
>> + NvdControlRegionIndex;
>> + NfitControlRegionPointer->VendorID = NvdInfo->VendorId;
>> + NfitControlRegionPointer->DeviceID = NvdInfo->DeviceId;
>> + NfitControlRegionPointer->RevisionID = NvdInfo->RevisionId;
>> + NfitControlRegionPointer->SubsystemVendorID = NvdInfo->SubVendorId;
>> + NfitControlRegionPointer->SubsystemDeviceID = NvdInfo->SubDeviceId;
>> + NfitControlRegionPointer->SubsystemRevisionID = NvdInfo->SubRevisionId;
>> + NfitControlRegionPointer->SerialNumber = NvdInfo->SerialNumber;
>> +}
>> +
>> +VOID
>> +NfitFillRegionMapping (
>> + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer,
>> + IN EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer,
>> + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer,
>> + IN NVDIMM_INFO *NvdInfo,
>> + IN UINTN NvdRegionID
>> + )
>> +{
>> + ASSERT (
>> + NfitRegionMappingPointer != NULL
>> + && NfitRegionMappingPointer != NULL
>> + && NfitRegionMappingPointer != NULL
>> + && NfitRegionMappingPointer != NULL
>> + && NvdInfo != NULL
>> + );
>> +
>> + NfitRegionMappingPointer->NVDIMMRegionID = NvdRegionID;
>> + NfitRegionMappingPointer->NVDIMMPhysicalID = NvdInfo->PhysId;
>> + NfitRegionMappingPointer->InterleaveWays = NvdInfo->InterleaveWays;
>> + NfitRegionMappingPointer->RegionOffset = NvdInfo->RegionOffset;
>> + NfitRegionMappingPointer->NVDIMMRegionSize = NvdInfo->NvdSize;
>> + NfitRegionMappingPointer->NFITDeviceHandle.DIMMNumber =
>> + NvdInfo->DeviceHandle & 0x0F;
>> + NfitRegionMappingPointer->NFITDeviceHandle.MemoryChannelNumber =
>> + (NvdInfo->DeviceHandle >> 4) & 0x0F;
>> + NfitRegionMappingPointer->NFITDeviceHandle.MemoryControllerID =
>> + (NvdInfo->DeviceHandle >> 8) & 0x0F;
>> + NfitRegionMappingPointer->NFITDeviceHandle.SocketID =
>> + (NvdInfo->DeviceHandle >> 12) & 0x0F;
>> + NfitRegionMappingPointer->SPARangeStructureIndex =
>> + NfitSpaPointer->SPARangeStructureIndex;
>> + NfitRegionMappingPointer->NVDIMMPhysicalAddressRegionBase =
>> + NfitSpaPointer->SystemPhysicalAddressRangeBase;
>> + NfitRegionMappingPointer->NVDIMMControlRegionStructureIndex =
>> + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiNfitFillTableBySK (
>> + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerStart,
>> + IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE **NfitSpaPointerNext,
>> + IN UINTN Socket
>> + )
>> +{
>> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointer;
>> + EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRegionPointer;
>> + EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMappingPointer;
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + VOID *Hob;
>> + UINT64 NvdRegionBase,
>> + NvdRegionSize;
>> + UINTN NvdCount, MaxNvdCount, RegionCount;
>> + UINTN RegionId, NvdRegionIndex, NvdIndex;
>> +
>> + /* Get the Platform HOB */
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL
>> + || NfitSpaPointerStart == NULL
>> + || NfitSpaPointerNext == NULL)
>> + {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> +
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> + NvdRegionIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdRegionNum;
>> + NvdIndex = (Socket == 0) ? 0 : NvdData[NVDIMM_SK0].NvdNum;
>> + if (NvdData[Socket].NvdMode == NVDIMM_HASHED) {
>> + /* Table Type 0: SPA Range Structure */
>> + NfitSpaPointer = NfitSpaPointerStart;
>> + CopyMem (
>> + (VOID *)NfitSpaPointer,
>> + (VOID *)&NfitSPATemplate,
>> + sizeof (NfitSPATemplate)
>> + );
>> + RegionId = NvdData[Socket].NvdRegionId[0];
>> + NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
>> + NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
>> + NvdRegionIndex++;
>> + AcpiNfitFillSPA (
>> + NfitSpaPointer,
>> + NvdRegionIndex,
>> + NvdRegionBase,
>> + NvdRegionSize
>> + );
>> +
>> + NfitControlRegionPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
>> + (NfitSpaPointer + 1);
>> + for (NvdCount = 0; NvdCount < NVDIMM_NUM_PER_SK; NvdCount++) {
>> + if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
>> + continue;
>> + }
>> + NvdIndex++;
>> + /* Table Type 4: NVDIMM Control Region Structure Mark */
>> + CopyMem (
>> + (VOID *)NfitControlRegionPointer,
>> + (VOID *)&NvdimmControlRegionTemplate,
>> + sizeof (NvdimmControlRegionTemplate)
>> + );
>> + NfitFillControlRegion (
>> + NfitControlRegionPointer,
>> + &NvdData[Socket].NvdInfo[NvdCount],
>> + NvdIndex
>> + );
>> +
>> + NfitRegionMappingPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
>> + (NfitControlRegionPointer + 1);
>> +
>> + /* Table Type 1: NVDIMM Region Mapping Structure */
>> + CopyMem (
>> + (VOID *)NfitRegionMappingPointer,
>> + (VOID *)&NvdimmRegionMappingTemplate,
>> + sizeof (NvdimmRegionMappingTemplate)
>> + );
>> + NfitFillRegionMapping (
>> + NfitRegionMappingPointer,
>> + NfitControlRegionPointer,
>> + NfitSpaPointer,
>> + &NvdData[Socket].NvdInfo[NvdCount],
>> + NvdIndex - 1
>> + );
>> +
>> + NfitControlRegionPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
>> + (NfitRegionMappingPointer + 1);
>> + }
>> + NfitSpaPointer =
>> + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
>> + NfitControlRegionPointer;
>> + } else { /* NVDIMM_NON_HASHED */
>> + NfitSpaPointer = NfitSpaPointerStart;
>> + for (RegionCount = 0; RegionCount < NvdData[Socket].NvdRegionNum;
>> + RegionCount++)
>> + {
>> + /* Table Type 0: SPA Range Structure */
>> + CopyMem (
>> + (VOID *)NfitSpaPointer,
>> + (VOID *)&NfitSPATemplate,
>> + sizeof (NfitSPATemplate)
>> + );
>> + RegionId = NvdData[Socket].NvdRegionId[RegionCount];
>> + NvdRegionBase = PlatformHob->DramInfo.Base[RegionId];
>> + NvdRegionSize = PlatformHob->DramInfo.Size[RegionId];
>> + NvdRegionIndex++;
>> + AcpiNfitFillSPA (
>> + NfitSpaPointer,
>> + NvdRegionIndex,
>> + NvdRegionBase,
>> + NvdRegionSize
>> + );
>> +
>> + NfitControlRegionPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
>> + (NfitSpaPointer + 1);
>> + NvdCount = ((NvdRegionBase == PLATFORM_NVDIMM_SK0_NHASHED_REGION0) ||
>> + (NvdRegionBase == PLATFORM_NVDIMM_SK1_NHASHED_REGION0)) ?
>> + 0 : PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
>> + MaxNvdCount = NvdCount + PLATFORM_NVDIMM_NUM_MAX_PER_MCU;
>> + for (; NvdCount < MaxNvdCount; NvdCount++) {
>> + if (!NvdData[Socket].NvdInfo[NvdCount].Enabled) {
>> + continue;
>> + }
>> + NvdIndex++;
>> +
>> + /* Table Type 4: NVDIMM Control Region Structure Mark */
>> + CopyMem (
>> + (VOID *)NfitControlRegionPointer,
>> + (VOID *)&NvdimmControlRegionTemplate,
>> + sizeof (NvdimmControlRegionTemplate)
>> + );
>> + NfitFillControlRegion (
>> + NfitControlRegionPointer,
>> + &NvdData[Socket].NvdInfo[NvdCount],
>> + NvdIndex
>> + );
>> +
>> + NfitRegionMappingPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *)
>> + (NfitControlRegionPointer + 1);
>> +
>> + /* Table Type 1: NVDIMM Region Mapping Structure */
>> + CopyMem (
>> + (VOID *)NfitRegionMappingPointer,
>> + (VOID *)&NvdimmRegionMappingTemplate,
>> + sizeof (NvdimmRegionMappingTemplate)
>> + );
>> + NfitFillRegionMapping (
>> + NfitRegionMappingPointer,
>> + NfitControlRegionPointer,
>> + NfitSpaPointer,
>> + &NvdData[Socket].NvdInfo[NvdCount],
>> + NvdIndex - 1
>> + );
>> +
>> + NfitControlRegionPointer =
>> + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *)
>> + (NfitRegionMappingPointer + 1);
>> + }
>> + NfitSpaPointer =
>> + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
>> + NfitControlRegionPointer;
>> + }
>> + }
>> + /* Update NfitSpaPointerNext */
>> + *NfitSpaPointerNext = NfitSpaPointer;
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiNfitFillTable (
>> + IN EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer
>> + )
>> +{
>> + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointerNext;
>> +
>> + if (NfitTablePointer == NULL) {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> +
>> + NfitSpaPointerNext = (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)
>> + (NfitTablePointer + 1);
>> +
>> + if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
>> + AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK0);
>> + }
>> +
>> + if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
>> + AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM_SK1);
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +/*
>> + * Install NFIT table.
>> + */
>> +EFI_STATUS
>> +AcpiInstallNfitTable (
>> + VOID
>> + )
>> +{
>> + EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *NfitTablePointer;
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + UINTN NfitTableKey = 0;
>> + EFI_STATUS Status;
>> + UINTN Size;
>> + UINTN NvdRegionNum;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> + Status = AcpiNvdDataInit (NVDIMM_SK0);
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> + Status = AcpiNvdDataInit (NVDIMM_SK1);
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> + NvdRegionNum = NvdData[NVDIMM_SK0].NvdRegionNum +
>> + NvdData[NVDIMM_SK1].NvdRegionNum;
>> + if (NvdRegionNum == 0) {
>> + return EFI_INVALID_PARAMETER; /* No NVDIMM Region */
>> + }
>> + Size = sizeof (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE);
>> + if (NvdData[NVDIMM_SK0].NvdRegionNum != 0) {
>> + Size +=
>> + (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
>> + NvdData[NVDIMM_SK0].NvdRegionNum) +
>> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
>> + NvdData[NVDIMM_SK0].NvdNum) +
>> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
>> + NvdData[NVDIMM_SK0].NvdNum);
>> + }
>> + if (NvdData[NVDIMM_SK1].NvdRegionNum != 0) {
>> + Size +=
>> + (sizeof (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE) *
>> + NvdData[NVDIMM_SK1].NvdRegionNum) +
>> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE) *
>> + NvdData[NVDIMM_SK1].NvdNum) +
>> + (sizeof (EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE) *
>> + NvdData[NVDIMM_SK1].NvdNum);
>> + }
>> + NfitTablePointer =
>> + (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *)AllocateZeroPool (Size);
>> + if (NfitTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> + CopyMem (
>> + (VOID *)NfitTablePointer,
>> + (VOID *)&NFITTableHeaderTemplate,
>> + sizeof (NFITTableHeaderTemplate)
>> + );
>> +
>> + NfitTablePointer->Header.Length = Size;
>> +
>> + Status = AcpiNfitFillTable (NfitTablePointer);
>> + if (EFI_ERROR (Status)) {
>> + FreePool ((VOID *)NfitTablePointer);
>> + return Status;
>> + }
>> + AcpiTableChecksum (
>> + (UINT8 *)NfitTablePointer,
>> + NfitTablePointer->Header.Length
>> + );
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)NfitTablePointer,
>> + NfitTablePointer->Header.Length,
>> + &NfitTableKey
>> + );
>> + if (EFI_ERROR (Status)) {
>> + FreePool ((VOID *)NfitTablePointer);
>> + }
>> + return Status;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
>> new file mode 100644
>> index 000000000000..296ae57aada0
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c
>> @@ -0,0 +1,196 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Library/AcpiPccLib.h>
>> +#include "AcpiPlatform.h"
>> +
>> +EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS PcctSubspaceTemplate = {
>> + EFI_ACPI_6_3_PCCT_SUBSPACE_TYPE_2_HW_REDUCED_COMMUNICATIONS,
>> + sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS),
>> + 0, // PlatformInterrupt
>> + 0, // PlatformInterruptFlags
>> + 0, // Reserved
>> + 0, // BaseAddress
>> + 0x100, // AddressLength
>> + { 0, 0x20, 0, 0x3, 0x0 }, // DoorbellRegister
>> + 0, // DoorbellPreserve
>> + 0x53000040, // DoorbellWrite
>> + 1, // NominalLatency
>> + 1, // MaximumPeriodicAccessRate
>> + 1, // MinimumRequestTurnaroundTime
>> + { 0, 0x20, 0, 0x3, 0x0 }, // PlatformInterruptAckRegister
>> + 0, // PlatformInterruptAckPreserve
>> + 0x10001, // PlatformInterruptAckWrite
>> +};
>> +
>> +EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER PcctTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_PLATFORM_COMMUNICATIONS_CHANNEL_TABLE_SIGNATURE,
>> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER,
>> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_REVISION
>> + ),
>> + EFI_ACPI_6_3_PCCT_FLAGS_PLATFORM_INTERRUPT,
>> +};
>> +
>> +EFI_STATUS
>> +AcpiPcctInit (
>> + VOID
>> + )
>> +{
>> + UINT8 NumberOfSockets;
>> + UINT8 Socket;
>> + UINT16 Doorbell;
>> + UINT16 Subspace;
>> +
>> + NumberOfSockets = GetNumberOfActiveSockets ();
>> + Subspace = 0;
>> +
>> + for (Socket = 0; Socket < NumberOfSockets; Socket++) {
>> + for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
>> + if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
>> + continue;
>> + }
>> + AcpiPccInitSharedMemory (Socket, Doorbell, Subspace);
>> + AcpiPccUnmaskDoorbellInterrupt (Socket, Doorbell);
>> +
>> + Subspace++;
>> + }
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +/**
>> + Install PCCT table.
>> +
>> + Each socket has 16 PCC subspaces corresponding to 16 Mailbox/Doorbell channels
>> + 0 - 7 : PMpro subspaces
>> + 8 - 15 : SMpro subspaces
>> +
>> + Please note that some SMpro/PMpro Doorbell are reserved for private use.
>> + The reserved Doorbells are filtered by using the ACPI_PCC_AVAILABLE_DOORBELL_MASK
>> + and ACPI_PCC_NUMBER_OF_RESERVED_DOORBELLS macro.
>> +
>> +**/
>> +EFI_STATUS
>> +AcpiInstallPcctTable (
>> + VOID
>> + )
>> +{
>> + EFI_STATUS Status;
>> + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *PcctTablePointer;
>> + EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *PcctEntryPointer;
>> + EFI_PHYSICAL_ADDRESS PccSharedMemPointer;
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + UINTN PcctTableKey;
>> + UINT8 NumberOfSockets;
>> + UINT8 Socket;
>> + UINT16 Doorbell;
>> + UINT16 Subspace;
>> + UINT16 NumberOfSubspaces;
>> + UINTN Size;
>> + UINTN DoorbellAddress;
>> +
>> + Subspace = 0;
>> + NumberOfSockets = GetNumberOfActiveSockets ();
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + NumberOfSubspaces = ACPI_PCC_MAX_SUBPACE_PER_SOCKET * NumberOfSockets;
>> +
>> + AcpiPccAllocateSharedMemory (&PccSharedMemPointer, NumberOfSubspaces);
>> + if (PccSharedMemPointer == 0) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> +
>> + Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
>> + NumberOfSubspaces * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
>> +
>> + PcctTablePointer = (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *)AllocateZeroPool (Size);
>> + if (PcctTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> +
>> + PcctEntryPointer = (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *)
>> + ((UINT64)PcctTablePointer + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER));
>> +
>> + for (Socket = 0; Socket < NumberOfSockets; Socket++) {
>> + for (Doorbell = 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell++ ) {
>> + if (AcpiPccIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKET * Socket)) {
>> + continue;
>> + }
>> +
>> + CopyMem (
>> + &PcctEntryPointer[Subspace],
>> + &PcctSubspaceTemplate,
>> + sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS)
>> + );
>> +
>> + PcctEntryPointer[Subspace].BaseAddress = (UINT64)PccSharedMemPointer + ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE * Subspace;
>> + PcctEntryPointer[Subspace].AddressLength = ACPI_PCC_SUBSPACE_SHARED_MEM_SIZE;
>> +
>> + DoorbellAddress = MailboxGetDoorbellAddress (Socket, Doorbell);
>> +
>> + PcctEntryPointer[Subspace].DoorbellRegister.Address = DoorbellAddress + DB_OUT_REG_OFST;
>> + PcctEntryPointer[Subspace].PlatformInterrupt = MailboxGetDoorbellInterruptNumber (Socket, Doorbell);
>> + PcctEntryPointer[Subspace].PlatformInterruptAckRegister.Address = DoorbellAddress + DB_STATUS_REG_OFST;
>> +
>> + if (Doorbell == ACPI_PCC_CPPC_DOORBELL_ID) {
>> + PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_URGENT_CPPC_MESSAGE;
>> + PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_CPPC_NOMINAL_LATENCY_US;
>> + PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_CPPC_MIN_REQ_TURNAROUND_TIME_US;
>> + } else {
>> + PcctEntryPointer[Subspace].DoorbellWrite = MAILBOX_TYPICAL_PCC_MESSAGE;
>> + PcctEntryPointer[Subspace].NominalLatency = ACPI_PCC_NOMINAL_LATENCY_US;
>> + PcctEntryPointer[Subspace].MinimumRequestTurnaroundTime = ACPI_PCC_MIN_REQ_TURNAROUND_TIME_US;
>> + }
>> + PcctEntryPointer[Subspace].MaximumPeriodicAccessRate = ACPI_PCC_MAX_PERIODIC_ACCESS_RATE;
>> +
>> + Subspace++;
>> + }
>> + }
>> +
>> + CopyMem (
>> + PcctTablePointer,
>> + &PcctTableHeaderTemplate,
>> + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER)
>> + );
>> +
>> + //
>> + // Recalculate the size
>> + //
>> + Size = sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) +
>> + Subspace * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS);
>> +
>> + PcctTablePointer->Header.Length = Size;
>> + AcpiTableChecksum (
>> + (UINT8 *)PcctTablePointer,
>> + PcctTablePointer->Header.Length
>> + );
>> +
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)PcctTablePointer,
>> + PcctTablePointer->Header.Length,
>> + &PcctTableKey
>> + );
>> + if (EFI_ERROR (Status)) {
>> + AcpiPccFreeSharedMemory ();
>> + FreePool ((VOID *)PcctTablePointer);
>> + return Status;
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
>> new file mode 100644
>> index 000000000000..3ed3e98d00d2
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c
>> @@ -0,0 +1,178 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include "AcpiApei.h"
>> +#include "AcpiPlatform.h"
>> +
>> +STATIC EFI_EVENT mAcpiRegistration = NULL;
>> +
>> +/*
>> + * This GUID must match the FILE_GUID in AcpiTables.inf of each boards
>> + */
>> +STATIC CONST EFI_GUID mAcpiCommonTableFile = { 0xCEFA2AEB, 0x357E, 0x4F48, { 0x80, 0x66, 0xEA, 0x95, 0x08, 0x53, 0x05, 0x6E } } ;
>> +STATIC CONST EFI_GUID mJadeAcpiTableFile = { 0x5addbc13, 0x8634, 0x480c, { 0x9b, 0x94, 0x67, 0x1b, 0x78, 0x55, 0xcd, 0xb8 } };
>> +/**
>> + * Callback called when ACPI Protocol is installed
>> + */
>> +STATIC VOID
>> +AcpiNotificationEvent (
>> + IN EFI_EVENT Event,
>> + IN VOID *Context
>> + )
>> +{
>> + EFI_STATUS Status;
>> + EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp;
>> +
>> + Status = LocateAndInstallAcpiFromFv (&mAcpiCommonTableFile);
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + Status = LocateAndInstallAcpiFromFv (&mJadeAcpiTableFile);
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + //
>> + // Find ACPI table RSD_PTR from the system table.
>> + //
>> + Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **)&Rsdp);
>> + if (EFI_ERROR (Status)) {
>> + Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **)&Rsdp);
>> + }
>> +
>> + if (!EFI_ERROR (Status) &&
>> + Rsdp != NULL &&
>> + Rsdp->Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION &&
>> + Rsdp->RsdtAddress != 0)
>> + {
>> + // ARM Platforms must set the RSDT address to NULL
>> + Rsdp->RsdtAddress = 0;
>> + }
>> +
>> + DEBUG ((DEBUG_INFO, "[%a:%d]-\n", __FUNCTION__, __LINE__));
>> +}
>> +
>> +VOID
>> +EFIAPI
>> +InstallAcpiOnReadyToBoot (
>> + IN EFI_EVENT Event,
>> + IN VOID *Context
>> + )
>> +{
>> + EFI_STATUS Status;
>> +
>> + Status = AcpiInstallMadtTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Installed MADT table\n"));
>> + }
>> +
>> + Status = AcpiInstallPpttTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Installed PPTT table\n"));
>> + }
>> +
>> + Status = AcpiInstallSlitTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Installed SLIT table\n"));
>> + }
>> +
>> + Status = AcpiInstallSratTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Installed SRAT table\n"));
>> + }
>> +
>> + Status = AcpiInstallPcctTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Installed PCCT table\n"));
>> + }
>> +
>> + Status = AcpiInstallNfitTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_ERROR, "Installed NFIT table\n"));
>> + }
>> +
>> + Status = AcpiPopulateBert ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "Populate BERT record\n"));
>> + }
>> +
>> + //
>> + // Close the event, so it will not be signalled again.
>> + //
>> + gBS->CloseEvent (Event);
>> +}
>> +
>> +VOID
>> +EFIAPI
>> +UpdateAcpiOnExitBootServices (
>> + IN EFI_EVENT Event,
>> + IN VOID *Context
>> + )
>> +{
>> + EFI_STATUS Status;
>> +
>> + Status = AcpiPatchDsdtTable ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "DSDT Table updated!\n"));
>> + }
>> +
>> + // Configure ACPI Platform Error Interfaces
>> + Status = AcpiApeiUpdate ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "APEI Table updated!\n"));
>> + }
>> +
>> + // Configure PCC mailbox base address and unmask interrupt
>> + Status = AcpiPcctInit ();
>> + if (!EFI_ERROR (Status)) {
>> + DEBUG ((DEBUG_INFO, "PCCT Table updated!\n"));
>> + }
>> +
>> + //
>> + // Close the event, so it will not be signalled again.
>> + //
>> + gBS->CloseEvent (Event);
>> +}
>> +
>> +EFI_STATUS
>> +EFIAPI
>> +AcpiPlatformDxeInitialize (
>> + IN EFI_HANDLE ImageHandle,
>> + IN EFI_SYSTEM_TABLE *SystemTable
>> + )
>> +{
>> + EFI_EVENT ReadyToBootEvent;
>> + EFI_EVENT ExitBootServicesEvent;
>> + EFI_STATUS Status;
>> +
>> + EfiCreateProtocolNotifyEvent (
>> + &gEfiAcpiTableProtocolGuid,
>> + TPL_CALLBACK,
>> + AcpiNotificationEvent,
>> + NULL,
>> + &mAcpiRegistration
>> + );
>> +
>> + Status = gBS->CreateEvent (
>> + EVT_SIGNAL_EXIT_BOOT_SERVICES,
>> + TPL_CALLBACK,
>> + UpdateAcpiOnExitBootServices,
>> + NULL,
>> + &ExitBootServicesEvent
>> + );
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + Status = gBS->CreateEventEx (
>> + EVT_NOTIFY_SIGNAL,
>> + TPL_CALLBACK,
>> + InstallAcpiOnReadyToBoot,
>> + NULL,
>> + &gEfiEventReadyToBootGuid,
>> + &ReadyToBootEvent
>> + );
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
>> new file mode 100644
>> index 000000000000..97adb66beed3
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c
>> @@ -0,0 +1,378 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include "AcpiPlatform.h"
>> +
>> +EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR PPTTProcessorTemplate = {
>> + EFI_ACPI_6_3_PPTT_TYPE_PROCESSOR,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR),
>> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
>> + {0}, /* Flags */
>> + 0, /* Parent */
>> + 0, /* AcpiProcessorId */
>> + 0 /* NumberOfPrivateResources */
>> +};
>> +
>> +EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE PPTTCacheTemplate = {
>> + EFI_ACPI_6_3_PPTT_TYPE_CACHE,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE),
>> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
>> + {0}, /* Flags */
>> + 0, /* NextLevelOfCache */
>> + 0, /* Size */
>> + 0, /* NumberOfSets */
>> + 0, /* Associativity */
>> + {0}, /* Attributes */
>> + 0
>> +};
>> +
>> +EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER PPTTTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_STRUCTURE_SIGNATURE,
>> + 0, /* need fill in */
>> + EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_REVISION
>> + ),
>> +};
>> +
>> +STATIC EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *PpttTablePointer;
>> +STATIC UINT32 PpttClusterOffset[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET];
>> +STATIC UINT32 PpttSocketOffset[PLATFORM_CPU_MAX_SOCKET];
>> +STATIC UINT32 PpttRootOffset;
>> +STATIC UINT32 PpttL1DataCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
>> +STATIC UINT32 PpttL1InstructionCacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
>> +STATIC UINT32 PpttL2CacheOffset[PLATFORM_CPU_MAX_NUM_CORES];
>> +STATIC UINT32 PpttSLCCacheOffset[PLATFORM_CPU_MAX_SOCKET];
>> +
>> +UINT32
>> +AcpiPpttProcessorCoreNode (
>> + VOID *EntryPointer,
>> + UINT32 CpuId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
>> + UINT32 *ResPointer;
>> + UINTN ClusterIdPerSocket, CoreIdPerCpm, SocketId;
>> +
>> + CopyMem (
>> + PpttProcessorEntryPointer,
>> + &PPTTProcessorTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
>> + );
>> +
>> + ClusterIdPerSocket = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) % PLATFORM_CPU_MAX_CPM;
>> + SocketId = (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) / PLATFORM_CPU_MAX_CPM;
>> + CoreIdPerCpm = CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM;
>> + PpttProcessorEntryPointer->Flags.AcpiProcessorIdValid = 1;
>> + PpttProcessorEntryPointer->Flags.NodeIsALeaf = 1;
>> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
>> + PpttProcessorEntryPointer->AcpiProcessorId = (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) | (ClusterIdPerSocket << 8) | CoreIdPerCpm;
>> + PpttProcessorEntryPointer->Parent = (UINT32)PpttClusterOffset[CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM];
>> + PpttProcessorEntryPointer->NumberOfPrivateResources = 2; /* L1I + L1D */
>> +
>> + ResPointer = (UINT32 *)((UINT64)EntryPointer +
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
>> + ResPointer[0] = PpttL1InstructionCacheOffset[CpuId];
>> + ResPointer[1] = PpttL1DataCacheOffset[CpuId];
>> +
>> + PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32);
>> +
>> + return PpttProcessorEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttClusterNode (
>> + VOID *EntryPointer,
>> + UINT32 ClusterId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
>> +
>> + PpttClusterOffset[ClusterId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> +
>> + CopyMem (
>> + PpttProcessorEntryPointer,
>> + &PPTTProcessorTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
>> + );
>> +
>> + PpttProcessorEntryPointer->Parent = (UINT32)PpttSocketOffset[ClusterId / PLATFORM_CPU_MAX_CPM];
>> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
>> +
>> + return PpttProcessorEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttSocketNode (
>> + VOID *EntryPointer,
>> + UINT32 SocketId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
>> + UINT32 *ResPointer;
>> +
>> + PpttSocketOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> +
>> + CopyMem (
>> + PpttProcessorEntryPointer,
>> + &PPTTProcessorTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
>> + );
>> +
>> + PpttProcessorEntryPointer->Flags.PhysicalPackage = 1;
>> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
>> + PpttProcessorEntryPointer->Parent = (UINT32)PpttRootOffset;
>> +
>> + PpttProcessorEntryPointer->NumberOfPrivateResources = 1;
>> + ResPointer = (UINT32 *)((UINT64)EntryPointer + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR));
>> + ResPointer[0] = PpttSLCCacheOffset[SocketId];
>> +
>> + PpttProcessorEntryPointer->Length = sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32);
>> +
>> + return PpttProcessorEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttRootNode (
>> + VOID *EntryPointer
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = EntryPointer;
>> +
>> + PpttRootOffset = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> +
>> + CopyMem (
>> + PpttProcessorEntryPointer,
>> + &PPTTProcessorTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)
>> + );
>> +
>> + PpttProcessorEntryPointer->Flags.IdenticalImplementation = 1;
>> +
>> + return PpttProcessorEntryPointer->Length;
>> +}
>> +
>> +STATIC VOID
>> +AcpiPpttFillCacheSizeInfo (
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *Node,
>> + UINT32 Level
>> + )
>> +{
>> + UINT64 CacheCCSIDR;
>> + UINT32 CacheLineSize;
>> + UINT32 Count;
>> +
>> + CacheCCSIDR = ReadCCSIDR (Level);
>> +
>> + CacheLineSize = 1;
>> + Count = CCSIDR_LINE_SIZE (CacheCCSIDR) + 4;
>> + while (Count-- > 0) {
>> + CacheLineSize *= 2;
>> + }
>> +
>> + Node->Flags.LineSizeValid = 1;
>> + Node->Flags.NumberOfSetsValid = 1;
>> + Node->Flags.AssociativityValid = 1;
>> + Node->Flags.SizePropertyValid = 1;
>> + Node->Flags.CacheTypeValid = 1;
>> + Node->NumberOfSets = CCSIDR_NUMSETS (CacheCCSIDR) + 1;
>> + Node->Associativity = CCSIDR_ASSOCIATIVITY (CacheCCSIDR) + 1;
>> + Node->LineSize = CacheLineSize;
>> + Node->Size = Node->NumberOfSets *
>> + Node->Associativity *
>> + Node->LineSize;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttL1DataCacheNode (
>> + VOID *EntryPointer,
>> + UINT32 CpuId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
>> +
>> + PpttL1DataCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> + CopyMem (
>> + PpttCacheEntryPointer,
>> + &PPTTCacheTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
>> + );
>> +
>> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
>> + PpttCacheEntryPointer->Attributes.CacheType = 0x0; /* Data Cache */
>> + PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
>> +
>> + return PpttCacheEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttL1InstructionCacheNode (
>> + VOID *EntryPointer,
>> + UINT32 CpuId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
>> +
>> + PpttL1InstructionCacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> + CopyMem (
>> + PpttCacheEntryPointer,
>> + &PPTTCacheTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
>> + );
>> +
>> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1);
>> + PpttCacheEntryPointer->Attributes.CacheType = 0x1; /* Instruction Cache */
>> + PpttCacheEntryPointer->NextLevelOfCache = PpttL2CacheOffset[CpuId];
>> +
>> + return PpttCacheEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttL2CacheNode (
>> + VOID *EntryPointer,
>> + UINT32 CpuId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
>> +
>> + PpttL2CacheOffset[CpuId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> + CopyMem (
>> + PpttCacheEntryPointer,
>> + &PPTTCacheTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
>> + );
>> +
>> + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 2);
>> + PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
>> + PpttCacheEntryPointer->NextLevelOfCache = 0;
>> +
>> + return PpttCacheEntryPointer->Length;
>> +}
>> +
>> +STATIC UINT32
>> +AcpiPpttSLCCacheNode (
>> + VOID *EntryPointer,
>> + UINT32 SocketId
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer = EntryPointer;
>> +
>> + PpttSLCCacheOffset[SocketId] = (UINT64)EntryPointer - (UINT64)PpttTablePointer;
>> + CopyMem (
>> + PpttCacheEntryPointer,
>> + &PPTTCacheTemplate,
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)
>> + );
>> +
>> + PpttCacheEntryPointer->Flags.LineSizeValid = 1;
>> + PpttCacheEntryPointer->Flags.NumberOfSetsValid = 1;
>> + PpttCacheEntryPointer->Flags.AssociativityValid = 1;
>> + PpttCacheEntryPointer->Flags.SizePropertyValid = 1;
>> + PpttCacheEntryPointer->Flags.CacheTypeValid = 1;
>> +
>> + PpttCacheEntryPointer->Size = 0x2000000; /* 32 MB */
>> + PpttCacheEntryPointer->NumberOfSets = 0x400; /* 1024 sets per 1MB HN-F */
>> +
>> + PpttCacheEntryPointer->Associativity = 0x10; /* 16-way set-associative */
>> + PpttCacheEntryPointer->LineSize = 0x40; /* 64 bytes */
>> + PpttCacheEntryPointer->NextLevelOfCache = 0;
>> +
>> + PpttCacheEntryPointer->Attributes.CacheType = 0x3; /* Unified Cache */
>> +
>> + return PpttCacheEntryPointer->Length;
>> +}
>> +
>> +/*
>> + * Install PPTT table.
>> + */
>> +EFI_STATUS
>> +AcpiInstallPpttTable (
>> + VOID
>> + )
>> +{
>> + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer = NULL;
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + UINTN PpttTableKey = 0;
>> + UINTN Count;
>> + EFI_STATUS Status;
>> + UINTN Size;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + Size = sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER) +
>> + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + /* Root node */
>> + (PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* SLC node */
>> + (PLATFORM_CPU_MAX_SOCKET * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + sizeof (UINT32))) + /* Socket node */
>> + (PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)) + /* Cluster node */
>> + (PLATFORM_CPU_MAX_NUM_CORES * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + 2 * sizeof (UINT32))) + /* Core node */
>> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1I node */
>> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)) + /* L1D node */
>> + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE)); /* L2 node */
>> +
>> + PpttTablePointer =
>> + (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *)AllocateZeroPool (Size);
>> + if (PpttTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> +
>> + PpttProcessorEntryPointer =
>> + (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *)((UINT64)PpttTablePointer +
>> + sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER));
>> +
>> + Size = 0;
>> + Size += AcpiPpttRootNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size));
>> +
>> + for (Count = 0; Count < PLATFORM_CPU_MAX_SOCKET; Count++) {
>> + Size += AcpiPpttSLCCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + Size += AcpiPpttSocketNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + }
>> +
>> + for (Count = 0; Count < PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET; Count++) {
>> + Size += AcpiPpttClusterNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + }
>> +
>> + for (Count = 0; Count < PLATFORM_CPU_MAX_NUM_CORES; Count++) {
>> + Size += AcpiPpttL2CacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + Size += AcpiPpttL1InstructionCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + Size += AcpiPpttL1DataCacheNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + Size += AcpiPpttProcessorCoreNode ((VOID *)((UINT64)PpttProcessorEntryPointer + Size), Count);
>> + }
>> +
>> + CopyMem (
>> + PpttTablePointer,
>> + &PPTTTableHeaderTemplate,
>> + sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER)
>> + );
>> +
>> + Size += sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER);
>> + PpttTablePointer->Header.Length = Size;
>> +
>> + AcpiTableChecksum (
>> + (UINT8 *)PpttTablePointer,
>> + PpttTablePointer->Header.Length
>> + );
>> +
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)PpttTablePointer,
>> + PpttTablePointer->Header.Length,
>> + &PpttTableKey
>> + );
>> + FreePool ((VOID *)PpttTablePointer);
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
>> new file mode 100644
>> index 000000000000..60acdb9dd5db
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c
>> @@ -0,0 +1,190 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include "AcpiPlatform.h"
>> +
>> +#define MAX_NODES_PER_SOCKET 4
>> +#define SELF_DISTANCE 10
>> +#define REMOTE_DISTANCE 20
>> +
>> +EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER SLITTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_SYSTEM_LOCALITY_INFORMATION_TABLE_SIGNATURE,
>> + 0, /* need fill in */
>> + EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_REVISION
>> + ),
>> + 0,
>> +};
>> +
>> +VOID
>> +ComputeCoordinatesForNode (
>> + UINTN Node,
>> + UINTN *X,
>> + UINTN *Y
>> + )
>> +{
>> + switch (Node) {
>> + case 0:
>> + *X = 0;
>> + *Y = 0;
>> + break;
>> + case 1:
>> + *X = 1;
>> + *Y = 0;
>> + break;
>> + case 2:
>> + *X = 0;
>> + *Y = 1;
>> + break;
>> + case 3:
>> + *X = 1;
>> + *Y = 1;
>> + break;
>> + default:
>> + *X = 0;
>> + *Y = 0;
>> + break;
>> + }
>> +}
>> +
>> +/**
>> + Compute the distance between between two nodes on socket.
>> +**/
>> +UINT8
>> +ComputeSlitDistanceOnSocket (
>> + UINTN Node1,
>> + UINTN Node2
>> + )
>> +{
>> + UINTN X1, Y1, X2, Y2;
>> + UINTN XDistance, YDistance;
>> +
>> + ComputeCoordinatesForNode (Node1, &X1, &Y1);
>> + ComputeCoordinatesForNode (Node2, &X2, &Y2);
>> +
>> + XDistance = ABS ((INTN)(X1 - X2));
>> + YDistance = ABS ((INTN)(Y1 - Y2));
>> +
>> + return (UINT8)(XDistance + YDistance + SELF_DISTANCE);
>> +}
>> +
>> +/**
>> + Compute the distance between between two nodes on
>> + different sockets.
>> + Node1 - local socket node number
>> + Node2 - remote socket node number
>> +**/
>> +UINT8
>> +ComputeSlitDistanceOnRemoteSocket (
>> + UINTN LocalNode,
>> + UINTN RemoteNode
>> + )
>> +{
>> + UINTN LocalDistance, RemoteDistance;
>> +
>> + //
>> + // Mesh forwards traffic between sockets over both CCIX links when going from
>> + // one quadrant to another. For example, memory access from Node 0 to Node 4
>> + // results in traffic being split between RCA0 and 1. Hence distance is
>> + // different only between upper half and lower half of sockets and not
>> + // between quadrants. Hemisphere configuration is not impacted as there
>> + // is no upper-half.
>> + //
>> + LocalDistance = 0;
>> + RemoteDistance = 0;
>> + if (LocalNode >= (MAX_NODES_PER_SOCKET / 2)) {
>> + LocalDistance = 1;
>> + }
>> + if (RemoteNode >= (MAX_NODES_PER_SOCKET / 2)) {
>> + RemoteDistance = 1;
>> + }
>> +
>> + return (UINT8)(LocalDistance + RemoteDistance + REMOTE_DISTANCE);
>> +}
>> +
>> +UINT8
>> +ComputeSlitDistance (
>> + UINTN Node1,
>> + UINTN Node2,
>> + UINTN DomainsPerSocket
>> + )
>> +{
>> + UINT8 Distance;
>> +
>> + Distance = 0;
>> + if ((Node1 / DomainsPerSocket) == (Node2 / DomainsPerSocket)) {
>> + Distance = ComputeSlitDistanceOnSocket (
>> + Node1 % DomainsPerSocket,
>> + Node2 % DomainsPerSocket
>> + );
>> + } else {
>> + Distance = ComputeSlitDistanceOnRemoteSocket (
>> + Node1 % DomainsPerSocket,
>> + Node2 % DomainsPerSocket
>> + );
>> + }
>> +
>> + return Distance;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiInstallSlitTable (
>> + VOID
>> + )
>> +{
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + EFI_STATUS Status;
>> + UINTN NumDomain, Count, Count1;
>> + EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *SlitTablePointer;
>> + UINT8 *TmpPtr;
>> + UINTN SlitTableKey;
>> + UINTN NumDomainPerSocket;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + NumDomainPerSocket = CpuGetNumberOfSubNumaRegion ();
>> + NumDomain = NumDomainPerSocket * GetNumberOfActiveSockets ();
>> +
>> + SlitTablePointer = (EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *)
>> + AllocateZeroPool (sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain);
>> + if (SlitTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> + CopyMem ((VOID *)SlitTablePointer, (VOID *)&SLITTableHeaderTemplate, sizeof (SLITTableHeaderTemplate));
>> + SlitTablePointer->NumberOfSystemLocalities = NumDomain;
>> + TmpPtr = (UINT8 *)SlitTablePointer + sizeof (SLITTableHeaderTemplate);
>> + for (Count = 0; Count < NumDomain; Count++) {
>> + for (Count1 = 0; Count1 < NumDomain; Count1++, TmpPtr++) {
>> + *TmpPtr = ComputeSlitDistance (Count, Count1, NumDomainPerSocket);
>> + }
>> + }
>> +
>> + SlitTablePointer->Header.Length = sizeof (SLITTableHeaderTemplate) + NumDomain * NumDomain;
>> +
>> + AcpiTableChecksum (
>> + (UINT8 *)SlitTablePointer,
>> + SlitTablePointer->Header.Length
>> + );
>> +
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)SlitTablePointer,
>> + SlitTablePointer->Header.Length,
>> + &SlitTableKey
>> + );
>> + FreePool ((VOID *)SlitTablePointer);
>> +
>> + return Status;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
>> new file mode 100644
>> index 000000000000..5f3b7007623a
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c
>> @@ -0,0 +1,274 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Guid/ArmMpCoreInfo.h>
>> +#include "AcpiPlatform.h"
>> +
>> +EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER SRATTableHeaderTemplate = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_SIGNATURE,
>> + 0, /* need fill in */
>> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_REVISION
>> + ),
>> + 0x00000001,
>> + 0x0000000000000000,
>> +};
>> +
>> +EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE GicItsAffinityTemplate = {
>> + .Type = EFI_ACPI_6_3_GIC_ITS_AFFINITY,
>> + sizeof (EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE),
>> + .ProximityDomain = 0, /* ProximityDomain */
>> + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE },
>> + .ItsId = 0,
>> +};
>> +
>> +STATIC
>> +UINTN
>> +SratCalculateNumMemoryRegion (
>> + VOID
>> + )
>> +{
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + UINTN Count;
>> + UINT64 TmpVal;
>> + VOID *Hob;
>> + UINTN Result;
>> +
>> + /* Get the Platform HOB */
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL) {
>> + return 0;
>> + }
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + Result = 0;
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + TmpVal = PlatformHob->DramInfo.Size[Count];
>> + if (TmpVal > 0) {
>> + Result++;
>> + }
>> + }
>> +
>> + return Result;
>> +}
>> +
>> +STATIC
>> +EFI_STATUS
>> +SratAddMemAffinity (
>> + EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *SratMemAffinity
>> + )
>> +{
>> + PLATFORM_INFO_HOB *PlatformHob;
>> + UINTN Count, NumRegion;
>> + UINT64 RegionSize, RegionBase;
>> + VOID *Hob;
>> + UINTN ProximityDomain;
>> +
>> + /* Get the Platform HOB */
>> + Hob = GetFirstGuidHob (&gPlatformHobGuid);
>> + if (Hob == NULL) {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> + PlatformHob = (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob);
>> +
>> + NumRegion = 0;
>> +
>> + for (Count = 0; Count < PlatformHob->DramInfo.NumRegion; Count++) {
>> + RegionSize = PlatformHob->DramInfo.Size[Count];
>> + RegionBase = PlatformHob->DramInfo.Base[Count];
>> + ProximityDomain = PlatformHob->DramInfo.Node[Count];
>> + if (RegionSize > 0) {
>> + ZeroMem ((VOID *)&SratMemAffinity[NumRegion], sizeof (SratMemAffinity[NumRegion]));
>> + SratMemAffinity[NumRegion].Flags = EFI_ACPI_6_3_MEMORY_ENABLED;
>> + if (PlatformHob->DramInfo.NvdRegion[Count] != 0) {
>> + /* Mark NVDIMM-N region as HOT_PLUGGABLE and NON-VOLATILE */
>> + SratMemAffinity[NumRegion].Flags |= EFI_ACPI_6_3_MEMORY_HOT_PLUGGABLE |
>> + EFI_ACPI_6_3_MEMORY_NONVOLATILE;
>> + }
>> + SratMemAffinity[NumRegion].LengthLow =
>> + (UINT32)(RegionSize & 0xFFFFFFFF);
>> + SratMemAffinity[NumRegion].LengthHigh =
>> + (UINT32)((RegionSize & 0xFFFFFFFF00000000ULL) >> 32);
>> + SratMemAffinity[NumRegion].AddressBaseLow =
>> + (UINT32)(RegionBase & 0xFFFFFFFF);
>> + SratMemAffinity[NumRegion].AddressBaseHigh =
>> + (UINT32)((RegionBase & 0xFFFFFFFF00000000ULL) >> 32);
>> + SratMemAffinity[NumRegion].ProximityDomain = (UINT32)(ProximityDomain);
>> + SratMemAffinity[NumRegion].Type = EFI_ACPI_6_3_MEMORY_AFFINITY;
>> + SratMemAffinity[NumRegion].Length = sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
>> + NumRegion++;
>> + }
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +STATIC
>> +EFI_STATUS
>> +SratAddGiccAffinity (
>> + EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *SratGiccAffinity
>> + )
>> +{
>> + ARM_PROCESSOR_TABLE *ArmProcessorTable;
>> + ARM_CORE_INFO *ArmCoreInfoTable;
>> + UINTN Count, NumNode, Idx;
>> + UINT32 AcpiProcessorUid;
>> + UINT8 Socket;
>> + UINT8 Cpm;
>> +
>> + for (Idx = 0; Idx < gST->NumberOfTableEntries; Idx++) {
>> + if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Idx].VendorGuid))) {
>> + ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Idx].VendorTable;
>> + ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
>> + break;
>> + }
>> + }
>> +
>> + if (Idx == gST->NumberOfTableEntries) {
>> + return EFI_INVALID_PARAMETER;
>> + }
>> +
>> + Count = 0;
>> + NumNode = 0;
>> + while (Count != ArmProcessorTable->NumberOfEntries) {
>> + for (Idx = 0; Idx < ArmProcessorTable->NumberOfEntries; Idx++ ) {
>> + Socket = ArmCoreInfoTable[Idx].ClusterId;
>> + Cpm = (ArmCoreInfoTable[Idx].CoreId >> PLATFORM_CPM_UID_BIT_OFFSET);
>> + if (CpuGetSubNumNode (Socket, Cpm) != NumNode) {
>> + /* We add nodes based on ProximityDomain order */
>> + continue;
>> + }
>> + AcpiProcessorUid = (ArmCoreInfoTable[Idx].ClusterId << PLATFORM_SOCKET_UID_BIT_OFFSET) +
>> + ArmCoreInfoTable[Idx].CoreId;
>> + ZeroMem ((VOID *)&SratGiccAffinity[Count], sizeof (SratGiccAffinity[Count]));
>> + SratGiccAffinity[Count].AcpiProcessorUid = AcpiProcessorUid;
>> + SratGiccAffinity[Count].Flags = 1;
>> + SratGiccAffinity[Count].Length = sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
>> + SratGiccAffinity[Count].Type = EFI_ACPI_6_3_GICC_AFFINITY;
>> + SratGiccAffinity[Count].ProximityDomain = CpuGetSubNumNode (Socket, Cpm);
>> + Count++;
>> + }
>> + NumNode++;
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +STATIC UINT32
>> +InstallGicItsAffinity (
>> + VOID *EntryPointer,
>> + UINT32 Index
>> + )
>> +{
>> + EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE *ItsAffinityEntryPointer = EntryPointer;
>> + UINTN Size;
>> +
>> + Size = sizeof (GicItsAffinityTemplate);
>> + CopyMem (ItsAffinityEntryPointer, &GicItsAffinityTemplate, Size);
>> + return Size;
>> +}
>> +
>> +STATIC
>> +EFI_STATUS
>> +SratAddGicItsAffinity (
>> + VOID *TmpPtr
>> + )
>> +{
>> + UINTN Size = 0;
>> + UINTN Index;
>> +
>> + /* Install Gic ITSAffinity */
>> + if (!IsSlaveSocketPresent ()) {
>> + for (Index = 0; Index <= 1; Index++) { /* RCA0/1 */
>> + GicItsAffinityTemplate.ItsId = Index;
>> + GicItsAffinityTemplate.ProximityDomain = 0;
>> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
>> + }
>> + }
>> +
>> + for (Index = SOCKET0_FIRST_RC; Index <= SOCKET0_LAST_RC; Index++) {
>> + GicItsAffinityTemplate.ItsId = Index;
>> + GicItsAffinityTemplate.ProximityDomain = 0;
>> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
>> + }
>> +
>> + if (IsSlaveSocketActive ()) {
>> + for (Index = SOCKET1_FIRST_RC; Index <= SOCKET1_LAST_RC; Index++) {
>> + GicItsAffinityTemplate.ItsId = Index;
>> + GicItsAffinityTemplate.ProximityDomain = 1;
>> + Size += InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Index);
>> + }
>> + }
>> +
>> + return EFI_SUCCESS;
>> +}
>> +
>> +EFI_STATUS
>> +AcpiInstallSratTable (
>> + VOID
>> + )
>> +{
>> + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
>> + EFI_STATUS Status;
>> + EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *SratTablePointer;
>> + UINT8 *TmpPtr;
>> + UINTN SratTableKey;
>> + UINTN Size;
>> +
>> + Status = gBS->LocateProtocol (
>> + &gEfiAcpiTableProtocolGuid,
>> + NULL,
>> + (VOID **)&AcpiTableProtocol
>> + );
>> + if (EFI_ERROR (Status)) {
>> + return Status;
>> + }
>> +
>> + Size = sizeof (SRATTableHeaderTemplate) +
>> + SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE) +
>> + GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE) +
>> + ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate));
>> + if (IsSlaveSocketActive ()) {
>> + Size += (SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsAffinityTemplate);
>> + } else if (!IsSlaveSocketPresent ()) {
>> + Size += 2 * sizeof (GicItsAffinityTemplate); /* RCA0/1 */
>> + }
>> +
>> + SratTablePointer = (EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER *)AllocateZeroPool (Size);
>> + if (SratTablePointer == NULL) {
>> + return EFI_OUT_OF_RESOURCES;
>> + }
>> + CopyMem ((VOID *)SratTablePointer, (VOID *)&SRATTableHeaderTemplate, sizeof (SRATTableHeaderTemplate));
>> +
>> + TmpPtr = (UINT8 *)SratTablePointer + sizeof (SRATTableHeaderTemplate);
>> + Status = SratAddMemAffinity ((EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *)TmpPtr);
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + TmpPtr += SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE);
>> + Status = SratAddGiccAffinity ((EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *)TmpPtr);
>> + ASSERT_EFI_ERROR (Status);
>> +
>> + TmpPtr += GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE);
>> + SratAddGicItsAffinity ((VOID *)(UINT64)TmpPtr);
>> + SratTablePointer->Header.Length = Size;
>> +
>> + AcpiTableChecksum (
>> + (UINT8 *)SratTablePointer,
>> + SratTablePointer->Header.Length
>> + );
>> +
>> + Status = AcpiTableProtocol->InstallAcpiTable (
>> + AcpiTableProtocol,
>> + (VOID *)SratTablePointer,
>> + SratTablePointer->Header.Length,
>> + &SratTableKey
>> + );
>> + FreePool ((VOID *)SratTablePointer);
>> +
>> + return Status;
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
>> new file mode 100755
>> index 000000000000..023509412f04
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S0.asi
>> @@ -0,0 +1,5639 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Device(C000) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x0)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x000, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x004, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x008, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x010, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x014, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x054, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x058, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 0, 0xFD, 2}
>> + }) // Domain 0
>> +}
>> +
>> +Device(C001) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x080, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x084, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x088, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x090, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x094, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 1, 0xFD, 2}
>> + }) // Domain 1
>> +}
>> +
>> +Device(C002) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x100, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x104, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x108, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x110, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x114, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x154, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x158, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 2, 0xFD, 2}
>> + }) // Domain 2
>> +}
>> +
>> +Device(C003) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x180, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x184, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x188, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x190, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x194, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 3, 0xFD, 2}
>> + }) // Domain 3
>> +}
>> +
>> +Device(C004) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x200, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x204, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x208, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x210, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x214, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x254, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x258, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 4, 0xFD, 2}
>> + }) // Domain 4
>> +}
>> +
>> +Device(C005) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x280, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x284, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x288, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x290, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x294, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 5, 0xFD, 2}
>> + }) // Domain 5
>> +}
>> +
>> +Device(C006) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x300, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x304, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x308, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x310, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x314, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x354, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x358, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 6, 0xFD, 2}
>> + }) // Domain 6
>> +}
>> +
>> +Device(C007) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x380, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x384, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x388, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x390, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x394, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 7, 0xFD, 2}
>> + }) // Domain 7
>> +}
>> +
>> +Device(C008) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x400, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x404, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x408, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x410, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x414, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x454, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x458, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 8, 0xFD, 2}
>> + }) // Domain 8
>> +}
>> +
>> +Device(C009) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x480, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x484, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x488, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x490, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x494, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 9, 0xFD, 2}
>> + }) // Domain 9
>> +}
>> +
>> +Device(C010) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x500, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x504, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x508, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x510, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x514, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x554, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x558, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 10, 0xFD, 2}
>> + }) // Domain 10
>> +}
>> +
>> +Device(C011) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x580, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x584, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x588, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x590, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x594, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 11, 0xFD, 2}
>> + }) // Domain 11
>> +}
>> +
>> +Device(C012) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x600, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x604, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x608, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x610, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x614, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x654, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x658, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 12, 0xFD, 2}
>> + }) // Domain 12
>> +}
>> +
>> +Device(C013) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x680, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x684, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x688, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x690, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x694, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 13, 0xFD, 2}
>> + }) // Domain 13
>> +}
>> +
>> +Device(C014) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x700, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x704, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x708, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x710, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x714, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x754, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x758, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 14, 0xFD, 2}
>> + }) // Domain 14
>> +}
>> +
>> +Device(C015) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x780, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x784, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x788, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x790, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x794, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 15, 0xFD, 2}
>> + }) // Domain 15
>> +}
>> +
>> +Device(C016) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x800, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x804, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x808, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x810, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x814, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x854, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x858, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 16, 0xFD, 2}
>> + }) // Domain 16
>> +}
>> +
>> +Device(C017) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x880, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x884, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x888, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x890, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x894, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 17, 0xFD, 2}
>> + }) // Domain 17
>> +}
>> +
>> +Device(C018) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x900, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x904, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x908, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x910, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x914, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x954, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x958, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 18, 0xFD, 2}
>> + }) // Domain 18
>> +}
>> +
>> +Device(C019) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x980, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x984, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x988, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x990, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x994, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 19, 0xFD, 2}
>> + }) // Domain 19
>> +}
>> +
>> +Device(C020) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xa00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 20, 0xFD, 2}
>> + }) // Domain 20
>> +}
>> +
>> +Device(C021) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xa01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 21, 0xFD, 2}
>> + }) // Domain 21
>> +}
>> +
>> +Device(C022) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xb00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 22, 0xFD, 2}
>> + }) // Domain 22
>> +}
>> +
>> +Device(C023) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xb01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 23, 0xFD, 2}
>> + }) // Domain 23
>> +}
>> +
>> +Device(C024) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xc00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 24, 0xFD, 2}
>> + }) // Domain 24
>> +}
>> +
>> +Device(C025) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xc01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 25, 0xFD, 2}
>> + }) // Domain 25
>> +}
>> +
>> +Device(C026) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xd00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 26, 0xFD, 2}
>> + }) // Domain 26
>> +}
>> +
>> +Device(C027) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xd01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 27, 0xFD, 2}
>> + }) // Domain 27
>> +}
>> +
>> +Device(C028) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xe00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 28, 0xFD, 2}
>> + }) // Domain 28
>> +}
>> +
>> +Device(C029) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xe01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 29, 0xFD, 2}
>> + }) // Domain 29
>> +}
>> +
>> +Device(C030) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xf00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 30, 0xFD, 2}
>> + }) // Domain 30
>> +}
>> +
>> +Device(C031) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0xf01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 31, 0xFD, 2}
>> + }) // Domain 31
>> +}
>> +
>> +Device(C032) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 32, 0xFD, 2}
>> + }) // Domain 32
>> +}
>> +
>> +Device(C033) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 33, 0xFD, 2}
>> + }) // Domain 33
>> +}
>> +
>> +Device(C034) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 34, 0xFD, 2}
>> + }) // Domain 34
>> +}
>> +
>> +Device(C035) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 35, 0xFD, 2}
>> + }) // Domain 35
>> +}
>> +
>> +Device(C036) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 36, 0xFD, 2}
>> + }) // Domain 36
>> +}
>> +
>> +Device(C037) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 37, 0xFD, 2}
>> + }) // Domain 37
>> +}
>> +
>> +Device(C038) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 38, 0xFD, 2}
>> + }) // Domain 38
>> +}
>> +
>> +Device(C039) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 39, 0xFD, 2}
>> + }) // Domain 39
>> +}
>> +
>> +Device(C040) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 40, 0xFD, 2}
>> + }) // Domain 40
>> +}
>> +
>> +Device(C041) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 41, 0xFD, 2}
>> + }) // Domain 41
>> +}
>> +
>> +Device(C042) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 42, 0xFD, 2}
>> + }) // Domain 42
>> +}
>> +
>> +Device(C043) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 43, 0xFD, 2}
>> + }) // Domain 43
>> +}
>> +
>> +Device(C044) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 44, 0xFD, 2}
>> + }) // Domain 44
>> +}
>> +
>> +Device(C045) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 45, 0xFD, 2}
>> + }) // Domain 45
>> +}
>> +
>> +Device(C046) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 46, 0xFD, 2}
>> + }) // Domain 46
>> +}
>> +
>> +Device(C047) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 47, 0xFD, 2}
>> + }) // Domain 47
>> +}
>> +
>> +Device(C048) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 48, 0xFD, 2}
>> + }) // Domain 48
>> +}
>> +
>> +Device(C049) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 49, 0xFD, 2}
>> + }) // Domain 49
>> +}
>> +
>> +Device(C050) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 50, 0xFD, 2}
>> + }) // Domain 50
>> +}
>> +
>> +Device(C051) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 51, 0xFD, 2}
>> + }) // Domain 51
>> +}
>> +
>> +Device(C052) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 52, 0xFD, 2}
>> + }) // Domain 52
>> +}
>> +
>> +Device(C053) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 53, 0xFD, 2}
>> + }) // Domain 53
>> +}
>> +
>> +Device(C054) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 54, 0xFD, 2}
>> + }) // Domain 54
>> +}
>> +
>> +Device(C055) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 55, 0xFD, 2}
>> + }) // Domain 5
>> +}
>> +
>> +Device(C056) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 56, 0xFD, 2}
>> + }) // Domain 56
>> +}
>> +
>> +Device(C057) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 57, 0xFD, 2}
>> + }) // Domain 57
>> +}
>> +
>> +Device(C058) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 58, 0xFD, 2}
>> + }) // Domain 58
>> +}
>> +
>> +Device(C059) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 59, 0xFD, 2}
>> + }) // Domain 59
>> +}
>> +
>> +Device(C060) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 60, 0xFD, 2}
>> + }) // Domain 60
>> +}
>> +
>> +Device(C061) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 61, 0xFD, 2}
>> + }) // Domain 61
>> +}
>> +
>> +Device(C062) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 62, 0xFD, 2}
>> + }) // Domain 62
>> +}
>> +
>> +Device(C063) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x1f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 63, 0xFD, 2}
>> + }) // Domain 63
>> +}
>> +
>> +Device(C064) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 64, 0xFD, 2}
>> + }) // Domain 64
>> +}
>> +
>> +Device(C065) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 65, 0xFD, 2}
>> + }) // Domain 65
>> +}
>> +
>> +Device(C066) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 66, 0xFD, 2}
>> + }) // Domain 66
>> +}
>> +
>> +Device(C067) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 67, 0xFD, 2}
>> + }) // Domain 67
>> +}
>> +
>> +Device(C068) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 68, 0xFD, 2}
>> + }) // Domain 68
>> +}
>> +
>> +Device(C069) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 69, 0xFD, 2}
>> + }) // Domain 69
>> +}
>> +
>> +Device(C070) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 70, 0xFD, 2}
>> + }) // Domain 70
>> +}
>> +
>> +Device(C071) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 71, 0xFD, 2}
>> + }) // Domain 71
>> +}
>> +
>> +Device(C072) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 72, 0xFD, 2}
>> + }) // Domain 72
>> +}
>> +
>> +Device(C073) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 73, 0xFD, 2}
>> + }) // Domain 73
>> +}
>> +
>> +Device(C074) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 74, 0xFD, 2}
>> + }) // Domain 74
>> +}
>> +
>> +Device(C075) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 75, 0xFD, 2}
>> + }) // Domain 75
>> +}
>> +
>> +Device(C076) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 76, 0xFD, 2}
>> + }) // Domain 76
>> +}
>> +
>> +Device(C077) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 77, 0xFD, 2}
>> + }) // Domain 77
>> +}
>> +
>> +Device(C078) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 78, 0xFD, 2}
>> + }) // Domain 78
>> +}
>> +
>> +Device(C079) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 79, 0xFD, 2}
>> + }) // Domain 79
>> +}
>> +
>> +Device(C080) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 80, 0xFD, 2}
>> + }) // Domain 80
>> +}
>> +
>> +Device(C081) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 81, 0xFD, 2}
>> + }) // Domain 81
>> +}
>> +
>> +Device(C082) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 82, 0xFD, 2}
>> + }) // Domain 82
>> +}
>> +
>> +Device(C083) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 83, 0xFD, 2}
>> + }) // Domain 83
>> +}
>> +
>> +Device(C084) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 84, 0xFD, 2}
>> + }) // Domain 84
>> +}
>> +
>> +Device(C085) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 85, 0xFD, 2}
>> + }) // Domain 85
>> +}
>> +
>> +Device(C086) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 86, 0xFD, 2}
>> + }) // Domain 86
>> +}
>> +
>> +Device(C087) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 87, 0xFD, 2}
>> + }) // Domain 87
>> +}
>> +
>> +Device(C088) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 88, 0xFD, 2}
>> + }) // Domain 88
>> +}
>> +
>> +Device(C089) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 89, 0xFD, 2}
>> + }) // Domain 89
>> +}
>> +
>> +Device(C090) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 90, 0xFD, 2}
>> + }) // Domain 90
>> +}
>> +
>> +Device(C091) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 91, 0xFD, 2}
>> + }) // Domain 91
>> +}
>> +
>> +Device(C092) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 92, 0xFD, 2}
>> + }) // Domain 92
>> +}
>> +
>> +Device(C093) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 93, 0xFD, 2}
>> + }) // Domain 93
>> +}
>> +
>> +Device(C094) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 94, 0xFD, 2}
>> + }) // Domain 94
>> +}
>> +
>> +Device(C095) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x2f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 95, 0xFD, 2}
>> + }) // Domain 95
>> +}
>> +
>> +Device(C096) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 96, 0xFD, 2}
>> + }) // Domain 96
>> +}
>> +
>> +Device(C097) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 97, 0xFD, 2}
>> + }) // Domain 97
>> +}
>> +
>> +Device(C098) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 98, 0xFD, 2}
>> + }) // Domain 98
>> +}
>> +
>> +Device(C099) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 99, 0xFD, 2}
>> + }) // Domain 99
>> +}
>> +
>> +Device(C100) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 100, 0xFD, 2}
>> + }) // Domain 100
>> +}
>> +
>> +Device(C101) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 101, 0xFD, 2}
>> + }) // Domain 101
>> +}
>> +
>> +Device(C102) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 102, 0xFD, 2}
>> + }) // Domain 102
>> +}
>> +
>> +Device(C103) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 103, 0xFD, 2}
>> + }) // Domain 103
>> +}
>> +
>> +Device(C104) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 104, 0xFD, 2}
>> + }) // Domain 104
>> +}
>> +
>> +Device(C105) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 105, 0xFD, 2}
>> + }) // Domain 105
>> +}
>> +
>> +Device(C106) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 106, 0xFD, 2}
>> + }) // Domain 106
>> +}
>> +
>> +Device(C107) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 107, 0xFD, 2}
>> + }) // Domain 107
>> +}
>> +
>> +Device(C108) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 108, 0xFD, 2}
>> + }) // Domain 108
>> +}
>> +
>> +Device(C109) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 109, 0xFD, 2}
>> + }) // Domain 109
>> +}
>> +
>> +Device(C110) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 110, 0xFD, 2}
>> + }) // Domain 110
>> +}
>> +
>> +Device(C111) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 111, 0xFD, 2}
>> + }) // Domain 111
>> +}
>> +
>> +Device(C112) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 112, 0xFD, 2}
>> + }) // Domain 112
>> +}
>> +
>> +Device(C113) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 113, 0xFD, 2}
>> + }) // Domain 113
>> +}
>> +
>> +Device(C114) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 114, 0xFD, 2}
>> + }) // Domain 114
>> +}
>> +
>> +Device(C115) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 115, 0xFD, 2}
>> + }) // Domain 115
>> +}
>> +
>> +Device(C116) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 116, 0xFD, 2}
>> + }) // Domain 116
>> +}
>> +
>> +Device(C117) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 117, 0xFD, 2}
>> + }) // Domain 117
>> +}
>> +
>> +Device(C118) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 118, 0xFD, 2}
>> + }) // Domain 118
>> +}
>> +
>> +Device(C119) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 119, 0xFD, 2}
>> + }) // Domain 119
>> +}
>> +
>> +Device(C120) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 120, 0xFD, 2}
>> + }) // Domain 120
>> +}
>> +
>> +Device(C121) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 121, 0xFD, 2}
>> + }) // Domain 121
>> +}
>> +
>> +Device(C122) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 122, 0xFD, 2}
>> + }) // Domain 122
>> +}
>> +
>> +Device(C123) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 123, 0xFD, 2}
>> + }) // Domain 123
>> +}
>> +
>> +Device(C124) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 124, 0xFD, 2}
>> + }) // Domain 124
>> +}
>> +
>> +Device(C125) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 125, 0xFD, 2}
>> + }) // Domain 125
>> +}
>> +
>> +Device(C126) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 126, 0xFD, 2}
>> + }) // Domain 126
>> +}
>> +
>> +Device(C127) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x3f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 127, 0xFD, 2}
>> + }) // Domain 127
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
>> new file mode 100755
>> index 000000000000..b3cc7a1b00e4
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU-S1.asi
>> @@ -0,0 +1,5639 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Device(C128) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x000, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x004, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x008, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x00c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x010, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x014, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x054, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x058, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 128, 0xFD, 2}
>> + }) // Domain 128
>> +}
>> +
>> +Device(C129) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x080, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x084, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x088, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x08c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x090, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x094, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x0d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 1219, 0xFD, 2}
>> + }) // Domain 129
>> +}
>> +
>> +Device(C130) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x100, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x104, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x108, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x110, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x114, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x154, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x158, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 130, 0xFD, 2}
>> + }) // Domain 130
>> +}
>> +
>> +Device(C131) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x180, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x184, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x188, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x190, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x194, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 131, 0xFD, 2}
>> + }) // Domain 131
>> +}
>> +
>> +Device(C132) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x200, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x204, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x208, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x210, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x214, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x254, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x258, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 132, 0xFD, 2}
>> + }) // Domain 132
>> +}
>> +
>> +Device(C133) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x280, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x284, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x288, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x290, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x294, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 133, 0xFD, 2}
>> + }) // Domain 133
>> +}
>> +
>> +Device(C134) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x300, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x304, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x308, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x310, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x314, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x354, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x358, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 134, 0xFD, 2}
>> + }) // Domain 134
>> +}
>> +
>> +Device(C135) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x380, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x384, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x388, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x390, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x394, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 135, 0xFD, 2}
>> + }) // Domain 135
>> +}
>> +
>> +Device(C136) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x400, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x404, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x408, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x40c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x410, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x414, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x454, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x458, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 136, 0xFD, 2}
>> + }) // Domain 136
>> +}
>> +
>> +Device(C137) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x480, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x484, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x488, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x48c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x490, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x494, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x4d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 137, 0xFD, 2}
>> + }) // Domain 137
>> +}
>> +
>> +Device(C138) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x500, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x504, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x508, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x50c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x510, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x514, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x554, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x558, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 138, 0xFD, 2}
>> + }) // Domain 138
>> +}
>> +
>> +Device(C139) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x580, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x584, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x588, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x58c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x590, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x594, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x5d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 139, 0xFD, 2}
>> + }) // Domain 139
>> +}
>> +
>> +Device(C140) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x600, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x604, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x608, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x60c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x610, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x614, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x654, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x658, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 140, 0xFD, 2}
>> + }) // Domain 140
>> +}
>> +
>> +Device(C141) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x680, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x684, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x688, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x68c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x690, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x694, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x6d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 141, 0xFD, 2}
>> + }) // Domain 141
>> +}
>> +
>> +Device(C142) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x700, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x704, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x708, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x70c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x710, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x714, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x754, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x758, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 142, 0xFD, 2}
>> + }) // Domain 142
>> +}
>> +
>> +Device(C143) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x780, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x784, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x788, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x78c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x790, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x794, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x7d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 143, 0xFD, 2}
>> + }) // Domain 143
>> +}
>> +
>> +Device(C144) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x800, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x804, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x808, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x80c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x810, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x814, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x854, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x858, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 144, 0xFD, 2}
>> + }) // Domain 144
>> +}
>> +
>> +Device(C145) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x880, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x884, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x888, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x88c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x890, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x894, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x8d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 145, 0xFD, 2}
>> + }) // Domain 145
>> +}
>> +
>> +Device(C146) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x900, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x904, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x908, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x90c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x910, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x914, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x954, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x958, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 146, 0xFD, 2}
>> + }) // Domain 146
>> +}
>> +
>> +Device(C147) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x980, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x984, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x988, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x98c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x990, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x994, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x9d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 147, 0xFD, 2}
>> + }) // Domain 147
>> +}
>> +
>> +Device(C148) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 148, 0xFD, 2}
>> + }) // Domain 148
>> +}
>> +
>> +Device(C149) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xa94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xad8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 149, 0xFD, 2}
>> + }) // Domain 149
>> +}
>> +
>> +Device(C150) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 150, 0xFD, 2}
>> + }) // Domain 150
>> +}
>> +
>> +Device(C151) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xb94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xbd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 151, 0xFD, 2}
>> + }) // Domain 151
>> +}
>> +
>> +Device(C152) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 152, 0xFD, 2}
>> + }) // Domain 152
>> +}
>> +
>> +Device(C153) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xc94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xcd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 153, 0xFD, 2}
>> + }) // Domain 153
>> +}
>> +
>> +Device(C154) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 154, 0xFD, 2}
>> + }) // Domain 154
>> +}
>> +
>> +Device(C155) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xd94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xdd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 155, 0xFD, 2}
>> + }) // Domain 155
>> +}
>> +
>> +Device(C156) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 156, 0xFD, 2}
>> + }) // Domain 156
>> +}
>> +
>> +Device(C157) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xe94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xed8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 157, 0xFD, 2}
>> + }) // Domain 157
>> +}
>> +
>> +Device(C158) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 158, 0xFD, 2}
>> + }) // Domain 158
>> +}
>> +
>> +Device(C159) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x10f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xf94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0xfd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 159, 0xFD, 2}
>> + }) // Domain 159
>> +}
>> +
>> +Device(C160) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1000, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1004, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1008, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x100c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1010, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1014, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1054, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1058, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 160, 0xFD, 2}
>> + }) // Domain 160
>> +}
>> +
>> +Device(C161) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1080, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1084, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1088, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x108c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1090, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1094, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x10d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 161, 0xFD, 2}
>> + }) // Domain 161
>> +}
>> +
>> +Device(C162) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1100, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1104, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1108, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x110c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1110, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1114, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1154, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1158, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 162, 0xFD, 2}
>> + }) // Domain 162
>> +}
>> +
>> +Device(C163) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1180, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1184, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1188, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x118c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1190, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1194, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x11d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 163, 0xFD, 2}
>> + }) // Domain 163
>> +}
>> +
>> +Device(C164) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1200, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1204, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1208, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x120c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1210, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1214, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1254, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1258, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 164, 0xFD, 2}
>> + }) // Domain 164
>> +}
>> +
>> +Device(C165) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1280, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1284, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1288, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x128c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1290, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1294, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x12d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 165, 0xFD, 2}
>> + }) // Domain 165
>> +}
>> +
>> +Device(C166) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1300, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1304, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1308, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x130c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1310, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1314, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1354, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1358, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 166, 0xFD, 2}
>> + }) // Domain 166
>> +}
>> +
>> +Device(C167) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1380, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1384, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1388, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x138c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1390, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1394, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x13d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 167, 0xFD, 2}
>> + }) // Domain 167
>> +}
>> +
>> +Device(C168) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1400, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1404, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1408, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x140c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1410, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1414, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1454, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1458, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 168, 0xFD, 2}
>> + }) // Domain 168
>> +}
>> +
>> +Device(C169) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1480, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1484, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1488, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x148c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1490, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1494, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x14d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 169, 0xFD, 2}
>> + }) // Domain 169
>> +}
>> +
>> +Device(C170) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1500, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1504, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1508, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x150c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1510, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1514, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1554, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1558, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 170, 0xFD, 2}
>> + }) // Domain 170
>> +}
>> +
>> +Device(C171) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1580, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1584, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1588, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x158c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1590, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1594, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x15d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 171, 0xFD, 2}
>> + }) // Domain 171
>> +}
>> +
>> +Device(C172) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1600, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1604, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1608, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x160c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1610, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1614, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1654, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1658, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 172, 0xFD, 2}
>> + }) // Domain 172
>> +}
>> +
>> +Device(C173) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1680, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1684, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1688, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x168c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1690, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1694, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x16d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 173, 0xFD, 2}
>> + }) // Domain 173
>> +}
>> +
>> +Device(C174) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1700, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1704, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1708, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x170c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1710, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1714, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1754, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1758, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 174, 0xFD, 2}
>> + }) // Domain 174
>> +}
>> +
>> +Device(C175) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1780, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1784, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1788, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x178c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1790, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1794, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x17d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 175, 0xFD, 2}
>> + }) // Domain 175
>> +}
>> +
>> +Device(C176) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1800, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1804, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1808, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x180c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1810, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1814, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1854, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1858, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 176, 0xFD, 2}
>> + }) // Domain 176
>> +}
>> +
>> +Device(C177) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1880, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1884, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1888, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x188c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1890, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1894, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x18d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 177, 0xFD, 2}
>> + }) // Domain 177
>> +}
>> +
>> +Device(C178) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1900, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1904, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1908, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x190c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1910, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1914, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1954, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1958, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 178, 0xFD, 2}
>> + }) // Domain 178
>> +}
>> +
>> +Device(C179) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1980, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1984, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1988, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x198c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1990, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1994, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x19d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 179, 0xFD, 2}
>> + }) // Domain 179
>> +}
>> +
>> +Device(C180) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 180, 0xFD, 2}
>> + }) // Domain 180
>> +}
>> +
>> +Device(C181) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1a94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 181, 0xFD, 2}
>> + }) // Domain 181
>> +}
>> +
>> +Device(C182) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 182, 0xFD, 2}
>> + }) // Domain 182
>> +}
>> +
>> +Device(C183) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1b94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 183, 0xFD, 2}
>> + }) // Domain 183
>> +}
>> +
>> +Device(C184) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 184, 0xFD, 2}
>> + }) // Domain 184
>> +}
>> +
>> +Device(C185) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1c94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 185, 0xFD, 2}
>> + }) // Domain 185
>> +}
>> +
>> +Device(C186) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 186, 0xFD, 2}
>> + }) // Domain 186
>> +}
>> +
>> +Device(C187) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1d94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 187, 0xFD, 2}
>> + }) // Domain 187
>> +}
>> +
>> +Device(C188) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 188, 0xFD, 2}
>> + }) // Domain 188
>> +}
>> +
>> +Device(C189) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1e94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 189, 0xFD, 2}
>> + }) // Domain 189
>> +}
>> +
>> +Device(C190) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 190, 0xFD, 2}
>> + }) // Domain 190
>> +}
>> +
>> +Device(C191) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x11f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1f94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 191, 0xFD, 2}
>> + }) // Domain 191
>> +}
>> +
>> +Device(C192) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2000, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2004, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2008, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x200c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2010, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2014, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2054, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2058, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 192, 0xFD, 2}
>> + }) // Domain 192
>> +}
>> +
>> +Device(C193) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2080, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2084, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2088, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x208c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2090, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2094, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x20d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 193, 0xFD, 2}
>> + }) // Domain 193
>> +}
>> +
>> +Device(C194) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2100, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2104, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2108, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x210c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2110, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2114, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2154, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2158, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 194, 0xFD, 2}
>> + }) // Domain 194
>> +}
>> +
>> +Device(C195) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2180, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2184, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2188, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x218c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2190, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2194, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x21d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 195, 0xFD, 2}
>> + }) // Domain 195
>> +}
>> +
>> +Device(C196) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2200, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2204, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2208, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x220c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2210, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2214, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2254, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2258, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 196, 0xFD, 2}
>> + }) // Domain 196
>> +}
>> +
>> +Device(C197) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2280, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2284, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2288, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x228c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2290, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2294, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x22d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 197, 0xFD, 2}
>> + }) // Domain 197
>> +}
>> +
>> +Device(C198) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2300, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2304, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2308, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x230c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2310, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2314, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2354, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2358, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 198, 0xFD, 2}
>> + }) // Domain 198
>> +}
>> +
>> +Device(C199) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2380, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2384, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2388, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x238c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2390, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2394, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x23d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 199, 0xFD, 2}
>> + }) // Domain 199
>> +}
>> +
>> +Device(C200) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2400, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2404, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2408, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x240c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2410, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2414, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2454, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2458, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 200, 0xFD, 2}
>> + }) // Domain 200
>> +}
>> +
>> +Device(C201) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2480, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2484, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2488, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x248c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2490, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2494, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x24d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 201, 0xFD, 2}
>> + }) // Domain 201
>> +}
>> +
>> +Device(C202) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2500, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2504, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2508, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x250c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2510, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2514, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2554, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2558, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 202, 0xFD, 2}
>> + }) // Domain 202
>> +}
>> +
>> +Device(C203) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2580, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2584, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2588, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x258c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2590, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2594, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x25d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 203, 0xFD, 2}
>> + }) // Domain 203
>> +}
>> +
>> +Device(C204) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2600, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2604, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2608, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x260c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2610, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2614, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2654, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2658, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 204, 0xFD, 2}
>> + }) // Domain 204
>> +}
>> +
>> +Device(C205) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2680, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2684, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2688, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x268c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2690, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2694, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x26d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 205, 0xFD, 2}
>> + }) // Domain 205
>> +}
>> +
>> +Device(C206) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2700, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2704, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2708, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x270c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2710, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2714, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2754, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2758, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 206, 0xFD, 2}
>> + }) // Domain 206
>> +}
>> +
>> +Device(C207) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2780, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2784, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2788, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x278c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2790, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2794, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x27d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 207, 0xFD, 2}
>> + }) // Domain 207
>> +}
>> +
>> +Device(C208) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2800, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2804, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2808, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x280c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2810, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2814, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2854, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2858, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 208, 0xFD, 2}
>> + }) // Domain 208
>> +}
>> +
>> +Device(C209) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2880, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2884, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2888, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x288c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2890, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2894, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x28d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 209, 0xFD, 2}
>> + }) // Domain 209
>> +}
>> +
>> +Device(C210) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2900, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2904, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2908, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x290c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2910, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2914, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2954, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2958, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 210, 0xFD, 2}
>> + }) // Domain 210
>> +}
>> +
>> +Device(C211) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2980, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2984, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2988, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x298c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2990, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2994, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x29d8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 211, 0xFD, 2}
>> + }) // Domain 211
>> +}
>> +
>> +Device(C212) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 212, 0xFD, 2}
>> + }) // Domain 212
>> +}
>> +
>> +Device(C213) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2a94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 213, 0xFD, 2}
>> + }) // Domain 213
>> +}
>> +
>> +Device(C214) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 214, 0xFD, 2}
>> + }) // Domain 214
>> +}
>> +
>> +Device(C215) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2b94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 215, 0xFD, 2}
>> + }) // Domain 215
>> +}
>> +
>> +Device(C216) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 216, 0xFD, 2}
>> + }) // Domain 216
>> +}
>> +
>> +Device(C217) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2c94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 217, 0xFD, 2}
>> + }) // Domain 217
>> +}
>> +
>> +Device(C218) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 218, 0xFD, 2}
>> + }) // Domain 218
>> +}
>> +
>> +Device(C219) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2d94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 219, 0xFD, 2}
>> + }) // Domain 219
>> +}
>> +
>> +Device(C220) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 220, 0xFD, 2}
>> + }) // Domain 220
>> +}
>> +
>> +Device(C221) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2e94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 221, 0xFD, 2}
>> + }) // Domain 221
>> +}
>> +
>> +Device(C222) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f00, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f04, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f08, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f0c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f10, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f14, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f54, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f58, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 222, 0xFD, 2}
>> + }) // Domain 222
>> +}
>> +
>> +Device(C223) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x12f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f80, 17)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f84, 17)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f88, 17)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f8c, 17)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f90, 17)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2f94, 17)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 17)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 17)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 17)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd4, 17)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd8, 17)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 223, 0xFD, 2}
>> + }) // Domain 223
>> +}
>> +
>> +Device(C224) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13000)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3000, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3004, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3008, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x300c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3010, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3014, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3054, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3058, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 224, 0xFD, 2}
>> + }) // Domain 224
>> +}
>> +
>> +Device(C225) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13001)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3080, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3084, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3088, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x308c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3090, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3094, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x30d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 225, 0xFD, 2}
>> + }) // Domain 225
>> +}
>> +
>> +Device(C226) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13100)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3100, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3104, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3108, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x310c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3110, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3114, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3154, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3158, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 226, 0xFD, 2}
>> + }) // Domain 226
>> +}
>> +
>> +Device(C227) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13101)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3180, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3184, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3188, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x318c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3190, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3194, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x31d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 227, 0xFD, 2}
>> + }) // Domain 227
>> +}
>> +
>> +Device(C228) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13200)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3200, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3204, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3208, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x320c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3210, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3214, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3254, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3258, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 228, 0xFD, 2}
>> + }) // Domain 228
>> +}
>> +
>> +Device(C229) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13201)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3280, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3284, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3288, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x328c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3290, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3294, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x32d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 229, 0xFD, 2}
>> + }) // Domain 229
>> +}
>> +
>> +Device(C230) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13300)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3300, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3304, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3308, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x330c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3310, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3314, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3354, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3358, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 230, 0xFD, 2}
>> + }) // Domain 230
>> +}
>> +
>> +Device(C231) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13301)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3380, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3384, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3388, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x338c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3390, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3394, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x33d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 231, 0xFD, 2}
>> + }) // Domain 231
>> +}
>> +
>> +Device(C232) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13400)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3400, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3404, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3408, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x340c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3410, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3414, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3454, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3458, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 232, 0xFD, 2}
>> + }) // Domain 232
>> +}
>> +
>> +Device(C233) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13401)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3480, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3484, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3488, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x348c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3490, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3494, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x34d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 233, 0xFD, 2}
>> + }) // Domain 233
>> +}
>> +
>> +Device(C234) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13500)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3500, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3504, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3508, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x350c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3510, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3514, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3554, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3558, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 234, 0xFD, 2}
>> + }) // Domain 234
>> +}
>> +
>> +Device(C235) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13501)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3580, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3584, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3588, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x358c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3590, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3594, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x35d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 235, 0xFD, 2}
>> + }) // Domain 235
>> +}
>> +
>> +Device(C236) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13600)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3600, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3604, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3608, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x360c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3610, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3614, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3654, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3658, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 236, 0xFD, 2}
>> + }) // Domain 236
>> +}
>> +
>> +Device(C237) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13601)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3680, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3684, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3688, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x368c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3690, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3694, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x36d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 237, 0xFD, 2}
>> + }) // Domain 237
>> +}
>> +
>> +Device(C238) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13700)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3700, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3704, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3708, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x370c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3710, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3714, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3754, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3758, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 238, 0xFD, 2}
>> + }) // Domain 238
>> +}
>> +
>> +Device(C239) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13701)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3780, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3784, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3788, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x378c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3790, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3794, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x37d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 239, 0xFD, 2}
>> + }) // Domain 239
>> +}
>> +
>> +Device(C240) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13800)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3800, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3804, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3808, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x380c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3810, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3814, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3854, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3858, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 240, 0xFD, 2}
>> + }) // Domain 240
>> +}
>> +
>> +Device(C241) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13801)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3880, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3884, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3888, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x388c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3890, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3894, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x38d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 241, 0xFD, 2}
>> + }) // Domain 241
>> +}
>> +
>> +Device(C242) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13900)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3900, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3904, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3908, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x390c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3910, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3914, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3954, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3958, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 242, 0xFD, 2}
>> + }) // Domain 242
>> +}
>> +
>> +Device(C243) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13901)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3980, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3984, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3988, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x398c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3990, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3994, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x39d8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 243, 0xFD, 2}
>> + }) // Domain 243
>> +}
>> +
>> +Device(C244) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13a00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 244, 0xFD, 2}
>> + }) // Domain 244
>> +}
>> +
>> +Device(C245) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13a01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3a94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 245, 0xFD, 2}
>> + }) // Domain 245
>> +}
>> +
>> +Device(C246) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13b00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 246, 0xFD, 2}
>> + }) // Domain 246
>> +}
>> +
>> +Device(C247) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13b01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3b94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 247, 0xFD, 2}
>> + }) // Domain 247
>> +}
>> +
>> +Device(C248) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13c00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 248, 0xFD, 2}
>> + }) // Domain 248
>> +}
>> +
>> +Device(C249) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13c01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3c94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 249, 0xFD, 2}
>> + }) // Domain 249
>> +}
>> +
>> +Device(C250) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13d00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 250, 0xFD, 2}
>> + }) // Domain 250
>> +}
>> +
>> +Device(C251) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13d01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3d94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 251, 0xFD, 2}
>> + }) // Domain 251
>> +}
>> +
>> +Device(C252) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13e00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 252, 0xFD, 2}
>> + }) // Domain 252
>> +}
>> +
>> +Device(C253) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13e01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3e94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 253, 0xFD, 2}
>> + }) // Domain 253
>> +}
>> +
>> +Device(C254) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13f00)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f00, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f04, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f08, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f0c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f10, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f14, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f54, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f58, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package() {
>> + Package() {5, 0, 254, 0xFD, 2}
>> + }) // Domain 254
>> +}
>> +
>> +Device(C255) {
>> + Name(_HID, "ACPI0007")
>> + Name(_UID, 0x13f01)
>> +
>> + Method (_LPI, 0, NotSerialized) {
>> + return(PLPI)
>> + }
>> +
>> + Name(PCPC, Package() {
>> + 23, // NumEntries
>> + 3, // Revision
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f80, 2)}, // Highest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f84, 2)}, // Nominal Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f88, 2)}, // Lowest Nonlinear Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f8c, 2)}, // Lowest Performance
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f90, 2)}, // Guaranteed Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3f94, 2)}, // Desired Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Minimum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Maximum Performance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Reduction Tolerance Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter Wraparound Time
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Reference Counter Register
>> + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Delivered Counter Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Performance Limited Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Selection Enable
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonomous Activity Window Register
>> + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy Performance Preference Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Reference Performance Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd4, 2)}, // Lowest Frequency Register
>> + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd8, 2)}, // Nominal Frequency Register
>> + })
>> + If (LEqual(CPCE, 0x1)) {
>> + Method (_CPC, 0, NotSerialized) {
>> + return(PCPC)
>> + }
>> + }
>> + //Performance State dependency
>> + Name(_PSD, Package(){
>> + Package() {5, 0, 255, 0xFD, 2}
>> + }) // Domain 255
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/CPU.asi b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
>> new file mode 100755
>> index 000000000000..00c09340b957
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/CPU.asi
>> @@ -0,0 +1,127 @@
>> +/** @file
>> +
>> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Name (CPCE, 1) // CPPC Enable
>> +Name (LPIE, 0) // LPI Enable
>> +
>> +Method (_OSC, 4, Serialized) { // _OSC: Operating System Capabilities
>> + CreateDWordField (Arg3, 0x00, STS0)
>> + CreateDWordField (Arg3, 0x04, CAP0)
>> + If (LEqual(Arg0, ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48")) /* Platform-wide Capabilities */) {
>> + If (LNotEqual(Arg1, One)) {
>> + And(STS0, 0xFFFFFFE0, STS0)
>> + Or(STS0, 0x0A, STS0) // Unrecognized Revision, OSC failure
>> + } Else {
>> + If (LEqual(And(CAP0, 0x100), 0x100)) {
>> + And(CAP0, 0xFFFFFEFF, CAP0) // No support for OS Initiated LPI
>> + And(STS0, 0xFFFFFFE0, STS0)
>> + Or(STS0, 0x12, STS0)
>> + }
>> + If (LEqual(LPIE, 0x1)) {
>> + Or(CAP0, 0x80, CAP0) // Support for LPI
>> + } Else {
>> + And(CAP0, 0xFFFFFF7F, CAP0) // No support for LPI
>> + }
>> + If (LEqual(CPCE, 0x1)) {
>> + Or(CAP0, 0x40, CAP0) // Support for CPPCv2
>> + } Else {
>> + And(CAP0, 0xFFFFFFBF, CAP0) // No support for CPPCv2
>> + }
>> + }
>> + } Else {
>> + And(STS0, 0xFFFFFFE0, STS0)
>> + Or(STS0, 0x06, STS0) // Unrecognized Revision, Unrecognized UUID
>> + }
>> + Return (Arg3)
>> +}
>> +
>> +Name(PLPI, Package() {
>> + 0, // Version
>> + 1, // Level Index
>> + 2, // Count
>> + // WFI for CPU (NS-WFI)
>> + Package() {
>> + 1, // Min residency (uS)
>> + 1, // Wake latency (uS)
>> + 1, // Flags
>> + 0, // Arch Context Flags
>> + 100, // Residency Counter Frequency
>> + 0, // No parent state
>> + ResourceTemplate () {
>> + // Register Entry method
>> + Register (FFixedHW,
>> + 0x20, // Bit Width
>> + 0x00, // Bit Offset
>> + 0xFFFFFFFF, // Address
>> + 0x03, // Access Size
>> + )
>> + },
>> + ResourceTemplate() { // Null Residency Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + ResourceTemplate() { // Null Usage Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + "Standby",
>> + },
>> + // Retention state for CPU (S-WFI)
>> + Package() {
>> + 2, // Min residency (uS)
>> + 2, // Wake latency (uS)
>> + 1, // Flags
>> + 0, // Arch Context Flags
>> + 100, // Residency Counter Frequency
>> + 1, // Parent node can be in Standby states
>> + ResourceTemplate () {
>> + // Register Entry method
>> + Register (FFixedHW,
>> + 0x20, // Bit Width
>> + 0x00, // Bit Offset
>> + 0x00000001, // Address
>> + 0x03, // Access Size
>> + )
>> + },
>> + ResourceTemplate() { // Null Residency Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + ResourceTemplate() { // Null Usage Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + "Standby_ATF"
>> + },
>> +})
>> +
>> +Device (SYST) { // System state
>> + Name(_HID, "ACPI0010")
>> + Name(_UID, 1)
>> + Name (_LPI, Package() {
>> + 0, // Version
>> + 0, // Level Index
>> + 1, // Count
>> + // Retention state for Cluster
>> + Package() {
>> + 100, // Min residency (uS)
>> + 100, // Wake latency (uS)
>> + 1, // Flags
>> + 0, // Arch Context Flags
>> + 100, // Residency Counter Frequency
>> + 0, // No Parent State
>> + 0x02000100, // Integer Entry method
>> + ResourceTemplate() { // Null Residency Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + ResourceTemplate() { // Null Usage Counter
>> + Register (SystemMemory, 0, 0, 0, 0)
>> + },
>> + "Standby"
>> + },
>> + })
>> +
>> + Include ("CPU-S0.asi")
>> + Include ("CPU-S1.asi")
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
>> new file mode 100755
>> index 000000000000..b9e2da79b5ef
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl
>> @@ -0,0 +1,575 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +DefinitionBlock("Dsdt.aml", "DSDT", 0x02, "Ampere", "Jade", 1) {
>> + //
>> + // Board Model
>> + Name(\BDMD, "Jade Board")
>> + Name(TPMF, 0) // TPM presence
>> + Name(AERF, 0) // PCIe AER Firmware-First
>> + Scope(\_SB) {
>> +
>> + Include ("CPU.asi")
>> + Include ("PMU.asi")
>> +
>> + //
>> + // Hardware Monitor
>> + Device(HM00) {
>> + Name(_HID, "APMC0D29")
>> + Name(_UID, "HWM0")
>> + Name(_DDN, "HWM0")
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Hardware Monitor Device"))
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xF)
>> + }
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package() {
>> + Package() {"pcc-channel", 14}
>> + }
>> + })
>> + }
>> +
>> + //
>> + // Hardware Monitor
>> + Device(HM01) {
>> + Name(_HID, "APMC0D29")
>> + Name(_UID, "HWM1")
>> + Name(_DDN, "HWM1")
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Hardware Monitor Device"))
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xF)
>> + }
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package() {
>> + Package() {"pcc-channel", 29}
>> + }
>> + })
>> + }
>> +
>> + //
>> + // Hardware Monitor
>> + Device(HM02) {
>> + Name(_HID, "AMPC0005")
>> + Name(_UID, "HWM2")
>> + Name(_DDN, "HWM2")
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xF)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000088900000, // AddressMinimum - MIN
>> + 0x000000008891FFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000020000 // RangeLength - LEN
>> + )
>> + })
>> + }
>> +
>> + //
>> + // Hardware Monitor
>> + Device(HM03) {
>> + Name(_HID, "AMPC0005")
>> + Name(_UID, "HWM3")
>> + Name(_DDN, "HWM3")
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("AC01 SoC Hardware Monitor Device"))
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xF)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000088920000, // AddressMinimum - MIN
>> + 0x000000008893FFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000020000 // RangeLength - LEN
>> + )
>> + })
>> + }
>> +
>> + //
>> + // DesignWare I2C on AHBC bus
>> + Device(I2C4) {
>> + Name(_HID, "APMC0D0F")
>> + Name(_UID, 4)
>> + Name(_STR, Unicode("Altra I2C Device"))
>> + Method(_STA, 0, NotSerialized) {
>> + return (0x0f)
>> + }
>> + Name(_CCA, ONE)
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00001000026B0000, // AddressMinimum - MIN
>> + 0x00001000026BFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000010000 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 105 }
>> + })
>> + Device (IPI) {
>> + Name(_HID, "AMPC0004")
>> + Name(_CID, "IPI0001")
>> + Name(_STR, Unicode("IPMI_SSIF"))
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Method(_IFT) {
>> + Return(0x04) // IPMI SSIF
>> + }
>> + Method(_ADR) {
>> + Return(0x10) // SSIF slave address
>> + }
>> + Method(_SRV) {
>> + Return(0x0200) // IPMI Specification Revision
>> + }
>> + Name(_CRS, ResourceTemplate ()
>> + {
>> + I2cSerialBus (0x0010, ControllerInitiated, 0x00061A80,
>> + AddressingMode7Bit, "\\_SB.I2C4",
>> + 0x00, ResourceConsumer,,
>> + )
>> + })
>> + }
>> + Name(SSCN, Package() { 0x3E2, 0x47D, 0 })
>> + Name(FMCN, Package() { 0xA4, 0x13F, 0 })
>> + }
>> +
>> + //
>> + // Report APEI Errors to GHES via SCI notification.
>> + // SCI notification requires one GED and one HED Device
>> + // GED = Generic Event Device (ACPI0013)
>> + // HED = Hardware Error Device (PNP0C33)
>> + //
>> + Device(GED0) {
>> + Name(_HID, "ACPI0013")
>> + Name(_UID, Zero)
>> + Method(_STA) {
>> + Return (0xF)
>> + }
>> + Name(_CRS, ResourceTemplate () {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 84 } // GHES
>> + })
>> + Method(_EVT, 1, Serialized) {
>> + Switch (ToInteger(Arg0)) {
>> + Case (84) { // GHES interrupt
>> + Notify (HED0, 0x80)
>> + }
>> + }
>> + }
>> + }
>> +
>> + // Shutdown button using GED.
>> + Device(GED1) {
>> + Name(_HID, "ACPI0013")
>> + Name(_CID, "ACPI0013")
>> + Name(_UID, One)
>> + Method(_STA) {
>> + Return (0xF)
>> + }
>> + Name(_CRS, ResourceTemplate () {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 327 }
>> + })
>> + OperationRegion(PDDR, SystemMemory, 0x1000027B0004, 4)
>> + Field(PDDR, DWordAcc, NoLock, Preserve) {
>> + STDI, 8
>> + }
>> +
>> + OperationRegion(INTE, SystemMemory, 0x1000027B0030, 4)
>> + Field(INTE, DWordAcc, NoLock, Preserve) {
>> + STDE, 8
>> + }
>> +
>> + OperationRegion(INTT, SystemMemory, 0x1000027B0034, 4)
>> + Field(INTT, DWordAcc, NoLock, Preserve) {
>> + TYPE, 8
>> + }
>> +
>> + OperationRegion(INTP, SystemMemory, 0x1000027B0038, 4)
>> + Field(INTP, DWordAcc, NoLock, Preserve) {
>> + POLA, 8
>> + }
>> +
>> + OperationRegion(INTS, SystemMemory, 0x1000027B003c, 4)
>> + Field(INTS, DWordAcc, NoLock, Preserve) {
>> + STDS, 8
>> + }
>> +
>> + OperationRegion(INTC, SystemMemory, 0x1000027B0040, 4)
>> + Field(INTC, DWordAcc, NoLock, Preserve) {
>> + SINT, 8
>> + }
>> +
>> + OperationRegion(INTM, SystemMemory, 0x1000027B0044, 4)
>> + Field(INTM, DWordAcc, NoLock, Preserve) {
>> + MASK, 8
>> + }
>> +
>> + Method(_INI, 0, NotSerialized) {
>> + // Set level type, low active (shutdown)
>> + Store (0x00, TYPE)
>> + Store (0x00, POLA)
>> + // Set Input type (shutdown)
>> + Store (0x00, STDI)
>> + // Enable interrupt (shutdown)
>> + Store (0x80, STDE)
>> + // Unmask the interrupt.
>> + Store (0x00, MASK)
>> + }
>> + Method(_EVT, 1, Serialized) {
>> + Switch (ToInteger(Arg0)) {
>> + Case (327) {
>> + if (And (STDS, 0x80)) {
>> + //Clear the interrupt.
>> + Store (0x80, SINT)
>> + // Notify OSPM the power button is pressed
>> + Notify (\_SB.PWRB, 0x80)
>> + }
>> + }
>> + }
>> + }
>> + }
>> +
>> + // Power button device description
>> + Device(PWRB) {
>> + Name(_HID, EISAID("PNP0C0C"))
>> + Name(_ADR, 0)
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Method(_STA, 0, Notserialized) {
>> + Return (0x0b)
>> + }
>> + }
>> +
>> + //
>> + // UART0 PL011
>> + Device(URT0) {
>> + Name(_HID, "ARMH0011")
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Method(_STA, 0, NotSerialized) {
>> + return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000100002600000, // AddressMinimum - MIN
>> + 0x0000100002600FFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000001000 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 98 }
>> + })
>> + } // UART0
>> +
>> + //
>> + // UART2 PL011
>> + Device(URT2) {
>> + Name(_HID, "ARMH0011")
>> + Name(_UID, 1)
>> + Name(_CCA, ONE)
>> + Method(_STA, 0, NotSerialized) {
>> + return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000100002620000, // AddressMinimum - MIN
>> + 0x0000100002620FFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000001000 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 100 }
>> + })
>> + } // UART1
>> +
>> + Device(HED0)
>> + {
>> + Name(_HID, EISAID("PNP0C33"))
>> + Name(_UID, Zero)
>> + }
>> +
>> + Device(NVDR) {
>> + Name(_HID, "ACPI0012")
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xf)
>> + }
>> + Method (_DSM, 0x4, Serialized) {
>> + // Not support any functions for now
>> + Return (Buffer() {0})
>> + }
>> + Device (NVD1) {
>> + Name(_ADR, 0x0330)
>> + Name(SMRT, Buffer(13) {0})
>> + CreateDWordField(SMRT, 0, BSTA)
>> + CreateWordField(SMRT, 4, BHTH)
>> + CreateWordField(SMRT, 6, BTMP)
>> + CreateByteField(SMRT, 8, BETH)
>> + CreateByteField(SMRT, 9, BWTH)
>> + CreateByteField(SMRT, 10, BNLF)
>> + OperationRegion(BUF1, SystemMemory, 0x88980000, 16)
>> + Field (BUF1, DWordAcc, NoLock, Preserve) {
>> + STAT, 32, //Status
>> + HLTH, 16, //Module Health
>> + CTMP, 16, //Module Current Status
>> + ETHS, 8, //Error Threshold Status
>> + WTHS, 8, //Warning Threshold Status
>> + NVLF, 8, //NVM Lifetime
>> + , 40 //Reserve
>> + }
>> + Method (_DSM, 0x4, Serialized) {
>> + //Accept only MSF Family type NVDIMM DSM functions
>> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
>> + //Handle Func 0 query implemented commands
>> + If(LEqual(Arg2, 0)) {
>> + //Check revision and returned proper implemented commands
>> + //Support only health check for now
>> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
>> + }
>> + //Handle MSF DSM Func 11 Get Smart and Health Info
>> + If(LEqual(Arg2, 11)) {
>> + Store(\_SB.NVDR.NVD1.STAT, BSTA)
>> + Store(\_SB.NVDR.NVD1.HLTH, BHTH)
>> + Store(\_SB.NVDR.NVD1.CTMP, BTMP)
>> + Store(\_SB.NVDR.NVD1.ETHS, BETH)
>> + Store(\_SB.NVDR.NVD1.WTHS, BWTH)
>> + Store(\_SB.NVDR.NVD1.NVLF, BNLF)
>> + Return (SMRT)
>> + }
>> + }
>> + Return (Buffer() {0})
>> + }
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xf)
>> + }
>> + }
>> + Device (NVD2) {
>> + Name(_ADR, 0x0770)
>> + Name(SMRT, Buffer(13) {0})
>> + CreateDWordField(SMRT, 0, BSTA)
>> + CreateWordField(SMRT, 4, BHTH)
>> + CreateWordField(SMRT, 6, BTMP)
>> + CreateByteField(SMRT, 8, BETH)
>> + CreateByteField(SMRT, 9, BWTH)
>> + CreateByteField(SMRT, 10, BNLF)
>> + OperationRegion(BUF1, SystemMemory, 0x88988000, 16)
>> + Field (BUF1, DWordAcc, NoLock, Preserve) {
>> + STAT, 32, //Status
>> + HLTH, 16, //Module Health
>> + CTMP, 16, //Module Current Status
>> + ETHS, 8, //Error Threshold Status
>> + WTHS, 8, //Warning Threshold Status
>> + NVLF, 8, //NVM Lifetime
>> + , 40 //Reserve
>> + }
>> + Method (_DSM, 0x4, Serialized) {
>> + //Accept only MSF Family type NVDIMM DSM functions
>> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
>> + //Handle Func 0 query implemented commands
>> + If(LEqual(Arg2, 0)) {
>> + //Check revision and returned proper implemented commands
>> + //Support only health check for now
>> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
>> + }
>> + //Handle MSF DSM Func 11 Get Smart and Health Info
>> + If(LEqual(Arg2, 11)) {
>> + Store(\_SB.NVDR.NVD2.STAT, BSTA)
>> + Store(\_SB.NVDR.NVD2.HLTH, BHTH)
>> + Store(\_SB.NVDR.NVD2.CTMP, BTMP)
>> + Store(\_SB.NVDR.NVD2.ETHS, BETH)
>> + Store(\_SB.NVDR.NVD2.WTHS, BWTH)
>> + Store(\_SB.NVDR.NVD2.NVLF, BNLF)
>> + Return (SMRT)
>> + }
>> + }
>> + Return (Buffer() {0})
>> + }
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xf)
>> + }
>> + }
>> + Device (NVD3) {
>> + Name(_ADR, 0x1330)
>> + Name(SMRT, Buffer(13) {0})
>> + CreateDWordField(SMRT, 0, BSTA)
>> + CreateWordField(SMRT, 4, BHTH)
>> + CreateWordField(SMRT, 6, BTMP)
>> + CreateByteField(SMRT, 8, BETH)
>> + CreateByteField(SMRT, 9, BWTH)
>> + CreateByteField(SMRT, 10, BNLF)
>> + OperationRegion(BUF1, SystemMemory, 0xC0080000, 16)
>> + Field (BUF1, DWordAcc, NoLock, Preserve) {
>> + STAT, 32, //Status
>> + HLTH, 16, //Module Health
>> + CTMP, 16, //Module Current Status
>> + ETHS, 8, //Error Threshold Status
>> + WTHS, 8, //Warning Threshold Status
>> + NVLF, 8, //NVM Lifetime
>> + , 40 //Reserve
>> + }
>> + Method (_DSM, 0x4, Serialized) {
>> + //Accept only MSF Family type NVDIMM DSM functions
>> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
>> + //Handle Func 0 query implemented commands
>> + If(LEqual(Arg2, 0)) {
>> + //Check revision and returned proper implemented commands
>> + //Support only health check for now
>> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
>> + }
>> + //Handle MSF DSM Func 11 Get Smart and Health Info
>> + If(LEqual(Arg2, 11)) {
>> + Store(\_SB.NVDR.NVD3.STAT, BSTA)
>> + Store(\_SB.NVDR.NVD3.HLTH, BHTH)
>> + Store(\_SB.NVDR.NVD3.CTMP, BTMP)
>> + Store(\_SB.NVDR.NVD3.ETHS, BETH)
>> + Store(\_SB.NVDR.NVD3.WTHS, BWTH)
>> + Store(\_SB.NVDR.NVD3.NVLF, BNLF)
>> + Return (SMRT)
>> + }
>> + }
>> + Return (Buffer() {0})
>> + }
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xf)
>> + }
>> + }
>> + Device (NVD4) {
>> + Name(_ADR, 0x1770)
>> + Name(SMRT, Buffer(13) {0})
>> + CreateDWordField(SMRT, 0, BSTA)
>> + CreateWordField(SMRT, 4, BHTH)
>> + CreateWordField(SMRT, 6, BTMP)
>> + CreateByteField(SMRT, 8, BETH)
>> + CreateByteField(SMRT, 9, BWTH)
>> + CreateByteField(SMRT, 10, BNLF)
>> + OperationRegion(BUF1, SystemMemory, 0xC0088000, 16)
>> + Field (BUF1, DWordAcc, NoLock, Preserve) {
>> + STAT, 32, //Status
>> + HLTH, 16, //Module Health
>> + CTMP, 16, //Module Current Status
>> + ETHS, 8, //Error Threshold Status
>> + WTHS, 8, //Warning Threshold Status
>> + NVLF, 8, //NVM Lifetime
>> + , 40 //Reserve
>> + }
>> + Method (_DSM, 0x4, Serialized) {
>> + //Accept only MSF Family type NVDIMM DSM functions
>> + If(LEqual(Arg0, ToUUID ("1ee68b36-d4bd-4a1a-9a16-4f8e53d46e05"))) {
>> + //Handle Func 0 query implemented commands
>> + If(LEqual(Arg2, 0)) {
>> + //Check revision and returned proper implemented commands
>> + //Support only health check for now
>> + Return (Buffer() {0x01, 0x08}) //Byte 0: 0x1
>> + }
>> + //Handle MSF DSM Func 11 Get Smart and Health Info
>> + If(LEqual(Arg2, 11)) {
>> + Store(\_SB.NVDR.NVD4.STAT, BSTA)
>> + Store(\_SB.NVDR.NVD4.HLTH, BHTH)
>> + Store(\_SB.NVDR.NVD4.CTMP, BTMP)
>> + Store(\_SB.NVDR.NVD4.ETHS, BETH)
>> + Store(\_SB.NVDR.NVD4.WTHS, BWTH)
>> + Store(\_SB.NVDR.NVD4.NVLF, BNLF)
>> + Return (SMRT)
>> + }
>> + }
>> + Return (Buffer() {0})
>> + }
>> + Method(_STA, 0, NotSerialized) {
>> + return (0xf)
>> + }
>> + }
>> + }
>> +
>> + Device (TPM0) {
>> + //
>> + // TPM 2.0
>> + //
>> +
>> + //
>> + // TAG for patching TPM2.0 _HID
>> + //
>> + Name (_HID, "NNNN0000")
>> + Name (_CID, "MSFT0101")
>> + Name (_UID, 0)
>> +
>> + Name (CRBB, 0x10000000)
>> + Name (CRBL, 0x10000000)
>> +
>> + Name (RBUF, ResourceTemplate () {
>> + Memory32Fixed (ReadWrite, 0x88500000, 0x1000, PCRE)
>> + })
>> +
>> + Method (_CRS, 0x0, Serialized) {
>> + // Declare fields in PCRE
>> + CreateDWordField(RBUF, ^PCRE._BAS, BASE)
>> + CreateDWordField(RBUF, ^PCRE._LEN, LENG)
>> +
>> + // Store updatable values into them
>> + Store(CRBB, BASE)
>> + Store(CRBL, LENG)
>> +
>> + Return (RBUF)
>> + }
>> +
>> + Method (_STR,0) {
>> + Return (Unicode ("TPM 2.0 Device"))
>> + }
>> +
>> + Method (_STA, 0) {
>> + if (TPMF) {
>> + Return (0x0f) //Enable resources
>> + }
>> + Return (0x0)
>> + }
>> + }
>> +
>> + Include ("PCI-S0.Rca01.asi")
>> + Include ("PCI-S0.asi")
>> + Include ("PCI-S1.asi")
>> + Include ("PCI-PDRC.asi")
>> + }
>> +} // DSDT
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
>> new file mode 100644
>> index 000000000000..16c00c35e3fe
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-PDRC.asi
>> @@ -0,0 +1,217 @@
>> +/** @file
>> +
>> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> + // Motherboard resource consumption for PCIE resource reservation
>> + // as upstream discussion "ACPI namespace details for ARM64"
>> + Device (PDRC) {
>> + Name (_HID, EISAID("PNP0C02"))
>> + Name (_UID, 1)
>> + // S0 Start here
>> + Name (PDRS, ResourceTemplate() {
>> + QWordMemory ( // PCIE0 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00003BFFF0000000, // AddressMinimum - MIN
>> + 0x00003BFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE1 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00003FFFF0000000, // AddressMinimum - MIN
>> + 0x00003FFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE2 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000023FFF0000000, // AddressMinimum - MIN
>> + 0x000023FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE3 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000027FFF0000000, // AddressMinimum - MIN
>> + 0x000027FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE4 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00002BFFF0000000, // AddressMinimum - MIN
>> + 0x00002BFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE5 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00002FFFF0000000, // AddressMinimum - MIN
>> + 0x00002FFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + // S1 Start here
>> + QWordMemory ( // PCIE6 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00007BFFF0000000, // AddressMinimum - MIN
>> + 0x00007BFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE7 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00007FFFF0000000, // AddressMinimum - MIN
>> + 0x00007FFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE8 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000063FFF0000000, // AddressMinimum - MIN
>> + 0x000063FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIE9 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000067FFF0000000, // AddressMinimum - MIN
>> + 0x000067FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> + QWordMemory ( // PCIEA 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00006BFFF0000000, // AddressMinimum - MIN
>> + 0x00006BFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIEB 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00006FFFF0000000, // AddressMinimum - MIN
>> + 0x00006FFFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIEC 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000033FFF0000000, // AddressMinimum - MIN
>> + 0x000033FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory ( // PCIED 256M CFG region for ECAM
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000037FFF0000000, // AddressMinimum - MIN
>> + 0x000037FFFFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + // Current Resource Settings
>> + Method (_CRS, 0, Serialized) {
>> + Return (PDRS)
>> + }
>> + }
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
>> new file mode 100755
>> index 000000000000..67e1518ebf88
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.Rca01.asi
>> @@ -0,0 +1,681 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> + // PCI0 RCA0
>> + Device (PCI0) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 12)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI0")
>> + Name (_STR, Unicode("PCIe 0 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 128/129/130/131 respectively. PCI0 RCA0
>> + //
>> + Package() {0x0001FFFF, 0, 0, 128},
>> + Package() {0x0001FFFF, 1, 0, 129},
>> + Package() {0x0001FFFF, 2, 0, 130},
>> + Package() {0x0001FFFF, 3, 0, 131},
>> + Package() {0x0002FFFF, 0, 0, 128},
>> + Package() {0x0002FFFF, 1, 0, 129},
>> + Package() {0x0002FFFF, 2, 0, 130},
>> + Package() {0x0002FFFF, 3, 0, 131},
>> + Package() {0x0003FFFF, 0, 0, 128},
>> + Package() {0x0003FFFF, 1, 0, 129},
>> + Package() {0x0003FFFF, 2, 0, 130},
>> + Package() {0x0003FFFF, 3, 0, 131},
>> + Package() {0x0004FFFF, 0, 0, 128},
>> + Package() {0x0004FFFF, 1, 0, 129},
>> + Package() {0x0004FFFF, 2, 0, 130},
>> + Package() {0x0004FFFF, 3, 0, 131},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x33FFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000040000000, // AddressMinimum - MIN
>> + 0x000000004FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000300000000000, // AddressMinimum - MIN
>> + 0x000033FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI0 RCA0
>> +
>> + // PCI1 RCA1
>> + Device (PCI1) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 13)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI1")
>> + Name (_STR, Unicode("PCIe 1 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 132/133/134/135 respectively. PCI1 RCA1
>> + //
>> + Package() {0x0001FFFF, 0, 0, 132},
>> + Package() {0x0001FFFF, 1, 0, 133},
>> + Package() {0x0001FFFF, 2, 0, 134},
>> + Package() {0x0001FFFF, 3, 0, 135},
>> + Package() {0x0002FFFF, 0, 0, 132},
>> + Package() {0x0002FFFF, 1, 0, 133},
>> + Package() {0x0002FFFF, 2, 0, 134},
>> + Package() {0x0002FFFF, 3, 0, 135},
>> + Package() {0x0003FFFF, 0, 0, 132},
>> + Package() {0x0003FFFF, 1, 0, 133},
>> + Package() {0x0003FFFF, 2, 0, 134},
>> + Package() {0x0003FFFF, 3, 0, 135},
>> + Package() {0x0004FFFF, 0, 0, 132},
>> + Package() {0x0004FFFF, 1, 0, 133},
>> + Package() {0x0004FFFF, 2, 0, 134},
>> + Package() {0x0004FFFF, 3, 0, 135},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x37FFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000050000000, // AddressMinimum - MIN
>> + 0x000000005FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + Cacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000340000000000, // AddressMinimum - MIN
>> + 0x000037FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI1 RCA1
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
>> new file mode 100755
>> index 000000000000..7c05c6768a0e
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S0.asi
>> @@ -0,0 +1,2078 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> + // PCI2 RCA2
>> + Device (PCI2) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF)
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 1)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI2")
>> + Name (_STR, Unicode("PCIe 2 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 136/137/138/139 respectively. PCI2 RCA2
>> + //
>> + Package() {0x0001FFFF, 0, 0, 136},
>> + Package() {0x0001FFFF, 1, 0, 137},
>> + Package() {0x0001FFFF, 2, 0, 138},
>> + Package() {0x0001FFFF, 3, 0, 139},
>> + Package() {0x0002FFFF, 0, 0, 136},
>> + Package() {0x0002FFFF, 1, 0, 137},
>> + Package() {0x0002FFFF, 2, 0, 138},
>> + Package() {0x0002FFFF, 3, 0, 139},
>> + Package() {0x0003FFFF, 0, 0, 136},
>> + Package() {0x0003FFFF, 1, 0, 137},
>> + Package() {0x0003FFFF, 2, 0, 138},
>> + Package() {0x0003FFFF, 3, 0, 139},
>> + Package() {0x0004FFFF, 0, 0, 136},
>> + Package() {0x0004FFFF, 1, 0, 137},
>> + Package() {0x0004FFFF, 2, 0, 138},
>> + Package() {0x0004FFFF, 3, 0, 139},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x3BFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE80000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000030000000, // AddressMinimum - MIN
>> + 0x0000000037FFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000380000000000, // AddressMinimum - MIN
>> + 0x00003BFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP, 0) // PCI _OSC Support Field value
>> + Name (CTRL, 0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3,0,CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI2 RCA2
>> +
>> + // PCI3 RCA3
>> + Device (PCI3) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF)
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 0)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI3")
>> + Name (_STR, Unicode("PCIe 3 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 140/141/142/143 respectively. PCI3 RCA3
>> + //
>> + Package() {0x0001FFFF, 0, 0, 140},
>> + Package() {0x0001FFFF, 1, 0, 141},
>> + Package() {0x0001FFFF, 2, 0, 142},
>> + Package() {0x0001FFFF, 3, 0, 143},
>> + Package() {0x0002FFFF, 0, 0, 140},
>> + Package() {0x0002FFFF, 1, 0, 141},
>> + Package() {0x0002FFFF, 2, 0, 142},
>> + Package() {0x0002FFFF, 3, 0, 143},
>> + Package() {0x0003FFFF, 0, 0, 140},
>> + Package() {0x0003FFFF, 1, 0, 141},
>> + Package() {0x0003FFFF, 2, 0, 142},
>> + Package() {0x0003FFFF, 3, 0, 143},
>> + Package() {0x0004FFFF, 0, 0, 140},
>> + Package() {0x0004FFFF, 1, 0, 141},
>> + Package() {0x0004FFFF, 2, 0, 142},
>> + Package() {0x0004FFFF, 3, 0, 143},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x3FFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to Return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE00000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000038000000, // AddressMinimum - MIN
>> + 0x000000003FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00003C0000000000, // AddressMinimum - MIN
>> + 0x00003FFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP, 0) // PCI _OSC Support Field value
>> + Name (CTRL, 0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI3 RCA3
>> +
>> + // PCI4 RCB0
>> + Device (PCI4) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 2)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI4")
>> + Name (_STR, Unicode("PCIe 4 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 144/145/146/147 respectively. PCI4 RCB0
>> + //
>> + Package() {0x0001FFFF, 0, 0, 144},
>> + Package() {0x0001FFFF, 1, 0, 145},
>> + Package() {0x0001FFFF, 2, 0, 146},
>> + Package() {0x0001FFFF, 3, 0, 147},
>> + Package() {0x0002FFFF, 0, 0, 144},
>> + Package() {0x0002FFFF, 1, 0, 145},
>> + Package() {0x0002FFFF, 2, 0, 146},
>> + Package() {0x0002FFFF, 3, 0, 147},
>> + Package() {0x0003FFFF, 0, 0, 144},
>> + Package() {0x0003FFFF, 1, 0, 145},
>> + Package() {0x0003FFFF, 2, 0, 146},
>> + Package() {0x0003FFFF, 3, 0, 147},
>> + Package() {0x0004FFFF, 0, 0, 144},
>> + Package() {0x0004FFFF, 1, 0, 145},
>> + Package() {0x0004FFFF, 2, 0, 146},
>> + Package() {0x0004FFFF, 3, 0, 147},
>> + Package() {0x0005FFFF, 0, 0, 144},
>> + Package() {0x0005FFFF, 1, 0, 145},
>> + Package() {0x0005FFFF, 2, 0, 146},
>> + Package() {0x0005FFFF, 3, 0, 147},
>> + Package() {0x0006FFFF, 0, 0, 144},
>> + Package() {0x0006FFFF, 1, 0, 145},
>> + Package() {0x0006FFFF, 2, 0, 146},
>> + Package() {0x0006FFFF, 3, 0, 147},
>> + Package() {0x0007FFFF, 0, 0, 144},
>> + Package() {0x0007FFFF, 1, 0, 145},
>> + Package() {0x0007FFFF, 2, 0, 146},
>> + Package() {0x0007FFFF, 3, 0, 147},
>> + Package() {0x0008FFFF, 0, 0, 144},
>> + Package() {0x0008FFFF, 1, 0, 145},
>> + Package() {0x0008FFFF, 2, 0, 146},
>> + Package() {0x0008FFFF, 3, 0, 147},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x23FFF0000000)
>> + }
>> +
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FEC0000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000001000000, // AddressMinimum - MIN
>> + 0x0000000007FFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000007000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000200000000000, // AddressMinimum - MIN
>> + 0x000023FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2))
>> + {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI4 RCB0
>> +
>> + // PCI5 RCB1
>> + Device (PCI5) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF)
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID,"PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 3)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI5")
>> + Name (_STR, Unicode("PCIe 5 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 148/149/150/151 respectively. PCI5 RCB1
>> + //
>> + Package() {0x0001FFFF, 0, 0, 148},
>> + Package() {0x0001FFFF, 1, 0, 149},
>> + Package() {0x0001FFFF, 2, 0, 150},
>> + Package() {0x0001FFFF, 3, 0, 151},
>> + Package() {0x0002FFFF, 0, 0, 148},
>> + Package() {0x0002FFFF, 1, 0, 149},
>> + Package() {0x0002FFFF, 2, 0, 150},
>> + Package() {0x0002FFFF, 3, 0, 151},
>> + Package() {0x0003FFFF, 0, 0, 148},
>> + Package() {0x0003FFFF, 1, 0, 149},
>> + Package() {0x0003FFFF, 2, 0, 150},
>> + Package() {0x0003FFFF, 3, 0, 151},
>> + Package() {0x0004FFFF, 0, 0, 148},
>> + Package() {0x0004FFFF, 1, 0, 149},
>> + Package() {0x0004FFFF, 2, 0, 150},
>> + Package() {0x0004FFFF, 3, 0, 151},
>> + Package() {0x0005FFFF, 0, 0, 148},
>> + Package() {0x0005FFFF, 1, 0, 149},
>> + Package() {0x0005FFFF, 2, 0, 150},
>> + Package() {0x0005FFFF, 3, 0, 151},
>> + Package() {0x0006FFFF, 0, 0, 148},
>> + Package() {0x0006FFFF, 1, 0, 149},
>> + Package() {0x0006FFFF, 2, 0, 150},
>> + Package() {0x0006FFFF, 3, 0, 151},
>> + Package() {0x0007FFFF, 0, 0, 148},
>> + Package() {0x0007FFFF, 1, 0, 149},
>> + Package() {0x0007FFFF, 2, 0, 150},
>> + Package() {0x0007FFFF, 3, 0, 151},
>> + Package() {0x0008FFFF, 0, 0, 148},
>> + Package() {0x0008FFFF, 1, 0, 149},
>> + Package() {0x0008FFFF, 2, 0, 150},
>> + Package() {0x0008FFFF, 3, 0, 151},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x27FFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FF00000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000008000000, // AddressMinimum - MIN
>> + 0x000000000FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000240000000000, // AddressMinimum - MIN
>> + 0x000027FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP, 0) // PCI _OSC Support Field value
>> + Name (CTRL, 0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2))
>> + {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI5 RCB1
>> +
>> +
>> + // PCI6 RCB2
>> + Device (PCI6) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID,"PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID,"PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 4)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI6")
>> + Name (_STR, Unicode("PCIe 6 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 152/153/154/155 respectively. PCI6 RCB2
>> + //
>> + Package() {0x0001FFFF, 0, 0, 152},
>> + Package() {0x0001FFFF, 1, 0, 153},
>> + Package() {0x0001FFFF, 2, 0, 154},
>> + Package() {0x0001FFFF, 3, 0, 155},
>> + Package() {0x0002FFFF, 0, 0, 152},
>> + Package() {0x0002FFFF, 1, 0, 153},
>> + Package() {0x0002FFFF, 2, 0, 154},
>> + Package() {0x0002FFFF, 3, 0, 155},
>> + Package() {0x0003FFFF, 0, 0, 152},
>> + Package() {0x0003FFFF, 1, 0, 153},
>> + Package() {0x0003FFFF, 2, 0, 154},
>> + Package() {0x0003FFFF, 3, 0, 155},
>> + Package() {0x0004FFFF, 0, 0, 152},
>> + Package() {0x0004FFFF, 1, 0, 153},
>> + Package() {0x0004FFFF, 2, 0, 154},
>> + Package() {0x0004FFFF, 3, 0, 155},
>> + Package() {0x0005FFFF, 0, 0, 152},
>> + Package() {0x0005FFFF, 1, 0, 153},
>> + Package() {0x0005FFFF, 2, 0, 154},
>> + Package() {0x0005FFFF, 3, 0, 155},
>> + Package() {0x0006FFFF, 0, 0, 152},
>> + Package() {0x0006FFFF, 1, 0, 153},
>> + Package() {0x0006FFFF, 2, 0, 154},
>> + Package() {0x0006FFFF, 3, 0, 155},
>> + Package() {0x0007FFFF, 0, 0, 152},
>> + Package() {0x0007FFFF, 1, 0, 153},
>> + Package() {0x0007FFFF, 2, 0, 154},
>> + Package() {0x0007FFFF, 3, 0, 155},
>> + Package() {0x0008FFFF, 0, 0, 152},
>> + Package() {0x0008FFFF, 1, 0, 153},
>> + Package() {0x0008FFFF, 2, 0, 154},
>> + Package() {0x0008FFFF, 3, 0, 155},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x2BFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000010000000, // AddressMinimum - MIN
>> + 0x0000000017FFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000280000000000, // AddressMinimum - MIN
>> + 0x00002BFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3,0,CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3,4,CDW2)
>> + CreateDWordField (Arg3,8,CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2,SUPP)
>> + Store (CDW3,CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL,0x1E,CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1,One)) {
>> + Or (CDW1,0x08,CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3,CTRL)) {
>> + Or (CDW1,0x10,CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL,CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1,4,CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI6 RCB2
>> +
>> + // PCI7 RCB3
>> + Device (PCI7) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID,"PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID,"PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 5)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCI7")
>> + Name (_STR, Unicode("PCIe 7 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 156/157/158/159 respectively. PCI7 RCB3
>> + //
>> + Package() {0x0001FFFF, 0, 0, 156},
>> + Package() {0x0001FFFF, 1, 0, 157},
>> + Package() {0x0001FFFF, 2, 0, 158},
>> + Package() {0x0001FFFF, 3, 0, 159},
>> + Package() {0x0002FFFF, 0, 0, 156},
>> + Package() {0x0002FFFF, 1, 0, 157},
>> + Package() {0x0002FFFF, 2, 0, 158},
>> + Package() {0x0002FFFF, 3, 0, 159},
>> + Package() {0x0003FFFF, 0, 0, 156},
>> + Package() {0x0003FFFF, 1, 0, 157},
>> + Package() {0x0003FFFF, 2, 0, 158},
>> + Package() {0x0003FFFF, 3, 0, 159},
>> + Package() {0x0004FFFF, 0, 0, 156},
>> + Package() {0x0004FFFF, 1, 0, 157},
>> + Package() {0x0004FFFF, 2, 0, 158},
>> + Package() {0x0004FFFF, 3, 0, 159},
>> + Package() {0x0005FFFF, 0, 0, 156},
>> + Package() {0x0005FFFF, 1, 0, 157},
>> + Package() {0x0005FFFF, 2, 0, 158},
>> + Package() {0x0005FFFF, 3, 0, 159},
>> + Package() {0x0006FFFF, 0, 0, 156},
>> + Package() {0x0006FFFF, 1, 0, 157},
>> + Package() {0x0006FFFF, 2, 0, 158},
>> + Package() {0x0006FFFF, 3, 0, 159},
>> + Package() {0x0007FFFF, 0, 0, 156},
>> + Package() {0x0007FFFF, 1, 0, 157},
>> + Package() {0x0007FFFF, 2, 0, 158},
>> + Package() {0x0007FFFF, 3, 0, 159},
>> + Package() {0x0008FFFF, 0, 0, 156},
>> + Package() {0x0008FFFF, 1, 0, 157},
>> + Package() {0x0008FFFF, 2, 0, 158},
>> + Package() {0x0008FFFF, 3, 0, 159},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x2FFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FF40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000018000000, // AddressMinimum - MIN
>> + 0x000000001FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00002C0000000000, // AddressMinimum - MIN
>> + 0x00002FFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3,0,CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3,4,CDW2)
>> + CreateDWordField (Arg3,8,CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2,SUPP)
>> + Store (CDW3,CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL,0x1E,CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1,One)) {
>> + Or (CDW1,0x08,CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3,CTRL)) {
>> + Or (CDW1,0x10,CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL,CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1,4,CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCI7 RCB3
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
>> new file mode 100755
>> index 000000000000..2757f3124b83
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PCI-S1.asi
>> @@ -0,0 +1,2087 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> + //
>> + // S1 Start here
>> + //
>> +
>> + // PCIE6 S1 RCA2
>> + Device (PCIA) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID,"PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF)
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID,"PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 6)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCIA")
>> + Name (_STR, Unicode("PCIe 10 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 136/137/138/139 + 320 respectively. PCIA RCA2
>> + //
>> + Package() {0x0001FFFF, 0, 0, 456},
>> + Package() {0x0001FFFF, 1, 0, 457},
>> + Package() {0x0001FFFF, 2, 0, 458},
>> + Package() {0x0001FFFF, 3, 0, 459},
>> + Package() {0x0002FFFF, 0, 0, 456},
>> + Package() {0x0002FFFF, 1, 0, 457},
>> + Package() {0x0002FFFF, 2, 0, 458},
>> + Package() {0x0002FFFF, 3, 0, 459},
>> + Package() {0x0003FFFF, 0, 0, 456},
>> + Package() {0x0003FFFF, 1, 0, 457},
>> + Package() {0x0003FFFF, 2, 0, 458},
>> + Package() {0x0003FFFF, 3, 0, 459},
>> + Package() {0x0004FFFF, 0, 0, 456},
>> + Package() {0x0004FFFF, 1, 0, 457},
>> + Package() {0x0004FFFF, 2, 0, 458},
>> + Package() {0x0004FFFF, 3, 0, 459},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x7BFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FF80000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000070000000, // AddressMinimum - MIN
>> + 0x0000000077FFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000780000000000, // AddressMinimum - MIN
>> + 0x00007BFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3,0,CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3,4,CDW2)
>> + CreateDWordField (Arg3,8,CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2,SUPP)
>> + Store (CDW3,CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL,0x1E,CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1,One)) {
>> + Or (CDW1,0x08,CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3,CTRL)) {
>> + Or (CDW1,0x10,CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL,CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1,4,CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCIA RCA2
>> +
>> + // PCIEB RCA3
>> + Device (PCIB) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID,"PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF)
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID,"PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 7)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCIB")
>> + Name (_STR, Unicode("PCIe 11 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 140/141/142/143 + 320 respectively. PCIB RCA3
>> + //
>> + Package() {0x0001FFFF, 0, 0, 460},
>> + Package() {0x0001FFFF, 1, 0, 461},
>> + Package() {0x0001FFFF, 2, 0, 462},
>> + Package() {0x0001FFFF, 3, 0, 463},
>> + Package() {0x0002FFFF, 0, 0, 460},
>> + Package() {0x0002FFFF, 1, 0, 461},
>> + Package() {0x0002FFFF, 2, 0, 462},
>> + Package() {0x0002FFFF, 3, 0, 463},
>> + Package() {0x0003FFFF, 0, 0, 460},
>> + Package() {0x0003FFFF, 1, 0, 461},
>> + Package() {0x0003FFFF, 2, 0, 462},
>> + Package() {0x0003FFFF, 3, 0, 463},
>> + Package() {0x0004FFFF, 0, 0, 460},
>> + Package() {0x0004FFFF, 1, 0, 461},
>> + Package() {0x0004FFFF, 2, 0, 462},
>> + Package() {0x0004FFFF, 3, 0, 463},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x7FFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FFC0000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000078000000, // AddressMinimum - MIN
>> + 0x000000007FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00007C0000000000, // AddressMinimum - MIN
>> + 0x00007FFFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3,0,CDW1)
>> + If (LEqual (Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3,4,CDW2)
>> + CreateDWordField (Arg3,8,CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2,SUPP)
>> + Store (CDW3,CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL,0x1E,CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1,One)) {
>> + Or (CDW1,0x08,CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3,CTRL)) {
>> + Or (CDW1,0x10,CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL,CDW3)
>> + Return (Arg3)
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1,4,CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0,ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCIB RCA3
>> +
>> + // PCIC RCB0
>> + Device (PCIC) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 8)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCIC")
>> + Name (_STR, Unicode("PCIe 12 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 144/145/146/147 + 320 respectively. PCIC RCB0
>> + //
>> + Package() {0x0001FFFF, 0, 0, 464},
>> + Package() {0x0001FFFF, 1, 0, 465},
>> + Package() {0x0001FFFF, 2, 0, 466},
>> + Package() {0x0001FFFF, 3, 0, 467},
>> + Package() {0x0002FFFF, 0, 0, 464},
>> + Package() {0x0002FFFF, 1, 0, 465},
>> + Package() {0x0002FFFF, 2, 0, 466},
>> + Package() {0x0002FFFF, 3, 0, 467},
>> + Package() {0x0003FFFF, 0, 0, 464},
>> + Package() {0x0003FFFF, 1, 0, 465},
>> + Package() {0x0003FFFF, 2, 0, 466},
>> + Package() {0x0003FFFF, 3, 0, 467},
>> + Package() {0x0004FFFF, 0, 0, 464},
>> + Package() {0x0004FFFF, 1, 0, 465},
>> + Package() {0x0004FFFF, 2, 0, 466},
>> + Package() {0x0004FFFF, 3, 0, 467},
>> + Package() {0x0005FFFF, 0, 0, 464},
>> + Package() {0x0005FFFF, 1, 0, 465},
>> + Package() {0x0005FFFF, 2, 0, 466},
>> + Package() {0x0005FFFF, 3, 0, 467},
>> + Package() {0x0006FFFF, 0, 0, 464},
>> + Package() {0x0006FFFF, 1, 0, 465},
>> + Package() {0x0006FFFF, 2, 0, 466},
>> + Package() {0x0006FFFF, 3, 0, 467},
>> + Package() {0x0007FFFF, 0, 0, 464},
>> + Package() {0x0007FFFF, 1, 0, 465},
>> + Package() {0x0007FFFF, 2, 0, 466},
>> + Package() {0x0007FFFF, 3, 0, 467},
>> + Package() {0x0008FFFF, 0, 0, 464},
>> + Package() {0x0008FFFF, 1, 0, 465},
>> + Package() {0x0008FFFF, 2, 0, 466},
>> + Package() {0x0008FFFF, 3, 0, 467},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x63FFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000040000000, // AddressMinimum - MIN
>> + 0x0000000047FFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000600000000000, // AddressMinimum - MIN
>> + 0x000063FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCIC RCB0
>> +
>> + // PCID RCB1
>> + Device (PCID) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 9)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCID")
>> + Name (_STR, Unicode("PCIe 13 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 148/149/150/151 + 320 respectively. PCID RCB1
>> + //
>> + Package() {0x0001FFFF, 0, 0, 468},
>> + Package() {0x0001FFFF, 1, 0, 469},
>> + Package() {0x0001FFFF, 2, 0, 470},
>> + Package() {0x0001FFFF, 3, 0, 471},
>> + Package() {0x0002FFFF, 0, 0, 468},
>> + Package() {0x0002FFFF, 1, 0, 469},
>> + Package() {0x0002FFFF, 2, 0, 470},
>> + Package() {0x0002FFFF, 3, 0, 471},
>> + Package() {0x0003FFFF, 0, 0, 468},
>> + Package() {0x0003FFFF, 1, 0, 469},
>> + Package() {0x0003FFFF, 2, 0, 470},
>> + Package() {0x0003FFFF, 3, 0, 471},
>> + Package() {0x0004FFFF, 0, 0, 468},
>> + Package() {0x0004FFFF, 1, 0, 469},
>> + Package() {0x0004FFFF, 2, 0, 470},
>> + Package() {0x0004FFFF, 3, 0, 471},
>> + Package() {0x0005FFFF, 0, 0, 468},
>> + Package() {0x0005FFFF, 1, 0, 469},
>> + Package() {0x0005FFFF, 2, 0, 470},
>> + Package() {0x0005FFFF, 3, 0, 471},
>> + Package() {0x0006FFFF, 0, 0, 468},
>> + Package() {0x0006FFFF, 1, 0, 469},
>> + Package() {0x0006FFFF, 2, 0, 470},
>> + Package() {0x0006FFFF, 3, 0, 471},
>> + Package() {0x0007FFFF, 0, 0, 468},
>> + Package() {0x0007FFFF, 1, 0, 469},
>> + Package() {0x0007FFFF, 2, 0, 470},
>> + Package() {0x0007FFFF, 3, 0, 471},
>> + Package() {0x0008FFFF, 0, 0, 468},
>> + Package() {0x0008FFFF, 1, 0, 469},
>> + Package() {0x0008FFFF, 2, 0, 470},
>> + Package() {0x0008FFFF, 3, 0, 471},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x67FFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000048000000, // AddressMinimum - MIN
>> + 0x000000004FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000640000000000, // AddressMinimum - MIN
>> + 0x000067FFDFFFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCID RCB1
>> +
>> + // PCIE RCB2
>> + Device (PCIE) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 10)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCIE")
>> + Name (_STR, Unicode("PCIe 14 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 152/153/154/155 + 320 respectively. PCIE RCB2
>> + //
>> + Package() {0x0001FFFF, 0, 0, 472},
>> + Package() {0x0001FFFF, 1, 0, 473},
>> + Package() {0x0001FFFF, 2, 0, 474},
>> + Package() {0x0001FFFF, 3, 0, 475},
>> + Package() {0x0002FFFF, 0, 0, 472},
>> + Package() {0x0002FFFF, 1, 0, 473},
>> + Package() {0x0002FFFF, 2, 0, 474},
>> + Package() {0x0002FFFF, 3, 0, 475},
>> + Package() {0x0003FFFF, 0, 0, 472},
>> + Package() {0x0003FFFF, 1, 0, 473},
>> + Package() {0x0003FFFF, 2, 0, 474},
>> + Package() {0x0003FFFF, 3, 0, 475},
>> + Package() {0x0004FFFF, 0, 0, 472},
>> + Package() {0x0004FFFF, 1, 0, 473},
>> + Package() {0x0004FFFF, 2, 0, 474},
>> + Package() {0x0004FFFF, 3, 0, 475},
>> + Package() {0x0005FFFF, 0, 0, 472},
>> + Package() {0x0005FFFF, 1, 0, 473},
>> + Package() {0x0005FFFF, 2, 0, 474},
>> + Package() {0x0005FFFF, 3, 0, 475},
>> + Package() {0x0006FFFF, 0, 0, 472},
>> + Package() {0x0006FFFF, 1, 0, 473},
>> + Package() {0x0006FFFF, 2, 0, 474},
>> + Package() {0x0006FFFF, 3, 0, 475},
>> + Package() {0x0007FFFF, 0, 0, 472},
>> + Package() {0x0007FFFF, 1, 0, 473},
>> + Package() {0x0007FFFF, 2, 0, 474},
>> + Package() {0x0007FFFF, 3, 0, 475},
>> + Package() {0x0008FFFF, 0, 0, 472},
>> + Package() {0x0008FFFF, 1, 0, 473},
>> + Package() {0x0008FFFF, 2, 0, 474},
>> + Package() {0x0008FFFF, 3, 0, 475},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x6BFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000050000000, // AddressMinimum - MIN
>> + 0x0000000057FFFFFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000680000000000, // AddressMinimum - MIN
>> + 0x00006BFFDFFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCIE RCB2
>> +
>> + // PCIF RCB3
>> + Device (PCIF) {
>> + //
>> + // Hardware ID must be PNP0A08, which maps to a PCIe root complex.
>> + // Section 6.1.5
>> + //
>> +
>> + Name (_HID, "PNP0A08")
>> + Name (_CCA, ONE)
>> +
>> + Method (_STA, 0, NotSerialized) {
>> + Return (0xF) // The default value is 0x0. Unfortunately, it breaks
>> + // run-time patching as the representation of 0 is special
>> + // encoding and cannot be patched to expand with extra bytes
>> + // easily. As such, we default to 0xF and patch this based
>> + // on whether the port was enabled or not by the BIOS.
>> + }
>> +
>> + //
>> + // Optionally, include a compatible ID of PNP0A03, which maps to a PCI
>> + // root complex for use with pre-PCIe operating systems.
>> + // Section 6.1.2
>> + //
>> +
>> + Name (_CID, "PNP0A03")
>> +
>> + //
>> + // Declare the segment number of this root complex. Most systems only
>> + // have one segment, which is numbered 0.
>> + // Section 6.5.6
>> + //
>> +
>> + Name (_SEG, 11)
>> +
>> + //
>> + // Declare the base bus number, which is the bus number of the root
>> + // bus in this root complex. This is usually 0, but need not be.
>> + // For root complexes supporting multiple root busses, this should
>> + // be the lowest numbered root bus.
>> + // Section 6.5.5
>> + //
>> +
>> + Name (_BBN, 0)
>> +
>> + //
>> + // The _UID value provides a way of uniquely identifying a device
>> + // in the case where more than one instance of a specific device
>> + // is implemented with the same _HID/_CID. For systems with a
>> + // single root complex, this is usually just 0. For systems with
>> + // multiple root complexes, this should be different for each
>> + // root complex.
>> + // Section 6.1.12
>> + //
>> +
>> + Name (_UID, "PCIF")
>> + Name (_STR, Unicode("PCIe 15 Device"))
>> +
>> + //
>> + // Declare the PCI Routing Table.
>> + // This defines SPI mappings of the four line-based interrupts
>> + // associated with the root complex and hierarchy below it.
>> + // Section 6.2.12
>> + //
>> +
>> + Name (_PRT, Package() {
>> +
>> + //
>> + // Routing for device 0, all functions.
>> + // Note: ARM doesn't support LNK nodes, so the third param
>> + // is 0 and the fourth param is the SPI number of the interrupt
>> + // line. In this example, the A/B/C/D interrupts are wired to
>> + // SPI lines 156/157/158/159 + 320 respectively. PCIF RCB3
>> + //
>> + Package() {0x0001FFFF, 0, 0, 476},
>> + Package() {0x0001FFFF, 1, 0, 477},
>> + Package() {0x0001FFFF, 2, 0, 478},
>> + Package() {0x0001FFFF, 3, 0, 479},
>> + Package() {0x0002FFFF, 0, 0, 476},
>> + Package() {0x0002FFFF, 1, 0, 477},
>> + Package() {0x0002FFFF, 2, 0, 478},
>> + Package() {0x0002FFFF, 3, 0, 479},
>> + Package() {0x0003FFFF, 0, 0, 476},
>> + Package() {0x0003FFFF, 1, 0, 477},
>> + Package() {0x0003FFFF, 2, 0, 478},
>> + Package() {0x0003FFFF, 3, 0, 479},
>> + Package() {0x0004FFFF, 0, 0, 476},
>> + Package() {0x0004FFFF, 1, 0, 477},
>> + Package() {0x0004FFFF, 2, 0, 478},
>> + Package() {0x0004FFFF, 3, 0, 479},
>> + Package() {0x0005FFFF, 0, 0, 476},
>> + Package() {0x0005FFFF, 1, 0, 477},
>> + Package() {0x0005FFFF, 2, 0, 478},
>> + Package() {0x0005FFFF, 3, 0, 479},
>> + Package() {0x0006FFFF, 0, 0, 476},
>> + Package() {0x0006FFFF, 1, 0, 477},
>> + Package() {0x0006FFFF, 2, 0, 478},
>> + Package() {0x0006FFFF, 3, 0, 479},
>> + Package() {0x0007FFFF, 0, 0, 476},
>> + Package() {0x0007FFFF, 1, 0, 477},
>> + Package() {0x0007FFFF, 2, 0, 478},
>> + Package() {0x0007FFFF, 3, 0, 479},
>> + Package() {0x0008FFFF, 0, 0, 476},
>> + Package() {0x0008FFFF, 1, 0, 477},
>> + Package() {0x0008FFFF, 2, 0, 478},
>> + Package() {0x0008FFFF, 3, 0, 479},
>> + })
>> +
>> + //
>> + // Declare the resources assigned to this root complex.
>> + // Section 6.2.2
>> + //
>> + Method (_CBA, 0, Serialized) {
>> + Return (0x6FFFF0000000)
>> + }
>> +
>> + //
>> + // Declare a ResourceTemplate buffer to return the resource
>> + // requirements from _CRS.
>> + // Section 19.5.109
>> + //
>> +
>> + Name (RBUF, ResourceTemplate () {
>> +
>> + //
>> + // Declare the range of bus numbers assigned to this root
>> + // complex. In this example, the minimum bus number will be
>> + // 0, the maximum bus number will be 0xFF, supporting
>> + // 256 busses total.
>> + // Section 19.5.141
>> + //
>> +
>> + WordBusNumber (
>> + ResourceProducer,
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + PosDecode, // Decode
>> + 0, // AddressGranularity
>> + 0, // AddressMinimum - Minimum Bus Number
>> + 255, // AddressMaximum - Maximum Bus Number
>> + 0, // AddressTranslation - Set to 0
>> + 256) // RangeLength - Number of Busses
>> +
>> + //
>> + // Declare the memory range to be used for BAR memory
>> + // windows. This declares a 4GB region starting at
>> + // 0x4000000000.
>> + // Section 19.5.80
>> + //
>> + // Memory32Fixed (ReadWrite, 0x1FE40000, 0x10000, )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000000058000000, // AddressMinimum - MIN
>> + 0x000000005FFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000008000000 // RangeLength - LEN
>> + )
>> +
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // NonCacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x00006C0000000000, // AddressMinimum - MIN
>> + 0x00006FFFDFFFFFFF, // AddressMinimum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x000003FFE0000000 // RangeLength - LEN
>> + )
>> + })
>> +
>> + Method (_CRS, 0, Serialized) {
>> + Return (RBUF)
>> + }
>> +
>> + //
>> + // Declare an _OSC (OS Control Handoff) method which takes 4 arguments.
>> + //
>> + // Argments:
>> + // Arg0 A Buffer containing a UUID
>> + // Arg1 An Integer containing a Revision ID of the buffer format
>> + // Arg2 An Integer containing a count of entries in Arg3
>> + // Arg3 A Buffer containing a list of DWORD capabilities
>> + // Return Value:
>> + // A Buffer containing a list of capabilities
>> + // See the APCI spec, Section 6.2.10,
>> + // and the PCI FW spec, Section 4.5.
>> + //
>> + // The following is an example, and may need modification for
>> + // specific implementations.
>> + //
>> +
>> + Name (SUPP,0) // PCI _OSC Support Field value
>> + Name (CTRL,0) // PCI _OSC Control Field value
>> +
>> + Method (_OSC, 4) {
>> +
>> + //
>> + // Look for the PCI Host Bridge Interface UUID.
>> + // Section 6.2.10.3
>> + //
>> +
>> + //
>> + // Create DWord-adressable fields from the Capabilities Buffer
>> + // Create CDW1 outside the test as it's used in the else clause.
>> + //
>> +
>> + CreateDWordField (Arg3, 0, CDW1)
>> + If (LEqual (Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) {
>> +
>> + CreateDWordField (Arg3, 4, CDW2)
>> + CreateDWordField (Arg3, 8, CDW3)
>> +
>> + //
>> + // Save Capabilities DWord 2 & 3
>> + //
>> +
>> + Store (CDW2, SUPP)
>> + Store (CDW3, CTRL)
>> +
>> + //
>> + // Only allow native hot plug control if OS supports:
>> + // ASPM
>> + // Clock PM
>> + // MSI/MSI-X
>> + //
>> +
>> + If (LNotEqual (And (SUPP, 0x16), 0x16)) {
>> +
>> + //
>> + // Mask bit 0 (and undefined bits)
>> + //
>> +
>> + And (CTRL, 0x1E, CTRL)
>> + }
>> +
>> + //
>> + // Never allow native Hot plug, PME.
>> + // Never allow SHPC (no SHPC controller in this system).
>> + // Only allow PCIe AER control if PCIe AER Firmware-First is disabled
>> + // Allows PCI Express Capability Structure control
>> + //
>> +
>> + If (AERF) {
>> + And (CTRL, 0x10, CTRL)
>> + } Else {
>> + And (CTRL, 0x18, CTRL)
>> + }
>> +
>> + //
>> + // Check for unknown revision.
>> + //
>> +
>> + If (LNotEqual (Arg1, One)) {
>> + Or (CDW1, 0x08, CDW1)
>> + }
>> +
>> + //
>> + // Check if capabilities bits were masked.
>> + //
>> +
>> + If (LNotEqual (CDW3, CTRL)) {
>> + Or (CDW1, 0x10, CDW1)
>> + }
>> +
>> + //
>> + // Update DWORD3 in the buffer.
>> + //
>> +
>> + Store (CTRL, CDW3)
>> + Return (Arg3)
>> +
>> + } Else {
>> +
>> + //
>> + // Unrecognized UUID
>> + //
>> +
>> + Or (CDW1, 4, CDW1)
>> + Return (Arg3)
>> + }
>> + } // End _OSC
>> +
>> + //
>> + // Declare a _DSM method for various functions called by the OS.
>> + // See the APCI spec, Section 9.14.1,
>> + // and the PCI FW spec, Section 4.6.
>> + // See also:
>> + // http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/PCI-rsc.doc
>> + //
>> +
>> + Method (_DSM, 0x4, Serialized) {
>> +
>> + //
>> + // Match against the _DSM PCI GUID.
>> + //
>> +
>> + If (LEqual (Arg0, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))) {
>> +
>> + Switch (ToInteger(Arg2)) {
>> + //
>> + // Function 0: Return supported functions as a bitfield
>> + // with one bit for each supported function.
>> + // Bit 0 must always be set, as that represents
>> + // function 0 (which is what is being called here).
>> + // Support for different functions may depend on
>> + // the revision ID of the interface, passed as Arg1.
>> + //
>> +
>> + Case (0) {
>> +
>> + //
>> + // Functions 0-7 are supported.
>> + //
>> +
>> + Return (Buffer() {0x01})
>> + }
>> + }
>> + }
>> +
>> + //
>> + // If not one of the function identifiers we recognize, then return a buffer
>> + // with bit 0 set to 0 indicating no functions supported.
>> + //
>> +
>> + Return (Buffer() {0})
>> + }
>> +
>> + //
>> + // Root Port 0 Device within the Root Complex.
>> + //
>> + Device (RP0) {
>> + //
>> + // Device 0, Function 0.
>> + //
>> +
>> + Name (_ADR, 0x00000000)
>> + }
>> +
>> + Method (_PXM, 0, NotSerialized) {
>> + // Patch by code
>> + Return(0xFF)
>> + }
>> + } // PCIF RCB3
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
>> new file mode 100755
>> index 000000000000..0e9db557d925
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S0.asi
>> @@ -0,0 +1,1303 @@
>> +/** @file
>> +
>> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Device(CMN0) {
>> + Name(_HID, "ARMHC600") // Device Identification Objects
>> + Name(_CID, "ARMHC600")
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("CMN0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceConsumer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000100010000000, // AddressMinimum - MIN
>> + 0x000010001fffffff, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> + QWordMemory (
>> + ResourceConsumer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000100012500000, // AddressMinimum - MIN
>> + 0x00001000164fffff, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000004000000 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 314 }
>> + })
>> +}
>> +
>> +Device(MC00) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008C000A00, // AddressMinimum - MIN
>> + 0x000010008C000BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC01) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 1)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008C400A00, // AddressMinimum - MIN
>> + 0x000010008C400BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC02) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 2)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU2"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008C800A00, // AddressMinimum - MIN
>> + 0x000010008C800BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC03) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 3)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU3"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008CC00A00, // AddressMinimum - MIN
>> + 0x000010008CC00BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC04) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 4)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU4"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008D000A00, // AddressMinimum - MIN
>> + 0x000010008D000BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC05) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 5)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU5"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008D400A00, // AddressMinimum - MIN
>> + 0x000010008D400BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC06) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 6)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU6"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008D800A00, // AddressMinimum - MIN
>> + 0x000010008D800BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(MC07) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 7)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 0: MCU7"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000010008DC00A00, // AddressMinimum - MIN
>> + 0x000010008DC00BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 312 }
>> + })
>> +}
>> +
>> +Device(DU00) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 64 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x000000,
>> + 0x000100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU01) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 65 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x010000,
>> + 0x010100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU02) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x2)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x2 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 66 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x020000,
>> + 0x020100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU03) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x3)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x3 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 67 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x030000,
>> + 0x030100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU04) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 68 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x040000,
>> + 0x040100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU05) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 69 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x050000,
>> + 0x050100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU06) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x6)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x6 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 71 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x060000,
>> + 0x060100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU07) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x7)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x7 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 80 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x070000,
>> + 0x070100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU08) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x8)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x8 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 81 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x080000,
>> + 0x080100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU09) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x9)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x9 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 82 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x090000,
>> + 0x090100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0A) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xA)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xA Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 83 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0A0000,
>> + 0x0A0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0B) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xB)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xB Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 115 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0B0000,
>> + 0x0B0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0C) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xC)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xC Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 116 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0C0000,
>> + 0x0C0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0D) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xD)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xD Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 221 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0D0000,
>> + 0x0D0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0E) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xE)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xE Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 222 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0E0000,
>> + 0x0E0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU0F) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0xF)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0xF Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 223 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x0F0000,
>> + 0x0F0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU10) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x10)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x10 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 248 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100000,
>> + 0x100100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU11) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x11)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x11 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 249 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x110000,
>> + 0x110100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU12) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x12)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x12 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 250 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x120000,
>> + 0x120100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU13) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x13)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x13 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 251 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x130000,
>> + 0x130100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU14) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x14)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x14 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 252 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x140000,
>> + 0x140100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU15) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x15)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x15 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 253 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x150000,
>> + 0x150100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU16) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x16)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x16 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 254 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x160000,
>> + 0x160100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU17) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x17)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x17 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 255 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x170000,
>> + 0x170100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU18) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x18)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x18 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 297 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x180000,
>> + 0x180100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU19) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x19)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x19 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 298 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x190000,
>> + 0x190100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1A) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1A)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1A Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 299 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1A0000,
>> + 0x1A0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1B) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1B)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1B Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 300 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1B0000,
>> + 0x1B0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1C) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1C)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1C Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 301 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1C0000,
>> + 0x1C0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1D) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1D)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1D Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 313 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1D0000,
>> + 0x1D0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1E) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1E)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1E Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 316 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1E0000,
>> + 0x1E0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU1F) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x1F)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x1F Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 317 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1F0000,
>> + 0x1F0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU20) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x20)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x20 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 318 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x200000,
>> + 0x200100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU21) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x21)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x21 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 319 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x210000,
>> + 0x210100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU22) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x22)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x22 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 344 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x220000,
>> + 0x220100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU23) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x23)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x23 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 345 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x230000,
>> + 0x230100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU24) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x24)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x24 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 346 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x240000,
>> + 0x240100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU25) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x25)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x25 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 347 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x250000,
>> + 0x250100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU26) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x26)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x26 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 348 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x260000,
>> + 0x260100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU27) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x27)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x27 Socket 0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 349 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x270000,
>> + 0x270100
>> + }
>> + }
>> + }
>> + })
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
>> new file mode 100755
>> index 000000000000..1ae1bac8098b
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU-S1.asi
>> @@ -0,0 +1,1303 @@
>> +/** @file
>> +
>> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Device(CMN1) {
>> + Name(_HID, "ARMHC600") // Device Identification Objects
>> + Name(_CID, "ARMHC600")
>> + Name(_UID, 1)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("CMN1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceConsumer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000500010000000, // AddressMinimum - MIN
>> + 0x000050001fffffff, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000010000000 // RangeLength - LEN
>> + )
>> + QWordMemory (
>> + ResourceConsumer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x0000500012500000, // AddressMinimum - MIN
>> + 0x00005000164fffff, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000004000000 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 634 }
>> + })
>> +}
>> +
>> +Device(MC10) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 8)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU0"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008C000A00, // AddressMinimum - MIN
>> + 0x000050008C000BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC11) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 9)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008C400A00, // AddressMinimum - MIN
>> + 0x000050008C400BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC12) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xa)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU2"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008C800A00, // AddressMinimum - MIN
>> + 0x000050008C800BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC13) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xb)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU3"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008CC00A00, // AddressMinimum - MIN
>> + 0x000050008CC00BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC14) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xc)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU4"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008D000A00, // AddressMinimum - MIN
>> + 0x000050008D000BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC15) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xd)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU5"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008D400A00, // AddressMinimum - MIN
>> + 0x000050008D400BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC16) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xe)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU6"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008D800A00, // AddressMinimum - MIN
>> + 0x000050008D800BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(MC17) {
>> + Name(_HID, "ARMHD620")
>> + Name(_CID, "ARMHD620")
>> + Name(_UID, 0xf)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("Socket 1: MCU7"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + QWordMemory (
>> + ResourceProducer, // ResourceUsage
>> + PosDecode, // Decode
>> + MinFixed, // IsMinFixed
>> + MaxFixed, // IsMaxFixed
>> + NonCacheable, // Cacheable
>> + ReadWrite, // ReadAndWrite
>> + 0x0000000000000000, // AddressGranularity - GRA
>> + 0x000050008DC00A00, // AddressMinimum - MIN
>> + 0x000050008DC00BFF, // AddressMaximum - MAX
>> + 0x0000000000000000, // AddressTranslation - TRA
>> + 0x0000000000000200 // RangeLength - LEN
>> + )
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 632 }
>> + })
>> +}
>> +
>> +Device(DU40) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x40)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x40 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 384 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100000000,
>> + 0x100000100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU41) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x41)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x41 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 385 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100010000,
>> + 0x100010100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU42) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x42)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x42 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 386 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100020000,
>> + 0x100020100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU43) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x43)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x43 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 387 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100030000,
>> + 0x100030100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU44) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x44)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x44 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 388 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100040000,
>> + 0x100040100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU45) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x45)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x45 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 389 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100050000,
>> + 0x100050100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU46) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x46)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x46 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 391 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100060000,
>> + 0x100060100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU47) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x47)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x47 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 400 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100070000,
>> + 0x100070100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU48) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x48)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x48 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 401 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100080000,
>> + 0x100080100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU49) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x49)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x49 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 402 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100090000,
>> + 0x100090100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4A) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4A)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4A Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 403 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000A0000,
>> + 0x1000A0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4B) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4B)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4B Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 435 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000B0000,
>> + 0x1000B0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4C) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4C)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4C Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 436 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000C0000,
>> + 0x1000C0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4D) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4D)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4D Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 541 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000D0000,
>> + 0x1000D0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4E) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4E)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4E Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 542 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000E0000,
>> + 0x1000E0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU4F) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x4F)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x4F Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 543 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1000F0000,
>> + 0x1000F0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU50) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x50)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x50 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 568 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100100000,
>> + 0x100100100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU51) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x51)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x51 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 569 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100110000,
>> + 0x100110100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU52) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x52)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x52 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 570 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100120000,
>> + 0x100120100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU53) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x53)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x53 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 571 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100130000,
>> + 0x100130100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU54) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x54)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x54 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 572 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100140000,
>> + 0x100140100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU55) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x55)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x55 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 573 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100150000,
>> + 0x100150100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU56) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x56)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x56 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 574 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100160000,
>> + 0x100160100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU57) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x57)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x57 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 575 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100170000,
>> + 0x100170100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU58) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x58)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x58 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 617 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100180000,
>> + 0x100180100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU59) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x59)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x59 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 618 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100190000,
>> + 0x100190100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5A) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5A)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5A Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 619 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001A0000,
>> + 0x1001A0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5B) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5B)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5B Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 620 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001B0000,
>> + 0x1001B0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5C) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5C)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5C Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 621 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001C0000,
>> + 0x1001C0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5D) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5D)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5D Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 633 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001D0000,
>> + 0x1001D0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5E) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5E)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5E Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 636 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001E0000,
>> + 0x1001E0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU5F) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x5F)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x5F Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 637 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x1001F0000,
>> + 0x1001F0100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU60) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x60)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x60 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 638 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100200000,
>> + 0x100200100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU61) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x61)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x61 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 639 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100210000,
>> + 0x100210100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU62) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x62)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x62 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 664 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100220000,
>> + 0x100220100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU63) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x63)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x63 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 665 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100230000,
>> + 0x100230100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU64) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x64)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x64 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 666 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100240000,
>> + 0x100240100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU65) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x65)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x65 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 667 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100250000,
>> + 0x100250100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU66) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x66)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x66 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 668 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100260000,
>> + 0x100260100
>> + }
>> + }
>> + }
>> + })
>> +}
>> +
>> +Device(DU67) {
>> + Name(_HID, "ARMHD500")
>> + Name(_CID, "ARMHD500")
>> + Name(_UID, 0x67)
>> + Name(_CCA, ONE)
>> + Name(_STR, Unicode("DSU CPM 0x67 Socket 1"))
>> + Method(_STA, 0, NotSerialized) {
>> + Return (0x0f)
>> + }
>> + Name(_CRS, ResourceTemplate() {
>> + Interrupt(ResourceConsumer, Level, ActiveHigh, Exclusive) { 669 }
>> + })
>> + Name (_DSD, Package () {
>> + ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
>> + Package () {
>> + Package (2) {
>> + "cpus",
>> + Package (2) {
>> + 0x100270000,
>> + 0x100270100
>> + }
>> + }
>> + }
>> + })
>> +}
>> diff --git a/Platform/Ampere/JadePkg/AcpiTables/PMU.asi b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
>> new file mode 100644
>> index 000000000000..0d177de8696d
>> --- /dev/null
>> +++ b/Platform/Ampere/JadePkg/AcpiTables/PMU.asi
>> @@ -0,0 +1,10 @@
>> +/** @file
>> +
>> + Copyright (c) 2020, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +Include ("PMU-S0.asi")
>> +Include ("PMU-S1.asi")
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
>> new file mode 100644
>> index 000000000000..a80f1e81b24f
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Bert.aslc
>> @@ -0,0 +1,33 @@
>> +/** @file
>> +
>> + Copyright (c) 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <IndustryStandard/Acpi.h>
>> +#include <AcpiHeader.h>
>> +
>> +#define BOOT_ERROR_REGION_LENGTH 0x50000
>> +#define BOOT_ERROR_REGION_BASE 0x0000000088230000
>> +
>> +#pragma pack(1)
>> +
>> +EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER Bert = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE,
>> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER,
>> + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_REVISION
>> + ),
>> + BOOT_ERROR_REGION_LENGTH,
>> + BOOT_ERROR_REGION_BASE
>> +};
>> +
>> +#pragma pack()
>> +
>> +//
>> +// Reference the table being generated to prevent the optimizer from removing
>> +// the data structure from the executable
>> +//
>> +VOID* CONST ReferenceAcpiTable = &Bert;
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
>> new file mode 100644
>> index 000000000000..bc2bbded11fd
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc
>> @@ -0,0 +1,87 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Library/AcpiLib.h>
>> +#include <Library/ArmLib.h>
>> +#include <Library/PcdLib.h>
>> +#include <IndustryStandard/Acpi.h>
>> +#include <IndustryStandard/DebugPort2Table.h>
>> +#include <AcpiHeader.h>
>> +
>> +#pragma pack(1)
>> +
>> +#define DBG2_NUM_DEBUG_PORTS 1
>> +#define DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS 1
>> +#define DBG2_NAMESPACESTRING_FIELD_SIZE 10
>> +#define SERIAL_PORT_PL011_UART_ADDR_SIZE 0x8
>> +
>> +#define NAME_STR_UART2 {'\\', '_', 'S', 'B', '.', 'U', 'R', 'T', '2', '\0'}
>> +
>> +typedef struct {
>> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT Dbg2Device;
>> + EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister;
>> + UINT32 AddressSize;
>> + UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE];
>> +} DBG2_DEBUG_DEVICE_INFORMATION;
>> +
>> +typedef struct {
>> + EFI_ACPI_DEBUG_PORT_2_DESCRIPTION_TABLE Description;
>> + DBG2_DEBUG_DEVICE_INFORMATION Dbg2DeviceInfo[DBG2_NUM_DEBUG_PORTS];
>> +} DBG2_TABLE;
>> +
>> +
>> +#define DBG2_DEBUG_PORT_DDI(NumReg, SubType, UartBase, UartAddrLen, UartNameStr) { \
>> + { \
>> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION, /* UINT8 Revision */ \
>> + sizeof (DBG2_DEBUG_DEVICE_INFORMATION), /* UINT16 Length */ \
>> + NumReg, /* UINT8 NumberofGenericAddressRegisters */ \
>> + DBG2_NAMESPACESTRING_FIELD_SIZE, /* UINT16 NameSpaceStringLength */ \
>> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, NameSpaceString), /* UINT16 NameSpaceStringOffset */ \
>> + 0, /* UINT16 OemDataLength */ \
>> + 0, /* UINT16 OemDataOffset */ \
>> + EFI_ACPI_DBG2_PORT_TYPE_SERIAL, /* UINT16 Port Type */ \
>> + SubType, /* UINT16 Port Subtype */ \
>> + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}, /* UINT8 Reserved[2] */ \
>> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, BaseAddressRegister), /* UINT16 BaseAddressRegister Offset */ \
>> + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, AddressSize) /* UINT16 AddressSize Offset */ \
>> + }, \
>> + ARM_GAS32 (UartBase), /* EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddressRegister */ \
>> + UartAddrLen, /* UINT32 AddressSize */ \
>> + UartNameStr /* UINT8 NameSpaceString[DBG2_NAMESPACESTRING_FIELD_SIZE] */ \
>> + }
>> +
>> +
>> +STATIC DBG2_TABLE Dbg2 = {
>> + {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_DEBUG_PORT_2_TABLE_SIGNATURE,
>> + DBG2_TABLE,
>> + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION
>> + ),
>> + OFFSET_OF (DBG2_TABLE, Dbg2DeviceInfo),
>> + DBG2_NUM_DEBUG_PORTS /* UINT32 NumberDbgDeviceInfo */
>> + },
>> + {
>> + // Kernel Debug Port
>> + DBG2_DEBUG_PORT_DDI (
>> + DBG2_NUMBER_OF_GENERIC_ADDRESS_REGISTERS,
>> + EFI_ACPI_DBG2_PORT_SUBTYPE_SERIAL_ARM_SBSA_GENERIC_UART,
>> + FixedPcdGet64 (PcdSerialDbgRegisterBase),
>> + SERIAL_PORT_PL011_UART_ADDR_SIZE,
>> + NAME_STR_UART2
>> + ),
>> + }
>> +};
>> +
>> +#pragma pack()
>> +
>> +//
>> +// Reference the table being generated to prevent the optimizer from removing
>> +// the data structure from the executable
>> +//
>> +VOID* CONST ReferenceAcpiTable = &Dbg2;
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
>> new file mode 100755
>> index 000000000000..9607b2e403e0
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl
>> @@ -0,0 +1,165 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +[0004] Signature : "EINJ" [Error Injection table]
>> +[0004] Table Length : 00000150
>> +[0001] Revision : 01
>> +[0001] Checksum : 09
>> +[0006] Oem ID : "Ampere"
>> +[0008] Oem Table ID : "Altra "
>> +[0004] Oem Revision : 00000001
>> +[0004] Asl Compiler ID : "INTL"
>> +[0004] Asl Compiler Revision : 20100528
>> +
>> +[0004] Injection Header Length : 00000030
>> +[0001] Flags : 00
>> +[0003] Reserved : 000000
>> +[0004] Injection Entry Count : 00000009
>> +
>> +[0001] Action : 00 [Begin Operation]
>> +[0001] Instruction : 00 [Read Register]
>> +[0001] Flags (decoded below) : 00
>> + Preserve Register Bits : 0
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088220000
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 01 [Get Trigger Table]
>> +[0001] Instruction : 00 [Read Register]
>> +[0001] Flags (decoded below) : 00
>> + Preserve Register Bits : 0
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088220040
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 08 [Set Error Type With Address]
>> +[0001] Instruction : 02 [Write Register]
>> +[0001] Flags (decoded below) : 01
>> + Preserve Register Bits : 1
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 20
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 03 [DWord Access:32]
>> +[0008] Address : 0000000088221000
>> +
>> +[0008] Value : 00000000
>> +[0008] Mask : FFFFFFFF
>> +
>> +[0001] Action : 02 [Set Error Type]
>> +[0001] Instruction : 02 [Write Register]
>> +[0001] Flags (decoded below) : 01
>> + Preserve Register Bits : 1
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 20
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [DWord Access:64]
>> +[0008] Address : 0000000088220080
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 03 [Get Error Type]
>> +[0001] Instruction : 00 [Read Register]
>> +[0001] Flags (decoded below) : 00
>> + Preserve Register Bits : 0
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 00000000882200c0
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 04 [End Operation]
>> +[0001] Instruction : 03 [Write Register Value]
>> +[0001] Flags (decoded below) : 01
>> + Preserve Register Bits : 1
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088220100
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 05 [Execute Operation]
>> +[0001] Instruction : 03 [Write Register Value]
>> +[0001] Flags (decoded below) : 01
>> + Preserve Register Bits : 1
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 20
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 03 [DWord Access:32]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Value : B1A00000
>> +[0008] Mask : FFFFFFFF
>> +
>> +[0001] Action : 06 [Check Busy Status]
>> +[0001] Instruction : 01 [Read Register Value]
>> +[0001] Flags (decoded below) : 00
>> + Preserve Register Bits : 0
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088220140
>> +
>> +[0008] Value : 0000000000000001
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> +
>> +[0001] Action : 07 [Get Command Status]
>> +[0001] Instruction : 00 [Read Register]
>> +[0001] Flags (decoded below) : 01
>> + Preserve Register Bits : 1
>> +[0001] Reserved : 00
>> +
>> +[0012] Register Region : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088220180
>> +
>> +[0008] Value : 0000000000000000
>> +[0008] Mask : FFFFFFFFFFFFFFFF
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
>> new file mode 100644
>> index 000000000000..5be828f1cdf0
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Fadt.aslc
>> @@ -0,0 +1,87 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Library/AcpiLib.h>
>> +#include <IndustryStandard/Acpi63.h>
>> +#include <AcpiHeader.h>
>> +
>> +//
>> +// This macro defines the FADT flag options.
>> +//
>> +#define FADT_FLAGS (EFI_ACPI_6_3_HW_REDUCED_ACPI | \
>> + EFI_ACPI_6_3_PWR_BUTTON)
>> +
>> +
>> +EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE Fadt = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE,
>> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE,
>> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_REVISION
>> + ),
>> + 0, // UINT32 FirmwareCtrl
>> + 0, // UINT32 Dsdt
>> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved0
>> + EFI_ACPI_6_3_PM_PROFILE_PERFORMANCE_SERVER, // UINT8 PreferredPmProfile
>> + 0, // UINT16 SciInt
>> + 0, // UINT32 SmiCmd
>> + 0, // UINT8 AcpiEnable
>> + 0, // UINT8 AcpiDisable
>> + 0, // UINT8 S4BiosReq
>> + 0, // UINT8 PstateCnt
>> + 0, // UINT32 Pm1aEvtBlk
>> + 0, // UINT32 Pm1bEvtBlk
>> + 0, // UINT32 Pm1aCntBlk
>> + 0, // UINT32 Pm1bCntBlk
>> + 0, // UINT32 Pm2CntBlk
>> + 0, // UINT32 PmTmrBlk
>> + 0, // UINT32 Gpe0Blk
>> + 0, // UINT32 Gpe1Blk
>> + 0, // UINT8 Pm1EvtLen
>> + 0, // UINT8 Pm1CntLen
>> + 0, // UINT8 Pm2CntLen
>> + 0, // UINT8 PmTmrLen
>> + 0, // UINT8 Gpe0BlkLen
>> + 0, // UINT8 Gpe1BlkLen
>> + 0, // UINT8 Gpe1Base
>> + 0, // UINT8 CstCnt
>> + 0, // UINT16 PLvl2Lat
>> + 0, // UINT16 PLvl3Lat
>> + 0, // UINT16 FlushSize
>> + 0, // UINT16 FlushStride
>> + 0, // UINT8 DutyOffset
>> + 0, // UINT8 DutyWidth
>> + 0, // UINT8 DayAlrm
>> + 0, // UINT8 MonAlrm
>> + 0, // UINT8 Century
>> + 0, // UINT16 IaPcBootArch
>> + 0, // UINT8 Reserved1
>> + FADT_FLAGS, // UINT32 Flags
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE ResetReg
>> + 0, // UINT8 ResetValue
>> + EFI_ACPI_6_3_ARM_PSCI_COMPLIANT, // UINT16 ArmBootArchFlags
>> + EFI_ACPI_6_3_FIXED_ACPI_DESCRIPTION_TABLE_MINOR_REVISION, // UINT8 MinorRevision
>> + 0, // UINT64 XFirmwareCtrl
>> + 0, // UINT64 XDsdt
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aEvtBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bEvtBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1aCntBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm1bCntBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPm2CntBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XPmTmrBlk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe0Blk
>> + NULL_GAS, // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE XGpe1Blk
>> + ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepControlReg
>> + ARM_GAS32(0), // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE SleepStatusReg
>> + 0 // UINT64 HypervisorVendorIdentity
>> +};
>> +
>> +//
>> +// Reference the table being generated to prevent the optimizer from removing the
>> +// data structure from the executable
>> +//
>> +VOID* CONST ReferenceAcpiTable = &Fadt;
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
>> new file mode 100644
>> index 000000000000..3824bd6bb956
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc
>> @@ -0,0 +1,180 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Library/PcdLib.h>
>> +#include <Library/AcpiLib.h>
>> +#include <IndustryStandard/Acpi63.h>
>> +#include <AcpiHeader.h>
>> +
>> +#define SYSTEM_TIMER_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
>> +#define CNT_READ_BASE_ADDRESS 0xFFFFFFFFFFFFFFFF
>> +
>> +#define SECURE_TIMER_EL1_GSIV 0x1D
>> +#define NON_SECURE_TIMER_EL1_GSIV 0x1E
>> +#define VIRTUAL_TIMER_GSIV 0x1B
>> +#define NON_SECURE_EL2_GSIV 0x1A
>> +
>> +#define GTDT_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_MODE
>> +#define GTDT_TIMER_LEVEL_TRIGGERED 0
>> +#define GTDT_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
>> +#define GTDT_TIMER_ACTIVE_HIGH 0
>> +#define GTDT_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_TIMER_FLAG_ALWAYS_ON_CAPABILITY
>> +#define GTDT_TIMER_LOSE_CONTEXT 0
>> +
>> +#define GTDT_GTIMER_FLAGS (GTDT_TIMER_LOSE_CONTEXT | GTDT_TIMER_ACTIVE_HIGH | GTDT_TIMER_LEVEL_TRIGGERED)
>> +
>> +#define WATCHDOG_COUNT FixedPcdGet32 (PcdWatchdogCount)
>> +#define PLATFORM_TIMER_COUNT (WATCHDOG_COUNT + 1)
>> +#define TIMER_FRAMES_COUNT 3
>> +
>> +#define GT_BLOCK_CTL_BASE 0x0000100002700000
>> +#define GT_BLOCK_FRAME0_CTL_BASE 0x0000100002710000
>> +#define GT_BLOCK_FRAME0_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
>> +#define GT_BLOCK_FRAME0_GSIV 0x58
>> +
>> +#define GT_BLOCK_FRAME1_CTL_BASE 0x0000100002720000
>> +#define GT_BLOCK_FRAME1_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
>> +#define GT_BLOCK_FRAME1_GSIV 0x59
>> +
>> +#define GT_BLOCK_FRAME2_CTL_BASE 0x0000100002730000
>> +#define GT_BLOCK_FRAME2_CTL_EL0_BASE 0xFFFFFFFFFFFFFFFF
>> +#define GT_BLOCK_FRAME2_GSIV 0x5A
>> +
>> +#define GTX_TIMER_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_MODE
>> +#define GTX_TIMER_LEVEL_TRIGGERED 0
>> +#define GTX_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_FLAG_TIMER_INTERRUPT_POLARITY
>> +#define GTX_TIMER_ACTIVE_HIGH 0
>> +
>> +#define GTX_TIMER_FLAGS (GTX_TIMER_ACTIVE_HIGH | GTX_TIMER_LEVEL_TRIGGERED)
>> +
>> +#define GTX_TIMER_SECURE EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_SECURE_TIMER
>> +#define GTX_TIMER_NON_SECURE 0
>> +#define GTX_TIMER_SAVE_CONTEXT EFI_ACPI_6_3_GTDT_GT_BLOCK_COMMON_FLAG_ALWAYS_ON_CAPABILITY
>> +#define GTX_TIMER_LOSE_CONTEXT 0
>> +
>> +#define GTX_COMMON_FLAGS_S (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_SECURE)
>> +#define GTX_COMMON_FLAGS_NS (GTX_TIMER_SAVE_CONTEXT | GTX_TIMER_NON_SECURE)
>> +
>> +#define SBSA_WATCHDOG_REFRESH_BASE 0x00001000027D0000
>> +#define SBSA_WATCHDOG_CONTROL_BASE 0x00001000027C0000
>> +#define SBSA_WATCHDOG_GSIV 0x5C
>> +
>> +#define SBSA_WATCHDOG_EDGE_TRIGGERED EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_MODE
>> +#define SBSA_WATCHDOG_LEVEL_TRIGGERED 0
>> +#define SBSA_WATCHDOG_ACTIVE_LOW EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_TIMER_INTERRUPT_POLARITY
>> +#define SBSA_WATCHDOG_ACTIVE_HIGH 0
>> +#define SBSA_WATCHDOG_SECURE EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_FLAG_SECURE_TIMER
>> +#define SBSA_WATCHDOG_NON_SECURE 0
>> +
>> +#define SBSA_WATCHDOG_FLAGS (SBSA_WATCHDOG_NON_SECURE | SBSA_WATCHDOG_ACTIVE_HIGH | SBSA_WATCHDOG_LEVEL_TRIGGERED)
>> +
>> +#pragma pack (1)
>> +
>> +typedef struct {
>> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE Gtdt;
>> + EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE GtBlock;
>> + EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE Frames[TIMER_FRAMES_COUNT];
>> +#if (WATCHDOG_COUNT != 0)
>> + EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE Watchdogs[WATCHDOG_COUNT];
>> +#endif
>> +} EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES;
>> +
>> +#pragma pack ()
>> +
>> +EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES Gtdt = {
>> + {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_SIGNATURE,
>> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLES,
>> + EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE_REVISION
>> + ),
>> + SYSTEM_TIMER_BASE_ADDRESS, // UINT64 CntControlBasePhysicalAddress
>> + EFI_ACPI_RESERVED_DWORD, // UINT32 Reserved
>> + SECURE_TIMER_EL1_GSIV, // UINT32 SecurePL1TimerGSIV
>> + GTDT_GTIMER_FLAGS, // UINT32 SecurePL1TimerFlags
>> + NON_SECURE_TIMER_EL1_GSIV, // UINT32 NonSecurePL1TimerGSIV
>> + GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL1TimerFlags
>> + VIRTUAL_TIMER_GSIV, // UINT32 VirtualTimerGSIV
>> + GTDT_GTIMER_FLAGS, // UINT32 VirtualTimerFlags
>> + NON_SECURE_EL2_GSIV, // UINT32 NonSecurePL2TimerGSIV
>> + GTDT_GTIMER_FLAGS, // UINT32 NonSecurePL2TimerFlags
>> + CNT_READ_BASE_ADDRESS, // UINT64 CntReadBasePhysicalAddress
>> + PLATFORM_TIMER_COUNT, // UINT32 PlatformTimerCount
>> + sizeof (EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE), // UINT32 PlatformTimerOffset
>> + },
>> + {
>> + EFI_ACPI_6_3_GTDT_GT_BLOCK, // UINT8 Type
>> + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT16 Length
>> + + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_STRUCTURE) *
>> + TIMER_FRAMES_COUNT,
>> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
>> + GT_BLOCK_CTL_BASE, // UINT64 CntCtlBase
>> + TIMER_FRAMES_COUNT, // UINT32 GTBlockTimerCount
>> + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT32 GTBlockTimerOffset
>> + },
>> + {
>> + {
>> + 0, // UINT8 GTFrameNumber
>> + {EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
>> + GT_BLOCK_FRAME0_CTL_BASE, // UINT64 CntBaseX
>> + GT_BLOCK_FRAME0_CTL_EL0_BASE, // UINT64 CntEL0BaseX
>> + GT_BLOCK_FRAME0_GSIV, // UINT32 GTxPhysicalTimerGSIV
>> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
>> + 0, // UINT32 GTxVirtualTimerGSIV
>> + 0, // UINT32 GTxVirtualTimerFlags
>> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
>> + },
>> + {
>> + 1, // UINT8 GTFrameNumber
>> + {EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
>> + GT_BLOCK_FRAME1_CTL_BASE, // UINT64 CntBaseX
>> + GT_BLOCK_FRAME1_CTL_EL0_BASE, // UINT64 CntEL0BaseX
>> + GT_BLOCK_FRAME1_GSIV, // UINT32 GTxPhysicalTimerGSIV
>> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
>> + 0, // UINT32 GTxVirtualTimerGSIV
>> + 0, // UINT32 GTxVirtualTimerFlags
>> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
>> + },
>> + {
>> + 2, // UINT8 GTFrameNumber
>> + {EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reserved[3]
>> + GT_BLOCK_FRAME2_CTL_BASE, // UINT64 CntBaseX
>> + GT_BLOCK_FRAME2_CTL_EL0_BASE, // UINT64 CntEL0BaseX
>> + GT_BLOCK_FRAME2_GSIV, // UINT32 GTxPhysicalTimerGSIV
>> + GTX_TIMER_FLAGS, // UINT32 GTxPhysicalTimerFlags
>> + 0, // UINT32 GTxVirtualTimerGSIV
>> + 0, // UINT32 GTxVirtualTimerFlags
>> + GTX_COMMON_FLAGS_NS // UINT32 GTxCommonFlags
>> + },
>> + },
>> +#if (WATCHDOG_COUNT != 0)
>> + {
>> + {
>> + EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG, // UINT8 Type
>> + sizeof(EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE), // UINT16 Length
>> + EFI_ACPI_RESERVED_BYTE, // UINT8 Reserved
>> + SBSA_WATCHDOG_REFRESH_BASE, // UINT64 RefreshFramePhysicalAddress
>> + SBSA_WATCHDOG_CONTROL_BASE, // UINT64 WatchdogControlFramePhysicalAddress
>> + SBSA_WATCHDOG_GSIV, // UINT32 WatchdogTimerGSIV
>> + SBSA_WATCHDOG_FLAGS // UINT32 WatchdogTimerFlags
>> + }
>> + }
>> +#endif
>> +};
>> +
>> +//
>> +// Reference the table being generated to prevent the optimizer from removing the
>> +// data structure from the executable
>> +//
>> +VOID* CONST ReferenceAcpiTable = &Gtdt;
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
>> new file mode 100644
>> index 000000000000..4413428719b8
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl
>> @@ -0,0 +1,330 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +[0004] Signature : "HEST" [Hardware Error Source Table]
>> +[0004] Table Length : 00000308
>> +[0001] Revision : 01
>> +[0001] Checksum : 20
>> +[0006] Oem ID : "Ampere"
>> +[0008] Oem Table ID : "Altra "
>> +[0004] Oem Revision : 00000001
>> +[0004] Asl Compiler ID : "INTL"
>> +[0004] Asl Compiler Revision : 20100528
>> +
>> +[0004] Error Source Count : 00000008
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0000
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200000
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1D00000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0001
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200008
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 00 [Polled]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1C00000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0002
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200010
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1F00000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0006
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200030
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1900000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0007
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200038
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000100000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1900001
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0003
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200018
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000500000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1D00000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0004
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200020
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 00 [Polled]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000500000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1C00000
>> +
>> +[0002] Subtable Type : 000A [Generic Hardware Error Source v2]
>> +[0002] Source Id : 0005
>> +[0002] Related Source Id : FFFF
>> +[0001] Reserved : 00
>> +[0001] Enabled : 01
>> +[0004] Records To Preallocate : 00000001
>> +[0004] Max Sections Per Record : 00000001
>> +[0004] Max Raw Data Length : 00001000
>> +
>> +[0012] Error Status Address : [Generic Address Structure]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000000088200028
>> +
>> +[0028] Notify : [Hardware Error Notification Structure]
>> +[0001] Notify Type : 03 [SCI]
>> +[0001] Notify Length : 1C
>> +[0002] Configuration Write Enable : 0000
>> +[0004] PollInterval : 00000BB8
>> +[0004] Vector : 00000000
>> +[0004] Polling Threshold Value : 00000000
>> +[0004] Polling Threshold Window : 00000000
>> +[0004] Error Threshold Value : 00000000
>> +[0004] Error Threshold Window : 00000000
>> +
>> +[0004] Error Status Block Length : 00001000
>> +
>> +[0012] Read Ack Register : [Generic Address Structure v2]
>> +[0001] Space ID : 00 [SystemMemory]
>> +[0001] Bit Width : 40
>> +[0001] Bit Offset : 00
>> +[0001] Encoded Access Width : 04 [QWord Access:64]
>> +[0008] Address : 0000500000543010
>> +
>> +[0008] Read Ack Preserve : 00000000
>> +[0008] Read Ack Write : B1F00000
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
>> new file mode 100644
>> index 000000000000..3c0a048552cf
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Sdei.asl
>> @@ -0,0 +1,17 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +[0004] Signature : "SDEI"
>> +[0004] Table Length : 0000003E
>> +[0001] Revision : 01
>> +[0001] Checksum : 59
>> +[0006] Oem ID : "Ampere"
>> +[0008] Oem Table ID : "Altra "
>> +[0004] Oem Revision : 00000001
>> +[0004] Asl Compiler ID : "INTL"
>> +[0004] Asl Compiler Revision : 20160930
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
>> new file mode 100644
>> index 000000000000..42042f8a3474
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Spcr.aslc
>> @@ -0,0 +1,81 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +#include <Library/PcdLib.h>
>> +#include <Library/AcpiLib.h>
>> +#include <IndustryStandard/Acpi63.h>
>> +#include <IndustryStandard/SerialPortConsoleRedirectionTable.h>
>> +#include <AcpiHeader.h>
>> +
>> +STATIC EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE Spcr = {
>> + __ACPI_HEADER (
>> + EFI_ACPI_6_3_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_SIGNATURE,
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE,
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_REVISION
>> + ),
>> + // UINT8 InterfaceType;
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERFACE_TYPE_ARM_PL011_UART,
>> + // UINT8 Reserved1[3];
>> + {
>> + EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE,
>> + EFI_ACPI_RESERVED_BYTE
>> + },
>> + // EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE BaseAddress;
>> + ARM_GAS32 (FixedPcdGet64 (PcdSerialRegisterBase)),
>> + // UINT8 InterruptType;
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_INTERRUPT_TYPE_GIC,
>> + // UINT8 Irq;
>> + 0, // Not used on ARM
>> + // UINT32 GlobalSystemInterrupt;
>> + FixedPcdGet32 (PL011UartInterrupt),
>> + // UINT8 BaudRate;
>> +#if (FixedPcdGet64 (PcdUartDefaultBaudRate) == 9600)
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_9600,
>> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 19200)
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_19200,
>> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 57600)
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_57600,
>> +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) == 115200)
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_115200,
>> +#else
>> +#error Unsupported SPCR Baud Rate
>> +#endif
>> + // UINT8 Parity;
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_PARITY_NO_PARITY,
>> + // UINT8 StopBits;
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_STOP_BITS_1,
>> + // UINT8 FlowControl;
>> + 0,
>> + // UINT8 TerminalType;
>> + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_TERMINAL_TYPE_VT_UTF8,
>> + // UINT8 Reserved2;
>> + EFI_ACPI_RESERVED_BYTE,
>> + // UINT16 PciDeviceId;
>> + 0xFFFF,
>> + // UINT16 PciVendorId;
>> + 0xFFFF,
>> + // UINT8 PciBusNumber;
>> + 0x00,
>> + // UINT8 PciDeviceNumber;
>> + 0x00,
>> + // UINT8 PciFunctionNumber;
>> + 0x00,
>> + // UINT32 PciFlags;
>> + 0x00000000,
>> + // UINT8 PciSegment;
>> + 0x00,
>> + // UINT32 Reserved3;
>> + EFI_ACPI_RESERVED_DWORD
>> +};
>> +
>> +//
>> +// Reference the table being generated to prevent the optimizer from removing the
>> +// data structure from the executable
>> +//
>> +VOID* CONST ReferenceAcpiTable = &Spcr;
>> diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
>> new file mode 100755
>> index 000000000000..cdb4bf5de9bf
>> --- /dev/null
>> +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl
>> @@ -0,0 +1,15 @@
>> +/** @file
>> +
>> + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved.<BR>
>> +
>> + SPDX-License-Identifier: BSD-2-Clause-Patent
>> +
>> +**/
>> +
>> +DefinitionBlock("Ssdt.aml", "SSDT", 2, "Ampere", "Altra ", 0x00000001)
>> +{
>> + Method (MAIN, 0, NotSerialized)
>> + {
>> + Return (Zero)
>> + }
>> +}
>> --
>> 2.17.1
>>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#76547): https://edk2.groups.io/g/devel/message/76547
Mute This Topic: https://groups.io/mt/83097115/1787277
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org]
-=-=-=-=-=-=-=-=-=-=-=-
© 2016 - 2026 Red Hat, Inc.