[edk2-devel] [edk2-platforms][PATCH v2 13/32] AmpereAltraPkg, JadePkg: Add ACPI support

Nhi Pham via groups.io nhi=os.amperecomputing.com at groups.io
Wed May 26 10:07:05 UTC 2021


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 at os.amperecomputing.com>
Cc: Chuong Tran <chuong at os.amperecomputing.com>
Cc: Phong Vo <phong at os.amperecomputing.com>
Cc: Leif Lindholm <leif at nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney at intel.com>
Cc: Ard Biesheuvel <ardb+tianocore at kernel.org>
Cc: Nate DeSimone <nathaniel.l.desimone at intel.com>

Signed-off-by: Nhi Pham <nhi at 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/1813853
Group Owner: devel+owner at edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [edk2-devel-archive at redhat.com]
-=-=-=-=-=-=-=-=-=-=-=-






More information about the edk2-devel-archive mailing list