From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from NAM12-MW2-obe.outbound.protection.outlook.com (NAM12-MW2-obe.outbound.protection.outlook.com [40.107.244.126]) by mx.groups.io with SMTP id smtpd.web09.4678.1634883616924388148 for ; Thu, 21 Oct 2021 23:20:17 -0700 Authentication-Results: mx.groups.io; dkim=fail reason="body hash did not verify" header.i=@os.amperecomputing.com header.s=selector2 header.b=Q0SM+9DB; spf=pass (domain: os.amperecomputing.com, ip: 40.107.244.126, mailfrom: nhi@os.amperecomputing.com) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=jyUnMK+dotPUfrG08888Y+BEZ5meAeQ43c9LPmGFXo4awt5Zdpnhpo+25UXWHotrpUZ7Z3gGGPcVlOBMTMbLhkKwQ+mAzHm6H7PNdgb08sB4WH2mR6mvdfaiK4mHPf8kwfbJHqN2qdxWa3KMyMuOws9lzm77j2mPqF5XsvJ9a7N2/C+BD/FUznYphEijdrGq6tw7gw77BRQU3OBunUzlZ/XIfWxkWdEJMklgin/v1BeqMDoMlTaVT/pWFdmtzTORogmxN/KVyiLpcNZWxVaqr1mzKq1rlIvJ/klZLwDUWSVpWnLqOblVpcd4z+UMe0D9GAQAvzerJTNWgF3XG7ZD0A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=NRI0B44GnnFZyCXoEqFb3nPNjqOa5Fqq08LcyDJORzI=; b=ZDfpMTOem0YzONUgPvfm6g206hA02wAciI8oiU2FTUEBzirKmrq3PXoucnR5TiZmZup7zXvLDkL0udvXn6UUEYqyOsEjYWz1zzk3J1BGBS5VHsL6N75YanozCsu/OO1jB+jhxGLzfSeYjeRJI54pFlUb1Dwh2maN8ASPkReL3UR63IZF2mYSkI8KZ4kwE9aDSkQD9sThGuFVgZti+uT35n4DQ2pyQ17Gn3TTLkTeEcvpz5zhmqEzDil/EQEYVjWJqY1xxFIN3r539K08SbkR/U3pLPR+TzBqK8il9NZFG2SzjwesbW1QRFfWyoOfQ2WIFQYYmbxbfMt1RBhVOeMrCQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=os.amperecomputing.com; dmarc=pass action=none header.from=os.amperecomputing.com; dkim=pass header.d=os.amperecomputing.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=os.amperecomputing.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=NRI0B44GnnFZyCXoEqFb3nPNjqOa5Fqq08LcyDJORzI=; b=Q0SM+9DBuFyg5YEJ8pOF6GCxrVYQ+h1MVdwPHKbKJxMMW8Zh4tcHm/3MiWFz6GfuJ+wKHkRatQzqPeKQ9j7q5aI/TIlXZf3b/AQRs2g2S4YqxiYAYuaUB4yKeC/KRbt+fN5evmuAvYeugF49fZrrGGVe8RqS8MmSyp3Xd0HoycI= Authentication-Results: edk2.groups.io; dkim=none (message not signed) header.d=none;edk2.groups.io; dmarc=none action=none header.from=os.amperecomputing.com; Received: from PH0PR01MB7287.prod.exchangelabs.com (2603:10b6:510:10a::21) by PH0PR01MB6103.prod.exchangelabs.com (2603:10b6:510:13::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4608.16; Fri, 22 Oct 2021 06:19:58 +0000 Received: from PH0PR01MB7287.prod.exchangelabs.com ([fe80::254c:9533:7f35:aee]) by PH0PR01MB7287.prod.exchangelabs.com ([fe80::254c:9533:7f35:aee%4]) with mapi id 15.20.4628.016; Fri, 22 Oct 2021 06:19:58 +0000 From: "Nhi Pham" To: devel@edk2.groups.io CC: patches@amperecomputing.com, nhi@os.amperecomputing.com, vunguyen@os.amperecomputing.com, Thang Nguyen , Chuong Tran , Phong Vo , Leif Lindholm , Michael D Kinney , Ard Biesheuvel , Nate DeSimone Subject: [edk2-platforms][PATCH v4 10/31] AmpereAltraPkg, JadePkg: Add ACPI support Date: Fri, 22 Oct 2021 13:17:48 +0700 Message-ID: <20211022061809.31087-11-nhi@os.amperecomputing.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20211022061809.31087-1-nhi@os.amperecomputing.com> References: <20211022061809.31087-1-nhi@os.amperecomputing.com> X-ClientProxiedBy: HK2PR02CA0168.apcprd02.prod.outlook.com (2603:1096:201:1f::28) To PH0PR01MB7287.prod.exchangelabs.com (2603:10b6:510:10a::21) Return-Path: nhi@os.amperecomputing.com MIME-Version: 1.0 Received: from sw004.amperecomputing.com (118.69.219.201) by HK2PR02CA0168.apcprd02.prod.outlook.com (2603:1096:201:1f::28) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4628.16 via Frontend Transport; Fri, 22 Oct 2021 06:19:55 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 418f96a6-837f-4146-f149-08d99523f896 X-MS-TrafficTypeDiagnostic: PH0PR01MB6103: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:4714; X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 2E41L9l0QUsPX9s8FMrOIxRMGS++DyU5WgPueUUVgJVS1dqEsbCSrhC91vI/pjGzSGCwhVLqzHYKRtu91bEEN8g/LG7WPO0ZQpv42bCXJPKXDd+bYO55gvqZ1DuODnaoXiO6Bm7Dxq4IKhm3F6JJNO8f6p67BBBvYJ0a62pCwYkx0x0VhDK1kcPIDzkqYWaWYHmfrFUiHhgdKJ1gsagggBzaW45gN46/upFa5SPtIdMf4DcotN5M2a4LqzfZqw3GsrH0jh+B3BmhT3OVh0YfnfqsVTcjTQCaY9koFb8S9BEAzMnFIXfhgB4gDE5Gav3fIY4ZkiaySaLUlmkaW7ffmFBL3PMGOleo7gJfEWT9lmnfbGd0+9Jec1W2nS1yJE1W/LL9C616L4kK6b/LRcIZam75J2bZDPobLxio/c+DHyC+ADx17+fIqxQs0yq50LbjpH7Xso5QvmFxJ67JbEwL1aRFVXe+WeAJRy8PWnif7q7vnorgxN/RvqKC6jwcgSFizn65yEJYz9HiITSY4VaaN05SSUWkQeak+3TXn5O0+Ct93N2BVTK8ZvyqfgoF6o4pM77O7P7ErxrbDpcSZOqcQsf66bmaUB4CZIU6jl2J1OPxRehwBkpF/mz169o89pd9ijhrVaYXhIalBN8dkSFCIXEe2deGeAY753R7MgCKUXfUgSQ8ScI+0jCyqjMYWDtGfDmtBKoeCxK6Kr5nbE3LMmM/llZX0b9W8yGkWtvDmnh++lFGwkghfOfOZm/pJ+tk8xfCfU+YvYN+AOpn1Q1G6RBz79sHWGjk6zNmrKy/oN4FnEf+mxh2QvpFyMLRjcAi X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:PH0PR01MB7287.prod.exchangelabs.com;PTR:;CAT:NONE;SFS:(4636009)(366004)(5660300002)(2906002)(86362001)(38100700002)(19627235002)(508600001)(66946007)(6916009)(316002)(186003)(66476007)(4326008)(1076003)(8936002)(956004)(2616005)(8676002)(83380400001)(6512007)(6486002)(26005)(52116002)(66556008)(30864003)(38350700002)(54906003)(6666004)(6506007)(966005)(559001)(569008)(579004)(44824005);DIR:OUT;SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?VKoRZGsE8bSz9W1St9DTVPfDaUz3lPsFuJPs7c5PLzVhSrYP2PTlMxscq1iH?= =?us-ascii?Q?OGE4VPYUvkqrcdWIH055Ro4D8Tl4tz25HEHfeLYPH8vndWsW9zJOgyovS9Wi?= =?us-ascii?Q?tZziZhgf2Cm7ZoyNpcY0ldkzIx8g/BNoGc1lb3hVEHDTNWpJPlpu2JUnlIvY?= =?us-ascii?Q?WMPWjqsg7jobW/ZSVrP5mFzgE+OactgRJj+/35s/MWAthl9jHmUxchvMnPq8?= =?us-ascii?Q?34o2dF+bIEVuMh3DB6w8APd6gc/WWekJ4CHpSdXJNYiyv52jwzCOKb9twDn6?= =?us-ascii?Q?hJGQVNaDrLN1ETqBrw9L8D6ut5EJzx9wuTOG5vk6OcI1UgMDMXvo0kudROqu?= =?us-ascii?Q?PkUGWZn11SqNLOaGm55WhqkDVFgOU2r7SQs+mcGZ/ji1/SDR6mnqzFFk9EQ+?= =?us-ascii?Q?+WP1tQDrToF+CpGJnZMMgAY29WDmzG/XJUc0N9keExdobsaGbBpaxqFlEPlI?= =?us-ascii?Q?X6A0P5wzgwuAESmDrNn7bQ6u9u9VTg8IzUQ4Ze0SYKRT4EpGIwU+FADzeCxi?= =?us-ascii?Q?mHsNLZ7OHltA1MqEpP4+0uFRgsV64uqs0DxhisFv3UI2+vaWb8E2LEvaLH1+?= =?us-ascii?Q?hGuOmgObl9SSJTtQVFp2OZ9P2Rt/YswZaifUsd4akUNPPHCk9gUhKTuhZhfD?= =?us-ascii?Q?yl9vi69ZWMXoyaiRyKg7nF7wgJcjL4AaXMhrQWDfVtk/lGwMcOFsG1RasZhh?= =?us-ascii?Q?z53WsWgAoHf5D/Tfm1LRTV9ApHj/wLY54BOgEffMdPdhRZQIhDSc+cLEPZms?= =?us-ascii?Q?fxtquwZYWYzaJv61b2L13plqkH5OMvPtl7FIbnb06YvxvGUMiZ2Kvkzs6fCu?= =?us-ascii?Q?Fl7MM9GFHypxc1XUDR695z+G1k915y3lANiO3d4xIdBp3YWbQm/h9wHTERL0?= =?us-ascii?Q?N1RdmXUQoFhaBS8Rcor15dmqkAENx/u6zKsrZhjpV3vr4y/XWjalimwkySpk?= =?us-ascii?Q?9SMEL7GrYYU61Rhzm0ZcpwmZYq32J9ZbSQBZrMRnoc+Lkd/twmoCtiRfHXTs?= =?us-ascii?Q?XNssB1knc2xb2EKw27Xcy+LudJk94MOU38fvsbFlduI0tLsDK39Y1G6d0ByV?= =?us-ascii?Q?tTiz0zrQzzmEzmWR1dZ4gPWGu1HrxeNwfIIJyftXT6sYuycGpTbLdxfsECjL?= =?us-ascii?Q?WM+cKCyv/48xccz3nVuR2H/gsPY0x+oQ+oj63hd/BiFeyDA8J1B0ZK05Smmq?= =?us-ascii?Q?/SdwB+GSPlpcI783BeI3UkBFQ/AUAa6Fm0SW5EzTPRd5mZmTxWWg3V5n9ZAY?= =?us-ascii?Q?22PJ50f4wSM06LqRAzi1QAw64jJzvTCl8km0HQEPMLSLzoWmkzKDXVVQYkqZ?= =?us-ascii?Q?g/EWwputfIMId1vcWQV+PrH3?= X-OriginatorOrg: os.amperecomputing.com X-MS-Exchange-CrossTenant-Network-Message-Id: 418f96a6-837f-4146-f149-08d99523f896 X-MS-Exchange-CrossTenant-AuthSource: PH0PR01MB7287.prod.exchangelabs.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 22 Oct 2021 06:19:58.4357 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3bc2b170-fd94-476d-b0ce-4229bdc904a7 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: nhi@amperemail.onmicrosoft.com X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH0PR01MB6103 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain 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 Cc: Chuong Tran Cc: Phong Vo Cc: Leif Lindholm Cc: Michael D Kinney Cc: Ard Biesheuvel Cc: Nate DeSimone Signed-off-by: Nhi Pham Acked-by: Leif Lindholm --- Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc | 8= + Platform/Ampere/JadePkg/Jade.dsc | 20= + Platform/Ampere/JadePkg/Jade.fdf | 8= + Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf | 20= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf | 76= + Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTables.inf | 44= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h | 131= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h | 50= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h | 74= + Silicon/Ampere/AmpereAltraPkg/Include/AcpiHeader.h | 37= + Silicon/Ampere/AmpereAltraPkg/Include/Platform/Ac01.h | 140= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c | 435= ++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c | 601= +++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c | 348= ++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c | 596= +++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c | 413= ++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c | 178= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c | 333= ++ Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c | 187= + Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c | 271= + 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 | 531= ++ 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= + 40 files changed, 24580 insertions(+) diff --git a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc b/Silicon= /Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc index be2d2f5852f6..c01a8be3c607 100644 --- a/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc +++ b/Silicon/Ampere/AmpereAltraPkg/AmpereAltraPkg.dsc.inc @@ -467,6 +467,14 @@ [PcdsFixedAtBuild.common] # gEfiMdeModulePkgTokenSpaceGuid.PcdBootManagerMenuFile|{ 0x21, 0xaa, 0x2c= , 0x46, 0x14, 0x76, 0x03, 0x45, 0x83, 0x6e, 0x8a, 0xb6, 0xf4, 0x66, 0x23, 0= x31 } =20 + # + # ACPI table + # + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId|"Ampere" + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId|0x2020206172746C= 41 # Altra + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId|0x2E504D41 # AMP. + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision|0x01000013 + # # Enable strict image permissions for all images. (This applies # only to images that were built with >=3D 4 KB section alignment.) diff --git a/Platform/Ampere/JadePkg/Jade.dsc b/Platform/Ampere/JadePkg/Jad= e.dsc index 0dd30dc14841..e4b29e36fc8d 100644 --- a/Platform/Ampere/JadePkg/Jade.dsc +++ b/Platform/Ampere/JadePkg/Jade.dsc @@ -77,12 +77,22 @@ [LibraryClasses] # RealTimeClockLib|Platform/Ampere/JadePkg/Library/PCF85063RealTimeClockLi= b/PCF85063RealTimeClockLib.inf =20 + # + # ACPI Libraries + # + AcpiLib|EmbeddedPkg/Library/AcpiLib/AcpiLib.inf + ##########################################################################= ###### # # Specific Platform Pcds # ##########################################################################= ###### [PcdsFeatureFlag.common] + # + # Activate AcpiSdtProtocol + # + gEfiMdeModulePkgTokenSpaceGuid.PcdInstallAcpiSdtProtocol|TRUE + [PcdsFixedAtBuild.common] # # Platform config UUID @@ -104,3 +114,13 @@ [PcdsFixedAtBuild.common] # ##########################################################################= ###### [Components.common] + # + # ACPI + # + MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf { + + 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/Jad= e.fdf index 5727d8706240..122a5b446302 100644 --- a/Platform/Ampere/JadePkg/Jade.fdf +++ b/Platform/Ampere/JadePkg/Jade.fdf @@ -289,4 +289,12 @@ [FV.FvMain] # !include NetworkPkg/Network.fdf.inc =20 + # + # ACPI + # + INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf + INF Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf + INF RuleOverride=3DACPITABLE Silicon/Ampere/AmpereAltraPkg/AcpiCommonTab= les/AcpiCommonTables.inf + INF RuleOverride=3DACPITABLE Platform/Ampere/JadePkg/AcpiTables/AcpiTabl= es.inf + !include Silicon/Ampere/AmpereSiliconPkg/FvRules.fdf.inc diff --git a/Platform/Ampere/JadePkg/AcpiTables/AcpiTables.inf b/Platform/A= mpere/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. +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +## + +[Defines] + INF_VERSION =3D 0x0001001B + BASE_NAME =3D JadeAcpiTables + FILE_GUID =3D 5ADDBC13-8634-480C-9B94-671B7855CDB8 + MODULE_TYPE =3D USER_DEFINED + VERSION_STRING =3D 1.0 + +[Sources] + Dsdt.asl + +[Packages] + MdePkg/MdePkg.dec diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDx= e.inf b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf new file mode 100644 index 000000000000..72e78fb4e31e --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.inf @@ -0,0 +1,76 @@ +## @file +# +# Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +## + +[Defines] + INF_VERSION =3D 0x0001001B + BASE_NAME =3D AcpiPlatformDxe + FILE_GUID =3D CDA4ED56-6960-4092-885D-FEF37D29093E + MODULE_TYPE =3D DXE_DRIVER + VERSION_STRING =3D 1.0 + ENTRY_POINT =3D AcpiPlatformDxeInitialize + +[Sources.common] + AcpiApei.c + AcpiApei.h + AcpiDsdt.c + AcpiMadt.c + AcpiNfit.c + AcpiPcct.c + AcpiPlatform.h + AcpiPlatformDxe.c + AcpiPptt.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] + AcpiLib + AmpereCpuLib + ArmLib + BaseLib + DebugLib + FlashLib + MailboxInterfaceLib + SystemFirmwareInterfaceLib + TimerLib + UefiBootServicesTableLib + UefiDriverEntryPoint + UefiLib + +[Pcd] + gArmPlatformTokenSpaceGuid.PcdCoreCount + gArmPlatformTokenSpaceGuid.PcdClusterCount + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemId + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemTableId + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorId + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision + gAmpereTokenSpaceGuid.PcdPmproDbBaseReg + gAmpereTokenSpaceGuid.PcdSmproDbBaseReg + +[Guids] + gArmMpCoreInfoGuid + gEfiAcpiTableGuid + gEfiEventReadyToBootGuid + gPlatformInfoHobGuid + +[Protocols] + gEfiAcpiTableProtocolGuid ## ALWAYS_CONSUMED + gEfiAcpiSdtProtocolGuid + gEfiPciRootBridgeIoProtocolGuid + +[Depex] + gEfiAcpiTableProtocolGuid diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/AcpiCommonTable= s.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. +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +## + +[Defines] + INF_VERSION =3D 0x0001001B + BASE_NAME =3D AcpiCommonTables + FILE_GUID =3D CEFA2AEB-357E-4F48-8066-EA950853056E + MODULE_TYPE =3D USER_DEFINED + VERSION_STRING =3D 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 ## CONSU= MES + gArmPlatformTokenSpaceGuid.PL011UartInterrupt ## CONSU= MES + gArmPlatformTokenSpaceGuid.PcdWatchdogCount ## CONSU= MES + + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultOemRevision ## CONSU= MES + gEfiMdeModulePkgTokenSpaceGuid.PcdAcpiDefaultCreatorRevision ## CONSU= MES + + gArmPlatformTokenSpaceGuid.PcdSerialDbgRegisterBase ## CONSU= MES + gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate ## CONSU= MES diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h b/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h new file mode 100644 index 000000000000..61648f107efe --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.h @@ -0,0 +1,131 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef ACPI_APEI_H_ +#define ACPI_APEI_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#pragma pack(1) +#define BERT_MSG_SIZE 0x2C +#define BERT_UEFI_FAILURE 5 +#define BERT_DEFAULT_ERROR_SEVERITY 0x1 +#define GENERIC_ERROR_DATA_REVISION 0x300 + +#define RAS_TYPE_2P 0x03 +#define RAS_TYPE_BERT 0x3F +#define RAS_TYPE_ERROR_MASK 0x3F +#define RAS_TYPE_PAYLOAD_MASK 0xC0 +#define RAS_TYPE_PAYLOAD0 0x00 +#define RAS_TYPE_PAYLOAD1 0x40 +#define RAS_TYPE_PAYLOAD2 0x80 +#define RAS_TYPE_PAYLOAD3 0xC0 +#define RAS_TYPE_BERT_PAYLOAD3 (RAS_TYPE_BERT | RAS_TYPE_PAYLOAD3) + +#define PLAT_CRASH_ITERATOR_SIZE 0x398 +#define SMPRO_CRASH_SIZE 0x800 +#define PMPRO_CRASH_SIZE 0x800 +#define RASIP_CRASH_SIZE 0x1000 +#define HEST_NUM_ENTRIES_PER_SOC 3 + +#define CURRENT_BERT_VERSION 0x11 +#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 S0RasIpRegisters[RASIP_CRASH_SIZE]; + UINT8 S1PmproRegisters[PMPRO_CRASH_SIZE]; + UINT8 S1SmproRegisters[SMPRO_CRASH_SIZE]; + UINT8 S1RasIpRegisters[RASIP_CRASH_SIZE]; + UINT8 AtfDump[PLATFORM_CPU_MAX_NUM_CORES * PLAT_CRASH_ITE= RATOR_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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h new file mode 100644 index 000000000000..db47e422d48d --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.h @@ -0,0 +1,50 @@ +/** @file + + Copyright (c) 2021, Ampere Computing LLC. All rights reserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef ACPI_NFIT_H_ +#define ACPI_NFIT_H_ + +#include + +#define NVDIMM_SK0 0 +#define NVDIMM_SK1 1 +#define NVDIMM_NUM_PER_SK (AC01_NVDIMM_MAX_MCU_PER_SOCKET * AC01_NVDIMM_= MAX_DIMM_PER_MCU) +#define ONE_GB (1024 * 1024 * 1024) + +typedef enum { + NvdimmDisabled =3D 0, + NvdimmNonHashed, + NvdimmHashed, + NvdimmModeMax +} NVDIMM_MODE; + +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[AC01_NVDIMM_MAX_REGION_PER_SOCKET]; + 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..b5035067a47b --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatform.h @@ -0,0 +1,74 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef ACPI_PLATFORM_H_ +#define ACPI_PLATFORM_H_ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +EFI_STATUS +AcpiPatchDsdtTable ( + VOID + ); + +EFI_STATUS +AcpiInstallMadtTable ( + VOID + ); + +EFI_STATUS +AcpiInstallNfitTable ( + VOID + ); + +EFI_STATUS +AcpiPcctInitializeSharedMemory ( + 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/A= mpere/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef ACPI_HEADER_H_ +#define ACPI_HEADER_H_ + +#include + +// +// 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 (PcdAcpiDefaultCreatorRevi= sion) + +// A macro to initialise the common header part of EFI ACPI tables as defi= ned 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/Silicon/Ampere/AmpereAltraPkg/Include/Platform/Ac01.h b/Silico= n/Ampere/AmpereAltraPkg/Include/Platform/Ac01.h index 1ba1da17117e..2310e4e1ce98 100644 --- a/Silicon/Ampere/AmpereAltraPkg/Include/Platform/Ac01.h +++ b/Silicon/Ampere/AmpereAltraPkg/Include/Platform/Ac01.h @@ -89,4 +89,144 @@ // #define AC01_GPIO_PINS_PER_SOCKET 32 =20 +// +// Maximum number of memory controller supports NVDIMM-N per socket +// +#define AC01_NVDIMM_MAX_MCU_PER_SOCKET 2 + +// +// Maximum number of NVDIMM-N per memory controller +// +#define AC01_NVDIMM_MAX_DIMM_PER_MCU 1 + +// +// Maximum number of NVDIMM region per socket +// +#define AC01_NVDIMM_MAX_REGION_PER_SOCKET 2 + +// +// Socket 0 base address of NVDIMM non-hashed region 0 +// +#define AC01_NVDIMM_SK0_NHASHED_REGION0_BASE 0x0B0000000000ULL + +// +// Socket 0 base address of NVDIMM non-hashed region 1 +// +#define AC01_NVDIMM_SK0_NHASHED_REGION1_BASE 0x0F0000000000ULL + +// +// Socket 1 base address of NVDIMM non-hashed region 0 +// +#define AC01_NVDIMM_SK1_NHASHED_REGION0_BASE 0x430000000000ULL + +// +// Socket 1 base address of NVDIMM non-hashed region 1 +// +#define AC01_NVDIMM_SK1_NHASHED_REGION1_BASE 0x470000000000ULL + +// +// DIMM ID of NVDIMM-N device 1 +// +#define AC01_NVDIMM_NVD1_DIMM_ID 6 + +// +// DIMM ID of NVDIMM-N device 2 +// +#define AC01_NVDIMM_NVD2_DIMM_ID 14 + +// +// DIMM ID of NVDIMM-N device 3 +// +#define AC01_NVDIMM_NVD3_DIMM_ID 22 + +// +// DIMM ID of NVDIMM-N device 4 +// +#define AC01_NVDIMM_NVD4_DIMM_ID 30 + +// +// NFIT device handle of NVDIMM-N device 1 +// +#define AC01_NVDIMM_NVD1_DEVICE_HANDLE 0x0330 + +// +// NFIT device handle of NVDIMM-N device 2 +// +#define AC01_NVDIMM_NVD2_DEVICE_HANDLE 0x0770 + +// +// NFIT device handle of NVDIMM-N device 3 +// +#define AC01_NVDIMM_NVD3_DEVICE_HANDLE 0x1330 + +// +// NFIT device handle of NVDIMM-N device 4 +// +#define AC01_NVDIMM_NVD4_DEVICE_HANDLE 0x1770 + +// +// Interleave ways of non-hashed NVDIMM-N +// +#define AC01_NVDIMM_NHASHED_INTERLEAVE_WAYS 1 + +// +// Interleave ways of hashed NVDIMM-N +// +#define AC01_NVDIMM_HASHED_INTERLEAVE_WAYS 2 + +// +// Region offset of hashed NVDIMM-N +// +#define AC01_NVDIMM_HASHED_REGION_OFFSET 512 + +// +// The base address of GIC distributor registers +// +#define AC01_GICD_MASTER_BASE_ADDRESS 0x100100000000 + +// +// The base address of master socket GIC redistributor registers +// +#define AC01_GICR_MASTER_BASE_ADDRESS 0x100100140000 + +// +// The base address of slave socket GIC distributor registers +// +#define AC01_GICD_SLAVE_BASE_ADDRESS 0x500100000000 + +// +// The base address of slave socket GIC redistributor registers +// +#define AC01_GICR_SLAVE_BASE_ADDRESS 0x500100140000 + +// +// Socket 0 first RC +// +#define SOCKET0_FIRST_RC 2 + +// +// Socket 0 last RC +// +#define SOCKET0_LAST_RC 7 + +// +// Socket 1 first RC +// +#define SOCKET1_FIRST_RC 10 + +// +// Socket 1 last RC +// +#define SOCKET1_LAST_RC 15 + +// +// Socket bit offset of core UID. +// +#define PLATFORM_SOCKET_UID_BIT_OFFSET 16 + +// +// CPM bit offset of core UID. +// +#define PLATFORM_CPM_UID_BIT_OFFSET 8 + #endif /* PLATFORM_AC01_H_ */ diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c b/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c new file mode 100644 index 000000000000..58c511db99a7 --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiApei.c @@ -0,0 +1,435 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include + +#include +#include +#include + +#include "AcpiApei.h" + +UINT8 AMPERE_GUID[16] =3D {0x8d, 0x89, 0xed, 0xe8, 0x16, 0xdf, 0xcc, 0x43,= 0x8e, 0xcc, 0x54, 0xf0, 0x60, 0xef, 0x15, 0x7f}; +CHAR8 DEFAULT_BERT_REBOOT_MSG[BERT_MSG_SIZE] =3D "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; + UINTN TableKey; + UINTN TableIndex; + + /* + * Get access to ACPI tables + */ + Status =3D 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 =3D gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **= )&AcpiTableSdtProtocol); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to locate ACPI table support proto= col\n", __FUNCTION__, __LINE__)); + return; + } + + /* + * Search for ACPI Table Signature + */ + TableIndex =3D 0; + Status =3D AcpiLocateTableBySignature ( + AcpiTableSdtProtocol, + Signature, + &TableIndex, + (EFI_ACPI_DESCRIPTION_HEADER **)&Table, + &TableKey + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a:%d Unable to get ACPI table\n", __FUNCTION__,= __LINE__)); + return; + } + + /* + * Uninstall ACPI Table + */ + Status =3D AcpiTableProtocol->UninstallAcpiTable (AcpiTableProtocol, Tab= leKey); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a:%d: Unable to uninstall table\n", __FUNCTION_= _, __LINE__)); + } +} + +VOID +AdjustBERTRegionLen ( + UINT32 Len + ) +{ + EFI_STATUS Status; + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol; + UINTN TableKey; + UINTN TableIndex; + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_HEADER *Table; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiSdtProtocolGuid, + NULL, + (VOID **)&AcpiTableSdtProtocol + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protoc= ol\n")); + return; + } + + /* + * Search for ACPI Table Signature + */ + TableIndex =3D 0; + Status =3D AcpiLocateTableBySignature ( + AcpiTableSdtProtocol, + EFI_ACPI_6_3_BOOT_ERROR_RECORD_TABLE_SIGNATURE, + &TableIndex, + (EFI_ACPI_DESCRIPTION_HEADER **)&Table, + &TableKey + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a:%d Unable to get ACPI BERT table\n", __FUNCTI= ON__, __LINE__)); + return; + } + + /* + * Adjust Boot Error Region Length + */ + Table->BootErrorRegionLength =3D Len; + + AcpiUpdateChecksum ((UINT8 *)Table, Table->Header.Length); +} + +/* + * Retrieve Bert data from SPI NOR + */ +VOID +PullBertSpinorData ( + APEI_CRASH_DUMP_DATA *BertErrorData + ) +{ + UINTN Length; + + Length =3D sizeof (*BertErrorData); + + FlashReadCommand ( + BERT_FLASH_OFFSET, + 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; + UINT8 CrashType; + UINT8 CrashSubType; + + CrashSize =3D PLAT_CRASH_ITERATOR_SIZE * + GetNumberOfSupportedSockets () * + GetMaximumNumberOfCores (); + CrashSize +=3D 2 * (SMPRO_CRASH_SIZE + PMPRO_CRASH_SIZE + RASIP_CRASH_SI= ZE); + CrashSize +=3D sizeof (WrappedError->Bed.Vendor) + sizeof (WrappedError-= >Bed.BertRev); + + CrashType =3D WrappedError->Bed.Vendor.Type & RAS_TYPE_ERROR_MASK; + CrashSubType =3D WrappedError->Bed.Vendor.SubType; + + WrappedError->Ges.BlockStatus.ErrorDataEntryCount =3D 1; + WrappedError->Ges.BlockStatus.UncorrectableErrorValid =3D 1; + WrappedError->Ged.ErrorSeverity =3D BERT_DEFAULT_ERROR_SEVERITY; + WrappedError->Ged.Revision =3D GENERIC_ERROR_DATA_REVISION; + + if ((CrashType =3D=3D RAS_TYPE_BERT && (CrashSubType =3D=3D 0 || CrashSu= bType =3D=3D BERT_UEFI_FAILURE)) + || (CrashType =3D=3D RAS_TYPE_2P)) { + WrappedError->Ged.ErrorDataLength =3D sizeof (WrappedError->Bed.Vendor= ) + + sizeof (WrappedError->Bed.BertRev)= ; + WrappedError->Ges.DataLength =3D 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 =3D CrashSize; + WrappedError->Ges.DataLength =3D 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 =3D RAS_TYPE_BERT_PAYLOAD3; + 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 =3D {0}; + + CreateDefaultBertData (&DefaultData); + if ((Bed->Vendor.Type !=3D DefaultData.Type)) { + Offset =3D BERT_FLASH_OFFSET + + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) + + OFFSET_OF (APEI_BERT_ERROR_DATA, Type); + Length =3D sizeof (DefaultData.Type); + FlashEraseCommand (Offset, Length); + FlashWriteCommand (Offset, &(DefaultData.Type), Length); + } + + if ((Bed->Vendor.SubType !=3D DefaultData.SubType)) { + Offset =3D BERT_FLASH_OFFSET + + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) + + OFFSET_OF (APEI_BERT_ERROR_DATA, SubType); + Length =3D sizeof (DefaultData.SubType); + FlashEraseCommand (Offset, Length); + FlashWriteCommand (Offset, &(DefaultData.SubType), Length); + } + + if ((Bed->Vendor.Instance !=3D DefaultData.Instance)) { + Offset =3D BERT_FLASH_OFFSET + + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) + + OFFSET_OF (APEI_BERT_ERROR_DATA, Instance); + Length =3D sizeof (DefaultData.Instance); + FlashEraseCommand (Offset, Length); + FlashWriteCommand (Offset, &(DefaultData.Instance), Length); + } + + MsgDiff =3D AsciiStrnCmp (Bed->Vendor.Msg, DefaultData.Msg, BERT_MSG_SIZ= E); + if (MsgDiff !=3D 0) { + Offset =3D BERT_FLASH_OFFSET + + OFFSET_OF (APEI_CRASH_DUMP_DATA, Vendor) + + OFFSET_OF (APEI_BERT_ERROR_DATA, Msg); + Length =3D sizeof (DefaultData.Msg); + FlashEraseCommand (Offset, Length); + FlashWriteCommand (Offset, &(DefaultData.Msg), Length); + } + + if (Bed->BertRev !=3D CURRENT_BERT_VERSION) { + Offset =3D BERT_FLASH_OFFSET + OFFSET_OF (APEI_CRASH_DUMP_DATA, BertRe= v); + Length =3D sizeof (Bed->BertRev); + BertRev =3D CURRENT_BERT_VERSION; + FlashEraseCommand (Offset, Length); + FlashWriteCommand (Offset, &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 =3D 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 !=3D 0) ? TRUE : FALSE; +} + +/* + * Write bert table to DDR + */ +VOID +WriteDDRBertTable ( + APEI_CRASH_DUMP_BERT_ERROR *Data + ) +{ + VOID *Blk =3D (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 =3D + (APEI_CRASH_DUMP_BERT_ERROR *) + AllocateZeroPool (sizeof (APEI_CRASH_DUMP_BERT_ERROR)); + + if (DDRError =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + + if (IsBertEnabled ()) { + PullBertSpinorData (&(DDRError->Bed)); + if ((DDRError->Bed.BertRev =3D=3D 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 =3D 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 !=3D 0) ? TRUE : FALSE; +} + +STATIC +VOID +AcpiApeiHestUpdateTable1P ( + VOID + ) +{ + EFI_STATUS Status; + EFI_ACPI_SDT_PROTOCOL *AcpiTableSdtProtocol; + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_HEADER *HestTablePointer; + UINTN TableKey; + UINTN TableIndex; + + Status =3D gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **= )&AcpiTableSdtProtocol); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "APEI: Unable to locate ACPI table support protoc= ol\n")); + return; + } + + /* + * Search for ACPI Table Signature + */ + TableIndex =3D 0; + Status =3D AcpiLocateTableBySignature ( + AcpiTableSdtProtocol, + EFI_ACPI_6_3_HARDWARE_ERROR_SOURCE_TABLE_SIGNATURE, + &TableIndex, + (EFI_ACPI_DESCRIPTION_HEADER **)&HestTablePointer, + &TableKey + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a:%d Unable to get ACPI HEST table\n", __FUNCTI= ON__, __LINE__)); + return; + } + + HestTablePointer->ErrorSourceCount -=3D HEST_NUM_ENTRIES_PER_SOC; + HestTablePointer->Header.Length -=3D + (HEST_NUM_ENTRIES_PER_SOC * + sizeof (EFI_ACPI_6_3_GENERIC_HARDWARE_ERROR_SOURCE_VERSION_2_STRUCTUR= E)); + + AcpiUpdateChecksum ((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_INT= ERFACE_TABLE_SIGNATURE); + } + + return EFI_SUCCESS; +} diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c b/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c new file mode 100644 index 000000000000..82bfbb90f07f --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiDsdt.c @@ -0,0 +1,601 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include + +#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 + +#pragma pack(1) +typedef struct { + UINT8 DWordPrefix; + UINT32 DWordData; +} OP_REGION_DWORD_DATA; + +typedef struct { + UINT8 ExtOpPrefix; + UINT8 ExtOpCode; + UINT8 NameString[4]; + UINT8 RegionSpace; + OP_REGION_DWORD_DATA RegionBase; + OP_REGION_DWORD_DATA RegionLen; +} AML_OP_REGION; +#pragma pack() + +EFI_STATUS +UpdateStatusMethodObject ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle, + CHAR8 *AsciiObjectPath, + CHAR8 ReturnValue + ) +{ + EFI_STATUS Status; + EFI_ACPI_HANDLE ObjectHandle; + EFI_ACPI_DATA_TYPE DataType; + CHAR8 *Buffer; + UINTN DataSize; + + Status =3D AcpiSdtProtocol->FindPath (TableHandle, AsciiObjectPath, &Obj= ectHandle); + if (EFI_ERROR (Status) || ObjectHandle =3D=3D NULL) { + return EFI_SUCCESS; + } + ASSERT (ObjectHandle !=3D NULL); + + Status =3D AcpiSdtProtocol->GetOption (ObjectHandle, 2, &DataType, (VOID= *)&Buffer, &DataSize); + if (!EFI_ERROR (Status) && Buffer[2] =3D=3D AML_BYTE_PREFIX) { + // + // Only patch when the initial value is byte object. + // + Buffer[3] =3D ReturnValue; + } + + AcpiSdtProtocol->Close (ObjectHandle); + return Status; +} + +EFI_STATUS +GetOpRegionBase ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle, + CHAR8 *AsciiObjectPath, + UINT32 *Value + ) +{ + EFI_STATUS Status; + EFI_ACPI_HANDLE ObjectHandle; + EFI_ACPI_DATA_TYPE DataType; + CHAR8 *Buffer; + UINTN DataSize; + AML_OP_REGION *OpRegion; + + Status =3D AcpiSdtProtocol->FindPath (TableHandle, AsciiObjectPath, &Obj= ectHandle); + if (EFI_ERROR (Status)) { + Status =3D EFI_NOT_FOUND; + goto Exit; + } + + Status =3D AcpiSdtProtocol->GetOption (ObjectHandle, 0, &DataType, (VOID= *)&Buffer, &DataSize); + if (!EFI_ERROR (Status) && Buffer !=3D NULL) { + OpRegion =3D (AML_OP_REGION *)Buffer; + + if (OpRegion->ExtOpCode !=3D AML_EXT_REGION_OP + || OpRegion->RegionBase.DWordPrefix !=3D AML_DWORD_PREFIX) + { + AcpiSdtProtocol->Close (TableHandle); + Status =3D EFI_NOT_FOUND; + goto Exit; + } + + *Value =3D OpRegion->RegionBase.DWordData; + } + +Exit: + AcpiSdtProtocol->Close (ObjectHandle); + return Status; +} + +EFI_STATUS +SetOpRegionBase ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle, + CHAR8 *AsciiObjectPath, + UINT32 Value + ) +{ + EFI_STATUS Status; + EFI_ACPI_HANDLE ObjectHandle; + EFI_ACPI_DATA_TYPE DataType; + CHAR8 *Buffer; + UINTN DataSize; + AML_OP_REGION *OpRegion; + + Status =3D AcpiSdtProtocol->FindPath (TableHandle, AsciiObjectPath, &Obj= ectHandle); + if (EFI_ERROR (Status)) { + Status =3D EFI_NOT_FOUND; + goto Exit; + } + + Status =3D AcpiSdtProtocol->GetOption (ObjectHandle, 0, &DataType, (VOID= *)&Buffer, &DataSize); + if (!EFI_ERROR (Status) && Buffer !=3D NULL) { + OpRegion =3D (AML_OP_REGION *)Buffer; + + if (OpRegion->ExtOpCode !=3D AML_EXT_REGION_OP + || OpRegion->RegionBase.DWordPrefix !=3D AML_DWORD_PREFIX) + { + AcpiSdtProtocol->Close (TableHandle); + Status =3D EFI_NOT_FOUND; + goto Exit; + } + + OpRegion->RegionBase.DWordData =3D Value; + } + +Exit: + AcpiSdtProtocol->Close (ObjectHandle); + return Status; +} + +STATIC VOID +AcpiPatchCmn600 ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINTN Index; + + for (Index =3D 0; Index < GetNumberOfSupportedSockets (); Index++) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.CMN%1X._STA", Index); + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= F); + } else { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= 0); + } + } +} + +STATIC VOID +AcpiPatchDmc620 ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINTN Index, Index1; + PLATFORM_INFO_HOB *PlatformHob; + UINT32 McuMask; + VOID *Hob; + + Hob =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL) { + return; + } + + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + for (Index =3D 0; Index < GetNumberOfSupportedSockets (); Index++) { + McuMask =3D PlatformHob->DramInfo.McuMask[Index]; + for (Index1 =3D 0; Index1 < sizeof (McuMask) * 8; Index1++) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.MC%1X%1X._STA", Ind= ex, Index1); + if (McuMask & (0x1 << Index1)) { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, = 0xF); + } else { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, = 0x0); + } + } + } +} + +STATIC VOID +AcpiPatchNvdimm ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINTN NvdRegionNumSK0, NvdRegionNumSK1, NvdRegionNum, Count= ; + PLATFORM_INFO_HOB *PlatformHob; + VOID *Hob; + UINT32 OpRegionBase;; + EFI_STATUS Status; + + Hob =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL) { + return; + } + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + NvdRegionNumSK0 =3D 0; + NvdRegionNumSK1 =3D 0; + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) { + if (PlatformHob->DramInfo.NvdRegion[Count] > 0) { + if (PlatformHob->DramInfo.Socket[Count] =3D=3D 0) { + NvdRegionNumSK0++; + } else { + NvdRegionNumSK1++; + } + } + } + NvdRegionNum =3D NvdRegionNumSK0 + NvdRegionNumSK1; + + /* Disable NVDIMM Root Device */ + if (NvdRegionNum =3D=3D 0) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR._STA"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x0)= ; + } + /* Update NVDIMM Device _STA for SK0 */ + if (NvdRegionNumSK0 =3D=3D 0) { + /* Disable NVD1/2 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._STA"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x0)= ; + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._STA"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x0)= ; + } else if (NvdRegionNumSK0 =3D=3D 1) { + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK0] =3D=3D NvdimmNonHashe= d) { + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) = { + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 && + PlatformHob->DramInfo.Socket[Count] =3D=3D 0) + { + if (PlatformHob->DramInfo.Base[Count] =3D=3D + AC01_NVDIMM_SK0_NHASHED_REGION0_BASE) + { + /* Disable NVD2 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2._ST= A"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePa= th, 0x0); + } else if (PlatformHob->DramInfo.Base[Count] =3D=3D + AC01_NVDIMM_SK0_NHASHED_REGION1_BASE) + { + /* Disable NVD1 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1._ST= A"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePa= th, 0x0); + } + } + } + } + } + /* Update NVDIMM Device _STA and OpRegions for SK1 */ + if (NvdRegionNumSK1 =3D=3D 0) { + /* Use NVD1 OpRegion base for NVD3 */ + OpRegionBase =3D 0; + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD1.BUF1"); + Status =3D GetOpRegionBase (AcpiSdtProtocol, TableHandle, NodePath, &O= pRegionBase); + ASSERT ((!EFI_ERROR (Status)) && (OpRegionBase !=3D 0)); + + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3.BUF1"); + Status =3D SetOpRegionBase (AcpiSdtProtocol, TableHandle, NodePath, Op= RegionBase); + + /* Use NVD2 OpRegion base for NVD4 */ + OpRegionBase =3D 0; + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD2.BUF1"); + Status =3D GetOpRegionBase (AcpiSdtProtocol, TableHandle, NodePath, &O= pRegionBase); + ASSERT ((!EFI_ERROR (Status)) && (OpRegionBase !=3D 0)); + + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4.BUF1"); + Status =3D SetOpRegionBase (AcpiSdtProtocol, TableHandle, NodePath, Op= RegionBase); + + /* Disable NVD3/4 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._STA"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x0)= ; + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._STA"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x0)= ; + } else if (NvdRegionNumSK1 =3D=3D 1) { + if (PlatformHob->DramInfo.NvdimmMode[NVDIMM_SK1] =3D=3D NvdimmNonHashe= d) { + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) = { + if (PlatformHob->DramInfo.NvdRegion[Count] > 0 && + PlatformHob->DramInfo.Socket[Count] =3D=3D 1) + { + if (PlatformHob->DramInfo.Base[Count] =3D=3D + AC01_NVDIMM_SK1_NHASHED_REGION0_BASE) + { + /* Disable NVD4 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD4._ST= A"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePa= th, 0x0); + } else if (PlatformHob->DramInfo.Base[Count] =3D=3D + AC01_NVDIMM_SK1_NHASHED_REGION1_BASE) + { + /* Disable NVD3 */ + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.NVDR.NVD3._ST= A"); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePa= th, 0x0); + } + } + } + } + } +} + +STATIC VOID +AcpiPatchHwmon ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINT8 Index; + + // PCC Hardware Monitor Devices + for (Index =3D 0; Index < GetNumberOfSupportedSockets (); Index++) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index); + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= F); + } else { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= 0); + } + } + + // Ampere Altra SoC Hardware Monitor Devices + for (Index =3D 0; Index < GetNumberOfSupportedSockets (); Index++) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.HM0%1X._STA", Index += 2); + if (GetNumberOfActiveCPMsPerSocket (Index) > 0) { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= F); + } else { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= 0); + } + } +} + +STATIC VOID +AcpiPatchDsu ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINTN Index; + + for (Index =3D 0; Index < PLATFORM_CPU_MAX_NUM_CORES; Index +=3D PLATFOR= M_CPU_NUM_CORES_PER_CPM) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.DU%2X._STA", Index / = PLATFORM_CPU_NUM_CORES_PER_CPM); + if (IsCpuEnabled (Index)) { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= F); + } else { + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, 0x= 0); + } + } +} + +VOID +AcpiPatchPcieNuma ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + CHAR8 NodePath[256]; + UINTN Index; + UINTN NumaIdx; + UINTN NumPciePort; + UINTN NumaAssignment[3][16] =3D { + { 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 =3D 0; + break; + + case SUBNUMA_MODE_HEMISPHERE: + NumaIdx =3D 1; + break; + + case SUBNUMA_MODE_QUADRANT: + NumaIdx =3D 2; + break; + + default: + NumaIdx =3D 0; + break; + } + + if (IsSlaveSocketActive ()) { + NumPciePort =3D 16; // 16 ports total (8 per socket) + } else { + NumPciePort =3D 8; // 8 ports total + } + + for (Index =3D 0; Index < NumPciePort; Index++) { + AsciiSPrint (NodePath, sizeof (NodePath), "\\_SB.PCI%X._PXM", Index); + UpdateStatusMethodObject (AcpiSdtProtocol, TableHandle, NodePath, Numa= Assignment[NumaIdx][Index]); + } +} + +EFI_STATUS +AcpiPatchPcieAerFwFirst ( + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol, + EFI_ACPI_HANDLE TableHandle + ) +{ + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS Address; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo; + EFI_HANDLE *HandleBuffer; + UINTN HandleCount; + CHAR8 ObjectPath[8]; + EFI_STATUS Status; + UINT32 AerFwFirstConfigValue; + UINT32 RegData; + UINT16 Device; + UINT32 Index; + + // + // Check if PCIe AER Firmware First should be enabled + // + Status =3D 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 =3D 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 =3D 0; + } + } + + if (AerFwFirstConfigValue =3D=3D 0) { + // + // By default, the PCIe AER FW-First (ACPI Object "AERF") is set to 0 + // in the DSDT table. + // + return EFI_SUCCESS; + } + + // + // Update Name Object "AERF" (PCIe AER Firmware-First) to enable PCIe AE= R Firmware-First + // + AsciiSPrint (ObjectPath, sizeof (ObjectPath), "\\AERF"); + Status =3D AcpiAmlObjectUpdateInteger (AcpiSdtProtocol, TableHandle, Obj= ectPath, 1); + + // + // For PCIe AER Firmware First, PCIe capability registers need + // to be updated to allow Firmware to detect AER errors. + // + + HandleCount =3D 0; + HandleBuffer =3D NULL; + PciRootBridgeIo =3D NULL; + + Status =3D gBS->LocateHandleBuffer ( + ByProtocol, + &gEfiPciRootBridgeIoProtocolGuid, + NULL, + &HandleCount, + &HandleBuffer + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Loop through each root complex + // + for (Index =3D 0; Index < HandleCount; Index++) { + Status =3D gBS->HandleProtocol ( + HandleBuffer[Index], + &gEfiPciRootBridgeIoProtocolGuid, + (VOID **)&PciRootBridgeIo + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Loop through each root port + // + for (Device =3D 1; Device <=3D PCIE_MAX_DEVICE_PER_ROOT_PORT; Device++= ) { + Address.Bus =3D 0; + Address.Device =3D Device; + Address.Function =3D 0; + Address.Register =3D 0; + + Address.ExtendedRegister =3D PCIE_DEVICE_CONTROL_OFFSET; + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UI= NT64 *)&Address), 1, &RegData); + + if (RegData =3D=3D 0xFFFFFFFF) { + continue; + } + + RegData |=3D 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, *((U= INT64 *)&Address), 1, &RegData); + + RegData =3D 0; + Address.ExtendedRegister =3D PCIE_ROOT_ERR_CMD_OFFSET; + PciRootBridgeIo->Pci.Read (PciRootBridgeIo, EfiPciWidthUint32, *((UI= NT64 *)&Address), 1, &RegData); + + RegData |=3D 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, *((U= INT64 *)&Address), 1, &RegData); + } + } + + return Status; +} + +EFI_STATUS +AcpiPatchDsdtTable ( + VOID + ) +{ + EFI_STATUS Status; + EFI_ACPI_SDT_PROTOCOL *AcpiSdtProtocol; + EFI_ACPI_DESCRIPTION_HEADER *Table; + UINTN TableKey; + UINTN TableIndex; + EFI_ACPI_HANDLE TableHandle; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiSdtProtocolGuid, + NULL, + (VOID **)&AcpiSdtProtocol + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "Unable to locate ACPI table protocol\n")); + return Status; + } + + TableIndex =3D 0; + Status =3D AcpiLocateTableBySignature ( + AcpiSdtProtocol, + EFI_ACPI_6_3_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATUR= E, + &TableIndex, + &Table, + &TableKey + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "ACPI DSDT table not found!\n")); + ASSERT_EFI_ERROR (Status); + return Status; + } + + Status =3D AcpiSdtProtocol->OpenSdt (TableKey, &TableHandle); + if (EFI_ERROR (Status)) { + ASSERT_EFI_ERROR (Status); + AcpiSdtProtocol->Close (TableHandle); + return Status; + } + + AcpiPatchCmn600 (AcpiSdtProtocol, TableHandle); + AcpiPatchDmc620 (AcpiSdtProtocol, TableHandle); + AcpiPatchDsu (AcpiSdtProtocol, TableHandle); + AcpiPatchHwmon (AcpiSdtProtocol, TableHandle); + AcpiPatchNvdimm (AcpiSdtProtocol, TableHandle); + AcpiPatchPcieNuma (AcpiSdtProtocol, TableHandle); + AcpiPatchPcieAerFwFirst (AcpiSdtProtocol, TableHandle); + + AcpiSdtProtocol->Close (TableHandle); + AcpiUpdateChecksum ((UINT8 *)Table, Table->Length); + + return EFI_SUCCESS; +} diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c b/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c new file mode 100644 index 000000000000..419ce578e452 --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiMadt.c @@ -0,0 +1,348 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "AcpiPlatform.h" + +EFI_ACPI_6_3_GIC_ITS_STRUCTURE GicItsTemplate =3D { + 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 =3D { + EFI_ACPI_6_3_GICR, + sizeof (EFI_ACPI_6_3_GICR_STRUCTURE), + EFI_ACPI_RESERVED_WORD, + AC01_GICR_MASTER_BASE_ADDRESS, /* DiscoveryRangeBaseAddress */ + 0x1000000, /* DiscoveryRangeLength */ +}; + +EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE GicDTemplate =3D { + EFI_ACPI_6_3_GICD, + sizeof (EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE), + EFI_ACPI_RESERVED_WORD, + 0, /* GicDistHwId */ + AC01_GICD_MASTER_BASE_ADDRESS, /* GicDistBase */ + 0, /* GicDistVector */ + 0x3, /* GicVersion */ + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE} +}; + +EFI_ACPI_6_3_GIC_STRUCTURE GiccTemplate =3D { + 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 MADTTableHeaderTemplat= e =3D { + __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_COR= ES_PER_CPM] =3D { + 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_COR= ES_PER_CPM] =3D { + 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] =3D { + 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 =3D 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 =3D EntryPointer; + UINT32 SocketId; + UINT32 ClusterId; + UINTN Size; + + Size =3D sizeof (GiccTemplate); + CopyMem (MadtProcessorEntryPointer, &GiccTemplate, Size); + + SocketId =3D SOCKET_ID (CpuId); + ClusterId =3D CLUSTER_ID (CpuId); + + // + // GICv2 compatibility mode is not supported. + // Hence, set GIC's CPU Interface Number to 0. + // + MadtProcessorEntryPointer->CPUInterfaceNumber =3D 0; + MadtProcessorEntryPointer->AcpiProcessorUid =3D + (SocketId << PLATFORM_SOCKET_UID_BIT_OFFSET) + + (ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM); + MadtProcessorEntryPointer->Flags =3D 1; + MadtProcessorEntryPointer->MPIDR =3D + (((ClusterId << 8) + (CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM)) << 8); + MadtProcessorEntryPointer->MPIDR +=3D (((UINT64)SocketId) << 32); + + return Size; +} + +UINT32 +AcpiInstallMadtGicD ( + VOID *EntryPointer + ) +{ + EFI_ACPI_6_3_GIC_DISTRIBUTOR_STRUCTURE *GicDEntryPointer =3D EntryPointe= r; + UINTN Size; + + Size =3D sizeof (GicDTemplate); + CopyMem (GicDEntryPointer, &GicDTemplate, Size); + + return Size; +} + +UINT32 +AcpiInstallMadtGicR ( + VOID *EntryPointer, + UINT32 SocketId + ) +{ + EFI_ACPI_6_3_GICR_STRUCTURE *GicREntryPointer =3D EntryPointer; + UINTN Size; + + /* + * If the Slave socket is not present, discard the Slave socket + * GIC redistributor region + */ + if (SocketId =3D=3D 1 && !IsSlaveSocketActive ()) { + return 0; + } + + Size =3D sizeof (GicRTemplate); + CopyMem (GicREntryPointer, &GicRTemplate, Size); + + if (SocketId =3D=3D 1) { + GicREntryPointer->DiscoveryRangeBaseAddress =3D AC01_GICR_SLAVE_BASE_A= DDRESS; + } + + return Size; +} + +UINT32 +AcpiInstallMadtGicIts ( + VOID *EntryPointer, + UINT32 Index + ) +{ + EFI_ACPI_6_3_GIC_ITS_STRUCTURE *GicItsEntryPointer =3D EntryPointer; + UINTN Size, Offset; + UINT64 GicBase =3D AC01_GICD_MASTER_BASE_ADDRESS= ; + UINT32 ItsId =3D Index; + + if (Index > SOCKET0_LAST_RC) { /* Socket 1, Index: 8-15 */ + GicBase =3D AC01_GICD_SLAVE_BASE_ADDRESS; + Index -=3D (SOCKET0_LAST_RC + 1); /* Socket 1, Index:8 -> RCA0 */ + } + Size =3D sizeof (GicItsTemplate); + CopyMem (GicItsEntryPointer, &GicItsTemplate, Size); + Offset =3D 0x40000 + Index * 0x20000; + GicItsEntryPointer->GicItsId =3D ItsId; + GicItsEntryPointer->PhysicalBaseAddress =3D Offset + GicBase; + + return Size; +} + +/* + * Install MADT table. + */ +EFI_STATUS +AcpiInstallMadtTable ( + VOID + ) +{ + EFI_ACPI_6_3_GIC_STRUCTURE *GiccEntryPointer =3D NULL; + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol; + UINTN MadtTableKey =3D 0; + INTN Index; + EFI_STATUS Status; + UINTN Size; + UINT32 *CoreOrder; + UINT32 SktMaxCoreNum; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + + Size =3D 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 (GicItsTempl= ate)); + if (IsSlaveSocketActive ()) { + Size +=3D ((SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsT= emplate)); + } else if (!IsSlaveSocketAvailable ()) { + Size +=3D 2 * sizeof (GicItsTemplate); /* RCA0/1 */ + } + + MadtTablePointer =3D + (EFI_ACPI_6_3_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)AllocateZeroPoo= l (Size); + if (MadtTablePointer =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + + GiccEntryPointer =3D + (EFI_ACPI_6_3_GIC_STRUCTURE *)((UINT64)MadtTablePointer + + sizeof (MADTTableHeaderTemplate)); + + /* Install Gic interface for each processor */ + Size =3D 0; + CoreOrder =3D CpuGetCoreOrder (); + ASSERT (CoreOrder !=3D NULL); + SktMaxCoreNum =3D PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_NUM_CORES_PER_CPM; + for (Index =3D 0; Index < SktMaxCoreNum; Index++) { + if (IsCpuEnabled (CoreOrder[Index])) { + Size +=3D AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPo= inter + Size), CoreOrder[Index]); + } + } + + for (Index =3D 0; Index < SktMaxCoreNum; Index++) { + if (IsCpuEnabled (CoreOrder[Index] + SktMaxCoreNum)) { + Size +=3D AcpiInstallMadtProcessorNode ((VOID *)((UINT64)GiccEntryPo= inter + Size), CoreOrder[Index] + SktMaxCoreNum); + } + } + + /* Install Gic Distributor */ + Size +=3D AcpiInstallMadtGicD ((VOID *)((UINT64)GiccEntryPointer + Size)= ); + + /* Install Gic Redistributor */ + for (Index =3D 0; Index < PLATFORM_CPU_MAX_SOCKET; Index++) { + Size +=3D AcpiInstallMadtGicR ((VOID *)((UINT64)GiccEntryPointer + Siz= e), Index); + } + + /* Install Gic ITS */ + if (!IsSlaveSocketAvailable ()) { + for (Index =3D 0; Index <=3D 1; Index++) { /* RCA0/1 */ + Size +=3D AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer += Size), Index); + } + } + for (Index =3D SOCKET0_FIRST_RC; Index <=3D SOCKET0_LAST_RC; Index++) { + Size +=3D AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer + S= ize), Index); + } + if (IsSlaveSocketActive ()) { + for (Index =3D SOCKET1_FIRST_RC; Index <=3D SOCKET1_LAST_RC; Index++) = { + Size +=3D AcpiInstallMadtGicIts ((VOID *)((UINT64)GiccEntryPointer += Size), Index); + } + } + CopyMem ( + MadtTablePointer, + &MADTTableHeaderTemplate, + sizeof (MADTTableHeaderTemplate) + ); + + Size +=3D sizeof (MADTTableHeaderTemplate); + MadtTablePointer->Header.Length =3D Size; + CopyMem ( + MadtTablePointer->Header.OemId, + PcdGetPtr (PcdAcpiDefaultOemId), + sizeof (MadtTablePointer->Header.OemId) + ); + + AcpiUpdateChecksum ((UINT8 *)MadtTablePointer, MadtTablePointer->Header.= Length); + + Status =3D 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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c new file mode 100644 index 000000000000..dd6843dc8164 --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiNfit.c @@ -0,0 +1,596 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "AcpiNfit.h" +#include "AcpiPlatform.h" + +EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE NfitSPATemplate = =3D { + 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, // Res= erved. + 0, // Pro= ximity domain - need to be filled. + EFI_ACPI_6_3_NFIT_GUID_BYTE_ADDRESSABLE_PERSISTENT_MEMORY_REGION, // PM = range type. + 0, // Sta= rt address - need to be filled. + 0, // Siz= e - 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 NvdimmControlRegionTempl= ate =3D { + 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 NvdimmRegionMappingTempl= ate =3D { + 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 =3D { + __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] =3D { { 0 } }; + +EFI_STATUS +AcpiNvdInfoInit ( + IN OUT NVDIMM_INFO *NvdInfoPtr, + IN UINTN NvdId + ) +{ + PLATFORM_INFO_HOB *PlatformHob; + VOID *Hob; + + /* Get the Platform HOB */ + Hob =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL || NvdInfoPtr =3D=3D NULL) { + return EFI_INVALID_PARAMETER; + } + + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + NvdInfoPtr->Enabled =3D TRUE; + NvdInfoPtr->PhysId =3D NvdId; + NvdInfoPtr->NvdSize =3D PlatformHob->DimmList.Dimm[NvdId].Info.DimmSize = * ONE_GB; + NvdInfoPtr->VendorId =3D + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[320]); + NvdInfoPtr->DeviceId =3D + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[192]); + NvdInfoPtr->RevisionId =3D + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[349]; + NvdInfoPtr->SubVendorId =3D + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[194]); + NvdInfoPtr->SubDeviceId =3D + *((UINT16 *)&PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[196]); + NvdInfoPtr->SubRevisionId =3D + (UINT16)PlatformHob->DimmList.Dimm[NvdId].SpdData.Data[198]; + NvdInfoPtr->SerialNumber =3D + *((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 =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL) { + return EFI_INVALID_PARAMETER; + } + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + NvdRegionNum =3D 0; + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) { + if (PlatformHob->DramInfo.NvdRegion[Count] !=3D 0 + && (PlatformHob->DramInfo.Socket[Count] =3D=3D Socket)) + { + NvdData[Socket].NvdRegionId[NvdRegionNum] =3D Count; + NvdRegionNum++; + } + } + if (NvdRegionNum =3D=3D 0) { + return EFI_SUCCESS; + } + + NvdData[Socket].NvdRegionNum =3D NvdRegionNum; + NvdData[Socket].NvdMode =3D PlatformHob->DramInfo.NvdimmMode[Socket]; + if (NvdData[Socket].NvdMode =3D=3D NvdimmHashed) { + NvdInfo =3D &NvdData[Socket].NvdInfo[NVDIMM_SK0]; + NvdInfo->DeviceHandle =3D + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD1_DEVICE_HANDLE : + AC01_NVDIMM_NVD3_DEVICE_HANDLE; + NvdInfo->InterleaveWays =3D AC01_NVDIMM_HASHED_INTERLEAVE_WAYS; + NvdInfo->RegionOffset =3D 0; + AcpiNvdInfoInit ( + NvdInfo, + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD1_DIMM_ID : + AC01_NVDIMM_NVD3_DIMM_ID + ); + + NvdInfo =3D &NvdData[Socket].NvdInfo[1]; + NvdInfo->DeviceHandle =3D + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD2_DEVICE_HANDLE : + AC01_NVDIMM_NVD4_DEVICE_HANDLE; + NvdInfo->InterleaveWays =3D AC01_NVDIMM_HASHED_INTERLEAVE_WAYS; + NvdInfo->RegionOffset =3D AC01_NVDIMM_HASHED_REGION_OFFSET; + AcpiNvdInfoInit ( + NvdInfo, + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD2_DIMM_ID : + AC01_NVDIMM_NVD4_DIMM_ID + ); + + /* Update NvdNum */ + NvdData[Socket].NvdNum =3D 0; + for (Count =3D 0; Count < NVDIMM_NUM_PER_SK; Count++) { + if (NvdData[Socket].NvdInfo[Count].Enabled) { + NvdData[Socket].NvdNum++; + } + } + return EFI_SUCCESS; + } + /* NvdimmNonHashed */ + NvdData[Socket].NvdNum =3D 0; + for (Count =3D 0; Count < NvdData[Socket].NvdRegionNum; Count++) { + RegionId =3D NvdData[Socket].NvdRegionId[Count]; + if (PlatformHob->DramInfo.Base[RegionId] =3D=3D + AC01_NVDIMM_SK0_NHASHED_REGION0_BASE || + PlatformHob->DramInfo.Base[RegionId] =3D=3D + AC01_NVDIMM_SK1_NHASHED_REGION0_BASE) + { + NvdInfo =3D &NvdData[Socket].NvdInfo[0]; + NvdInfo->DeviceHandle =3D + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD1_DEVICE_HANDLE : + AC01_NVDIMM_NVD3_DEVICE_HANDLE; + NvdInfo->InterleaveWays =3D AC01_NVDIMM_NHASHED_INTERLEAVE_WAYS; + NvdInfo->RegionOffset =3D 0; + AcpiNvdInfoInit ( + NvdInfo, + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD1_DIMM_ID : + AC01_NVDIMM_NVD3_DIMM_ID + ); + + } else if (PlatformHob->DramInfo.Base[RegionId] =3D=3D + AC01_NVDIMM_SK0_NHASHED_REGION1_BASE || + PlatformHob->DramInfo.Base[RegionId] =3D=3D + AC01_NVDIMM_SK1_NHASHED_REGION1_BASE) + { + NvdInfo =3D &NvdData[Socket].NvdInfo[1]; + NvdInfo->DeviceHandle =3D + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD2_DEVICE_HANDLE : + AC01_NVDIMM_NVD4_DEVICE_HANDLE; + NvdInfo->InterleaveWays =3D AC01_NVDIMM_NHASHED_INTERLEAVE_WAYS; + NvdInfo->RegionOffset =3D 0; + AcpiNvdInfoInit ( + NvdInfo, + (Socket =3D=3D 0) ? AC01_NVDIMM_NVD2_DIMM_ID : + AC01_NVDIMM_NVD4_DIMM_ID + ); + } + } + /* Update NvdNum */ + NvdData[Socket].NvdNum =3D 0; + for (Count =3D 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 *NfitSp= aPointer, + IN UINTN NvdRegi= onIndex, + IN UINT64 NvdRegi= onBase, + IN UINT64 NvdRegi= onSize + ) +{ + ASSERT (NfitSpaPointer !=3D NULL); + + NfitSpaPointer->Flags =3D 0; + NfitSpaPointer->SPARangeStructureIndex =3D NvdRegionIndex; + NfitSpaPointer->SystemPhysicalAddressRangeBase =3D NvdRegionBase; + NfitSpaPointer->SystemPhysicalAddressRangeLength =3D NvdRegionSize; +} + +VOID +NfitFillControlRegion ( + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlReg= ionPointer, + IN NVDIMM_INFO *NvdInfo, + IN UINTN NvdControlRegio= nIndex + ) +{ + ASSERT ( + NfitControlRegionPointer !=3D NULL + && NvdInfo !=3D NULL + ); + + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex =3D + NvdControlRegionIndex; + NfitControlRegionPointer->VendorID =3D NvdInfo->VendorId; + NfitControlRegionPointer->DeviceID =3D NvdInfo->DeviceId; + NfitControlRegionPointer->RevisionID =3D NvdInfo->RevisionId; + NfitControlRegionPointer->SubsystemVendorID =3D NvdInfo->SubVendorId; + NfitControlRegionPointer->SubsystemDeviceID =3D NvdInfo->SubDeviceId; + NfitControlRegionPointer->SubsystemRevisionID =3D NvdInfo->SubRevisionId= ; + NfitControlRegionPointer->SerialNumber =3D NvdInfo->SerialNumber; +} + +VOID +NfitFillRegionMapping ( + IN OUT EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRe= gionMappingPointer, + IN EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitCo= ntrolRegionPointer, + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSp= aPointer, + IN NVDIMM_INFO *NvdInf= o, + IN UINTN NvdRegi= onID + ) +{ + ASSERT ( + NfitRegionMappingPointer !=3D NULL + && NfitRegionMappingPointer !=3D NULL + && NfitRegionMappingPointer !=3D NULL + && NfitRegionMappingPointer !=3D NULL + && NvdInfo !=3D NULL + ); + + NfitRegionMappingPointer->NVDIMMRegionID =3D NvdRegionID; + NfitRegionMappingPointer->NVDIMMPhysicalID =3D NvdInfo->PhysId; + NfitRegionMappingPointer->InterleaveWays =3D NvdInfo->InterleaveWays; + NfitRegionMappingPointer->RegionOffset =3D NvdInfo->RegionOffset; + NfitRegionMappingPointer->NVDIMMRegionSize =3D NvdInfo->NvdSize; + NfitRegionMappingPointer->NFITDeviceHandle.DIMMNumber =3D + NvdInfo->DeviceHandle & 0x0F; + NfitRegionMappingPointer->NFITDeviceHandle.MemoryChannelNumber =3D + (NvdInfo->DeviceHandle >> 4) & 0x0F; + NfitRegionMappingPointer->NFITDeviceHandle.MemoryControllerID =3D + (NvdInfo->DeviceHandle >> 8) & 0x0F; + NfitRegionMappingPointer->NFITDeviceHandle.SocketID =3D + (NvdInfo->DeviceHandle >> 12) & 0x0F; + NfitRegionMappingPointer->SPARangeStructureIndex =3D + NfitSpaPointer->SPARangeStructureIndex; + NfitRegionMappingPointer->NVDIMMPhysicalAddressRegionBase =3D + NfitSpaPointer->SystemPhysicalAddressRangeBase; + NfitRegionMappingPointer->NVDIMMControlRegionStructureIndex =3D + NfitControlRegionPointer->NVDIMMControlRegionStructureIndex; +} + +EFI_STATUS +AcpiNfitFillTableBySK ( + IN EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSp= aPointerStart, + IN OUT EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE **NfitS= paPointerNext, + IN UINTN Socket + ) +{ + EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *NfitSpaPointe= r; + EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *NfitControlRe= gionPointer; + EFI_ACPI_6_3_NFIT_NVDIMM_REGION_MAPPING_STRUCTURE *NfitRegionMap= pingPointer; + PLATFORM_INFO_HOB *PlatformHob; + VOID *Hob; + UINT64 NvdRegionBase, + NvdRegionSize; + UINTN NvdCount, MaxNvdCount, RegionCount; + UINTN RegionId, NvdRegionIndex, NvdIndex; + + /* Get the Platform HOB */ + Hob =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL + || NfitSpaPointerStart =3D=3D NULL + || NfitSpaPointerNext =3D=3D NULL) + { + return EFI_INVALID_PARAMETER; + } + + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + NvdRegionIndex =3D (Socket =3D=3D 0) ? 0 : NvdData[NVDIMM_SK0].NvdRegion= Num; + NvdIndex =3D (Socket =3D=3D 0) ? 0 : NvdData[NVDIMM_SK0].NvdNum; + if (NvdData[Socket].NvdMode =3D=3D NvdimmHashed) { + /* Table Type 0: SPA Range Structure */ + NfitSpaPointer =3D NfitSpaPointerStart; + CopyMem ( + (VOID *)NfitSpaPointer, + (VOID *)&NfitSPATemplate, + sizeof (NfitSPATemplate) + ); + RegionId =3D NvdData[Socket].NvdRegionId[0]; + NvdRegionBase =3D PlatformHob->DramInfo.Base[RegionId]; + NvdRegionSize =3D PlatformHob->DramInfo.Size[RegionId]; + NvdRegionIndex++; + AcpiNfitFillSPA ( + NfitSpaPointer, + NvdRegionIndex, + NvdRegionBase, + NvdRegionSize + ); + + NfitControlRegionPointer =3D + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *) + (NfitSpaPointer + 1); + for (NvdCount =3D 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 =3D + (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 =3D + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *) + (NfitRegionMappingPointer + 1); + } + NfitSpaPointer =3D + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *) + NfitControlRegionPointer; + } else { /* NvdimmNonHashed */ + NfitSpaPointer =3D NfitSpaPointerStart; + for (RegionCount =3D 0; RegionCount < NvdData[Socket].NvdRegionNum; + RegionCount++) + { + /* Table Type 0: SPA Range Structure */ + CopyMem ( + (VOID *)NfitSpaPointer, + (VOID *)&NfitSPATemplate, + sizeof (NfitSPATemplate) + ); + RegionId =3D NvdData[Socket].NvdRegionId[RegionCount]; + NvdRegionBase =3D PlatformHob->DramInfo.Base[RegionId]; + NvdRegionSize =3D PlatformHob->DramInfo.Size[RegionId]; + NvdRegionIndex++; + AcpiNfitFillSPA ( + NfitSpaPointer, + NvdRegionIndex, + NvdRegionBase, + NvdRegionSize + ); + + NfitControlRegionPointer =3D + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *) + (NfitSpaPointer + 1); + NvdCount =3D ((NvdRegionBase =3D=3D AC01_NVDIMM_SK0_NHASHED_REGION0_= BASE) || + (NvdRegionBase =3D=3D AC01_NVDIMM_SK1_NHASHED_REGION0_BA= SE)) ? + 0 : AC01_NVDIMM_MAX_DIMM_PER_MCU; + MaxNvdCount =3D NvdCount + AC01_NVDIMM_MAX_DIMM_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 =3D + (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 =3D + (EFI_ACPI_6_3_NFIT_NVDIMM_CONTROL_REGION_STRUCTURE *) + (NfitRegionMappingPointer + 1); + } + NfitSpaPointer =3D + (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *) + NfitControlRegionPointer; + } + } + /* Update NfitSpaPointerNext */ + *NfitSpaPointerNext =3D 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 *NfitSpaPointe= rNext; + + if (NfitTablePointer =3D=3D NULL) { + return EFI_INVALID_PARAMETER; + } + + NfitSpaPointerNext =3D (EFI_ACPI_6_3_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_= STRUCTURE *) + (NfitTablePointer + 1); + + if (NvdData[NVDIMM_SK0].NvdRegionNum !=3D 0) { + AcpiNfitFillTableBySK (NfitSpaPointerNext, &NfitSpaPointerNext, NVDIMM= _SK0); + } + + if (NvdData[NVDIMM_SK1].NvdRegionNum !=3D 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 =3D 0; + EFI_STATUS Status; + UINTN Size; + UINTN NvdRegionNum; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + Status =3D AcpiNvdDataInit (NVDIMM_SK0); + if (EFI_ERROR (Status)) { + return Status; + } + Status =3D AcpiNvdDataInit (NVDIMM_SK1); + if (EFI_ERROR (Status)) { + return Status; + } + NvdRegionNum =3D NvdData[NVDIMM_SK0].NvdRegionNum + + NvdData[NVDIMM_SK1].NvdRegionNum; + if (NvdRegionNum =3D=3D 0) { + return EFI_INVALID_PARAMETER; /* No NVDIMM Region */ + } + Size =3D sizeof (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE); + if (NvdData[NVDIMM_SK0].NvdRegionNum !=3D 0) { + Size +=3D + (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 !=3D 0) { + Size +=3D + (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 =3D + (EFI_ACPI_6_3_NVDIMM_FIRMWARE_INTERFACE_TABLE *)AllocateZeroPool (Size= ); + if (NfitTablePointer =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + CopyMem ( + (VOID *)NfitTablePointer, + (VOID *)&NFITTableHeaderTemplate, + sizeof (NFITTableHeaderTemplate) + ); + + NfitTablePointer->Header.Length =3D Size; + + Status =3D AcpiNfitFillTable (NfitTablePointer); + if (EFI_ERROR (Status)) { + FreePool ((VOID *)NfitTablePointer); + return Status; + } + AcpiUpdateChecksum ((UINT8 *)NfitTablePointer, NfitTablePointer->Header.= Length); + Status =3D 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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c new file mode 100644 index 000000000000..6f4b252ab366 --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPcct.c @@ -0,0 +1,413 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "AcpiPlatform.h" + +#include +#include +#include + +// +// The communication data for advertising the shared memory address to the= SMpro/PMpro. +// +#define PCC_PAYLOAD_ADVERTISE_ADDRESS 0x0F000000 +#define PCC_PAYLOAD_SIZE 12 // Bytes + +// +// ACPI Platform Communication Channel (PCC) +// +#define PCC_SUBSPACE_SHARED_MEM_SIGNATURE 0x50434300 // "PCC" +#define PCC_SUBSPACE_SHARED_MEM_SIZE 0x4000 // Number of Byte= s + +// +// Mask for available doorbells. This is used to reserve +// doorbells which are for other communications with OS. +// +// Each bit in the mask represents each doorbell channel +// from PMpro Doorbell 0 to PMpro Doorbell 7 and SMpro +// Doorbell channel 0 to SMpro Doorbell channel 7. +// +#define PCC_AVAILABLE_DOORBELL_MASK 0xEFFFEFFF + +#define PCC_MAX_VALID_DOORBELL_COUNT (NUMBER_OF_DOORBELLS_P= ER_SOCKET * PLATFORM_CPU_MAX_SOCKET) + +#define PCC_NOMINAL_LATENCY_US 1000 // us +#define PCC_MAX_PERIODIC_ACCESS_RATE 0 // no limitation +#define PCC_MIN_REQ_TURNAROUND_TIME_US 0 + +// Polling interval for PCC Command Complete +#define PCC_COMMAND_POLL_INTERVAL_US 10 + +#define PCC_COMMAND_POLL_COUNT (PCC_NOMINAL_LATENCY_US / PCC_COMMAND_POLL= _INTERVAL_US) + +// +// Doorbell Channel for CPPC +// +#define PCC_CPPC_DOORBELL_ID (PMproDoorbellChannel2) + +#define PCC_CPPC_NOMINAL_LATENCY_US 100 +#define PCC_CPPC_MIN_REQ_TURNAROUND_TIME_US 110 + +// +// Shared memory regions allocated for PCC subspaces +// +STATIC EFI_PHYSICAL_ADDRESS mPccSharedMemoryAddress; +STATIC UINTN mPccSharedMemorySize; + + +EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS PcctSubspaceTemplat= e =3D { + 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 PcctTableHeaderTe= mplate =3D { + __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, +}; + + +/** + Check whether the Doorbell is reserved or not. + +**/ +BOOLEAN +PcctIsDoorbellReserved ( + IN UINT16 Doorbell + ) +{ + ASSERT (Doorbell <=3D PCC_MAX_VALID_DOORBELL_COUNT); + + if (((1 << Doorbell) & PCC_AVAILABLE_DOORBELL_MASK) =3D=3D 0) { + return TRUE; + } + + return FALSE; +} + +/** + Get number of available doorbells for the usage of PCC communication. + +**/ +UINT16 +PcctGetNumberOfAvailableDoorbells ( + VOID + ) +{ + UINT16 Doorbell; + UINT16 AvailableDoorbellCount; + + AvailableDoorbellCount =3D 0; + for (Doorbell =3D 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbell= ++ ) { + if (((1 << Doorbell) & PCC_AVAILABLE_DOORBELL_MASK) !=3D 0) { + AvailableDoorbellCount++; + } + } + ASSERT (AvailableDoorbellCount <=3D PCC_MAX_VALID_DOORBELL_COUNT); + + return AvailableDoorbellCount; +} + +/** + Allocate memory pages for the PCC shared memory region. + +**/ +EFI_STATUS +PcctAllocateSharedMemory ( + IN UINT16 SubspaceCount, + OUT EFI_PHYSICAL_ADDRESS *PccSharedMemoryPtr + ) +{ + EFI_STATUS Status; + + mPccSharedMemorySize =3D PCC_SUBSPACE_SHARED_MEM_SIZE * SubspaceCount; + + Status =3D gBS->AllocatePages ( + AllocateAnyPages, + EfiRuntimeServicesData, + EFI_SIZE_TO_PAGES (mPccSharedMemorySize), + &mPccSharedMemoryAddress + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "Failed to allocate PCC shared memory\n")); + mPccSharedMemorySize =3D 0; + return Status; + } + + *PccSharedMemoryPtr =3D mPccSharedMemoryAddress; + + return EFI_SUCCESS; +} + +EFI_PHYSICAL_ADDRESS +PcctGetSharedMemoryAddress ( + IN UINT8 Socket, + IN UINT16 Subspace + ) +{ + ASSERT (Socket < PLATFORM_CPU_MAX_SOCKET); + + return (mPccSharedMemoryAddress + PCC_SUBSPACE_SHARED_MEM_SIZE * Subspac= e); +} + +/** + Free the whole shared memory region that is allocated by + the PcctAllocateSharedMemory() function. + +**/ +VOID +PcctFreeSharedMemory ( + VOID + ) +{ + if (mPccSharedMemoryAddress !=3D 0 && mPccSharedMemorySize !=3D 0) { + gBS->FreePages ( + mPccSharedMemoryAddress, + EFI_SIZE_TO_PAGES (mPccSharedMemorySize) + ); + + mPccSharedMemoryAddress =3D 0; + } +} + +/** + This function is to advertise the shared memory region address + to the platform (SMpro/PMpro). + +**/ +EFI_STATUS +PcctAdvertiseSharedMemoryAddress ( + IN UINT8 Socket, + IN UINT16 Doorbell, + IN UINT16 Subspace + ) +{ + EFI_STATUS Status; + EFI_ACPI_6_3_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER *PccSharedMemoryRe= gion; + UINT32 CommunicationData; + UINTN Timeout; + + if (Socket >=3D PLATFORM_CPU_MAX_SOCKET + || Doorbell >=3D NUMBER_OF_DOORBELLS_PER_SOCKET) { + return EFI_INVALID_PARAMETER; + } + + PccSharedMemoryRegion =3D (EFI_ACPI_6_3_PCCT_GENERIC_SHARED_MEMORY_REGIO= N_HEADER *) + PcctGetSharedMemoryAddress (Socket, Subspace); + ASSERT (PccSharedMemoryRegion !=3D NULL); + + // + // Zero shared memory region for each PCC subspace + // + SetMem ( + (VOID *)PccSharedMemoryRegion, + sizeof (EFI_ACPI_6_3_PCCT_GENERIC_SHARED_MEMORY_REGION_HEADER) + PCC_P= AYLOAD_SIZE, + 0 + ); + + // Advertise shared memory address to Platform (SMpro/PMpro) + // by ringing the doorbell with dummy PCC message + // + CommunicationData =3D PCC_PAYLOAD_ADVERTISE_ADDRESS; + + // + // Write Data into Communication Space Region + // + CopyMem ((VOID *)(PccSharedMemoryRegion + 1), &CommunicationData, sizeof= (CommunicationData)); + + PccSharedMemoryRegion->Status.CommandComplete =3D 0; + PccSharedMemoryRegion->Signature =3D PCC_SUBSPACE_SHARED_MEM_SIGNATURE |= Subspace; + + Status =3D MailboxMsgSetPccSharedMem (Socket, Doorbell, TRUE, (UINT64)Pc= cSharedMemoryRegion); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "%a: Failed to send mailbox message!\n", __FUNCTI= ON__)); + ASSERT_EFI_ERROR (Status); + return Status; + } + + // + // Polling CMD_COMPLETE bit + // + Timeout =3D PCC_COMMAND_POLL_COUNT; + while (PccSharedMemoryRegion->Status.CommandComplete !=3D 1) { + if (--Timeout <=3D 0) { + DEBUG ((DEBUG_ERROR, "%a - Timeout occurred when polling the PCC Sta= tus Complete\n", __FUNCTION__)); + return EFI_TIMEOUT; + } + MicroSecondDelay (PCC_COMMAND_POLL_INTERVAL_US); + } + + return EFI_SUCCESS; +} + +EFI_STATUS +AcpiPcctInitializeSharedMemory ( + VOID + ) +{ + UINT8 SocketCount; + UINT8 Socket; + UINT16 Doorbell; + UINT16 Subspace; + + SocketCount =3D GetNumberOfActiveSockets (); + Subspace =3D 0; + + for (Socket =3D 0; Socket < SocketCount; Socket++) { + for (Doorbell =3D 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbe= ll++ ) { + if (PcctIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKE= T * Socket)) { + continue; + } + PcctAdvertiseSharedMemoryAddress (Socket, Doorbell, Subspace); + MailboxUnmaskInterrupt (Socket, Doorbell); + + Subspace++; + } + } + + return EFI_SUCCESS; +} + +/** + Install PCCT table. + + PCC channels are associated with hardware doorbell instances to provide + bi-directional communication between the OS and platform entities. + +**/ +EFI_STATUS +AcpiInstallPcctTable ( + VOID + ) +{ + EFI_STATUS Status; + EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER *PcctTableHeade= r; + EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS *PccSubspacePtr= ; + EFI_PHYSICAL_ADDRESS PccSharedMemory= Ptr; + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProto= col; + UINTN PcctTableKey; + UINT8 SocketCount; + UINT8 Socket; + UINT16 Doorbell; + UINT16 Subspace; + UINT16 SubspaceCount; + UINTN Size; + UINTN DoorbellAddress= ; + UINTN DoorbellCount; + + Subspace =3D 0; + SocketCount =3D GetNumberOfActiveSockets (); + DoorbellCount =3D PcctGetNumberOfAvailableDoorbells (); + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + + SubspaceCount =3D DoorbellCount * SocketCount; + + PcctAllocateSharedMemory (SubspaceCount, &PccSharedMemoryPtr); + if (PccSharedMemoryPtr =3D=3D (EFI_PHYSICAL_ADDRESS)(UINTN)NULL) { + return EFI_OUT_OF_RESOURCES; + } + + Size =3D sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADE= R) + + SubspaceCount * sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_= COMMUNICATIONS); + + PcctTableHeader =3D (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_H= EADER *)AllocateZeroPool (Size); + if (PcctTableHeader =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + + PccSubspacePtr =3D (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIO= NS *)(PcctTableHeader + 1); + + for (Socket =3D 0; Socket < SocketCount; Socket++) { + for (Doorbell =3D 0; Doorbell < NUMBER_OF_DOORBELLS_PER_SOCKET; Doorbe= ll++ ) { + if (PcctIsDoorbellReserved (Doorbell + NUMBER_OF_DOORBELLS_PER_SOCKE= T * Socket)) { + continue; + } + + CopyMem ( + PccSubspacePtr, + &PcctSubspaceTemplate, + sizeof (EFI_ACPI_6_3_PCCT_SUBSPACE_2_HW_REDUCED_COMMUNICATIONS) + ); + + PccSubspacePtr->BaseAddress =3D (UINT64)PccSharedMemoryPtr + PCC_SUB= SPACE_SHARED_MEM_SIZE * Subspace; + PccSubspacePtr->AddressLength =3D PCC_SUBSPACE_SHARED_MEM_SIZE; + + DoorbellAddress =3D MailboxGetDoorbellAddress (Socket, Doorbell); + + PccSubspacePtr->DoorbellRegister.Address =3D DoorbellAddress + DB_OU= T_REG_OFST; + PccSubspacePtr->PlatformInterrupt =3D MailboxGetDoorbellInterruptNum= ber (Socket, Doorbell); + PccSubspacePtr->PlatformInterruptAckRegister.Address =3D DoorbellAdd= ress + DB_STATUS_REG_OFST; + + if (Doorbell =3D=3D PCC_CPPC_DOORBELL_ID) { + PccSubspacePtr->DoorbellWrite =3D MAILBOX_URGENT_CPPC_MESSAGE; + PccSubspacePtr->NominalLatency =3D PCC_CPPC_NOMINAL_LATENCY_US; + PccSubspacePtr->MinimumRequestTurnaroundTime =3D PCC_CPPC_MIN_REQ_= TURNAROUND_TIME_US; + } else { + PccSubspacePtr->DoorbellWrite =3D MAILBOX_TYPICAL_PCC_MESSAGE; + PccSubspacePtr->NominalLatency =3D PCC_NOMINAL_LATENCY_US; + PccSubspacePtr->MinimumRequestTurnaroundTime =3D PCC_MIN_REQ_TURNA= ROUND_TIME_US; + } + PccSubspacePtr->MaximumPeriodicAccessRate =3D PCC_MAX_PERIODIC_ACCES= S_RATE; + + PccSubspacePtr++; + Subspace++; + } + } + + CopyMem ( + PcctTableHeader, + &PcctTableHeaderTemplate, + sizeof (EFI_ACPI_6_3_PLATFORM_COMMUNICATION_CHANNEL_TABLE_HEADER) + ); + + PcctTableHeader->Header.Length =3D Size; + + AcpiUpdateChecksum ( + (UINT8 *)PcctTableHeader, + PcctTableHeader->Header.Length + ); + + Status =3D AcpiTableProtocol->InstallAcpiTable ( + AcpiTableProtocol, + (VOID *)PcctTableHeader, + PcctTableHeader->Header.Length, + &PcctTableKey + ); + if (EFI_ERROR (Status)) { + PcctFreeSharedMemory (); + FreePool ((VOID *)PcctTableHeader); + return Status; + } + + return EFI_SUCCESS; +} diff --git a/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDx= e.c b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPlatformDxe.c new file mode 100644 index 000000000000..c4022eb056e0 --- /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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "AcpiApei.h" +#include "AcpiPlatform.h" + +STATIC EFI_EVENT mAcpiRegistration =3D NULL; + +/* + * This GUID must match the FILE_GUID in AcpiTables.inf of each boards + */ +STATIC CONST EFI_GUID mAcpiCommonTableFile =3D { 0xCEFA2AEB, 0x357E, 0x4F4= 8, { 0x80, 0x66, 0xEA, 0x95, 0x08, 0x53, 0x05, 0x6E } } ; +STATIC CONST EFI_GUID mJadeAcpiTableFile =3D { 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 =3D LocateAndInstallAcpiFromFv (&mAcpiCommonTableFile); + ASSERT_EFI_ERROR (Status); + + Status =3D LocateAndInstallAcpiFromFv (&mJadeAcpiTableFile); + ASSERT_EFI_ERROR (Status); + + // + // Find ACPI table RSD_PTR from the system table. + // + Status =3D EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **)= &Rsdp); + if (EFI_ERROR (Status)) { + Status =3D EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID= **)&Rsdp); + } + + if (!EFI_ERROR (Status) && + Rsdp !=3D NULL && + Rsdp->Revision >=3D EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REV= ISION && + Rsdp->RsdtAddress !=3D 0) + { + // ARM Platforms must set the RSDT address to NULL + Rsdp->RsdtAddress =3D 0; + } + + DEBUG ((DEBUG_INFO, "[%a:%d]-\n", __FUNCTION__, __LINE__)); +} + +VOID +EFIAPI +InstallAcpiOnReadyToBoot ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + EFI_STATUS Status; + + Status =3D AcpiInstallMadtTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed MADT table\n")); + } + + Status =3D AcpiInstallPpttTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed PPTT table\n")); + } + + Status =3D AcpiInstallSlitTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed SLIT table\n")); + } + + Status =3D AcpiInstallSratTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed SRAT table\n")); + } + + Status =3D AcpiInstallPcctTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed PCCT table\n")); + } + + Status =3D AcpiInstallNfitTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "Installed NFIT table\n")); + } + + Status =3D 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 =3D AcpiPatchDsdtTable (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "DSDT Table updated!\n")); + } + + // Configure ACPI Platform Error Interfaces + Status =3D AcpiApeiUpdate (); + if (!EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "APEI Table updated!\n")); + } + + // Advertise shared memory regions to SMpro/PMpro and unmask interrupt + Status =3D AcpiPcctInitializeSharedMemory (); + 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 =3D gBS->CreateEvent ( + EVT_SIGNAL_EXIT_BOOT_SERVICES, + TPL_CALLBACK, + UpdateAcpiOnExitBootServices, + NULL, + &ExitBootServicesEvent + ); + ASSERT_EFI_ERROR (Status); + + Status =3D 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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c new file mode 100644 index 000000000000..0e09a17cc52d --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiPptt.c @@ -0,0 +1,333 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include "AcpiPlatform.h" + +EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR PPTTProcessorTemplate =3D { + 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 =3D { + 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 PPTTTableHeaderTem= plate =3D { + __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 *PpttTableP= ointer; +STATIC UINT32 PpttCluster= Offset[PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET]; +STATIC UINT32 PpttSocketO= ffset[PLATFORM_CPU_MAX_SOCKET]; +STATIC UINT32 PpttRootOff= set; +STATIC UINT32 PpttL1DataC= acheOffset[PLATFORM_CPU_MAX_NUM_CORES]; +STATIC UINT32 PpttL1Instr= uctionCacheOffset[PLATFORM_CPU_MAX_NUM_CORES]; +STATIC UINT32 PpttL2Cache= Offset[PLATFORM_CPU_MAX_NUM_CORES]; + +UINT32 +AcpiPpttProcessorCoreNode ( + VOID *EntryPointer, + UINT32 CpuId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer =3D Ent= ryPointer; + UINT32 *ResPointer; + UINTN ClusterIdPerSocket, CoreIdPerCpm, = SocketId; + + CopyMem ( + PpttProcessorEntryPointer, + &PPTTProcessorTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + ); + + ClusterIdPerSocket =3D (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) % PLATFO= RM_CPU_MAX_CPM; + SocketId =3D (CpuId / PLATFORM_CPU_NUM_CORES_PER_CPM) / PLATFORM_CPU_MAX= _CPM; + CoreIdPerCpm =3D CpuId % PLATFORM_CPU_NUM_CORES_PER_CPM; + PpttProcessorEntryPointer->Flags.AcpiProcessorIdValid =3D 1; + PpttProcessorEntryPointer->Flags.NodeIsALeaf =3D 1; + PpttProcessorEntryPointer->Flags.IdenticalImplementation =3D 1; + PpttProcessorEntryPointer->AcpiProcessorId =3D (SocketId << PLATFORM_SOC= KET_UID_BIT_OFFSET) | (ClusterIdPerSocket << 8) | CoreIdPerCpm; + PpttProcessorEntryPointer->Parent =3D (UINT32)PpttClusterOffset[CpuId / = PLATFORM_CPU_NUM_CORES_PER_CPM]; + PpttProcessorEntryPointer->NumberOfPrivateResources =3D 2; /* L1I + L1D = */ + + ResPointer =3D (UINT32 *)((UINT64)EntryPointer + + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR)); + ResPointer[0] =3D PpttL1InstructionCacheOffset[CpuId]; + ResPointer[1] =3D PpttL1DataCacheOffset[CpuId]; + + PpttProcessorEntryPointer->Length =3D sizeof (EFI_ACPI_6_3_PPTT_STRUCTUR= E_PROCESSOR) + 2 * sizeof (UINT32); + + return PpttProcessorEntryPointer->Length; +} + +STATIC UINT32 +AcpiPpttClusterNode ( + VOID *EntryPointer, + UINT32 ClusterId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer =3D Ent= ryPointer; + + PpttClusterOffset[ClusterId] =3D (UINT64)EntryPointer - (UINT64)PpttTabl= ePointer; + + CopyMem ( + PpttProcessorEntryPointer, + &PPTTProcessorTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + ); + + PpttProcessorEntryPointer->Parent =3D (UINT32)PpttSocketOffset[ClusterId= / PLATFORM_CPU_MAX_CPM]; + PpttProcessorEntryPointer->Flags.IdenticalImplementation =3D 1; + + return PpttProcessorEntryPointer->Length; +} + +STATIC UINT32 +AcpiPpttSocketNode ( + VOID *EntryPointer, + UINT32 SocketId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer =3D Ent= ryPointer; + + PpttSocketOffset[SocketId] =3D (UINT64)EntryPointer - (UINT64)PpttTableP= ointer; + + CopyMem ( + PpttProcessorEntryPointer, + &PPTTProcessorTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + ); + + PpttProcessorEntryPointer->Flags.PhysicalPackage =3D 1; + PpttProcessorEntryPointer->Flags.IdenticalImplementation =3D 1; + PpttProcessorEntryPointer->Parent =3D (UINT32)PpttRootOffset; + + return PpttProcessorEntryPointer->Length; +} + +STATIC UINT32 +AcpiPpttRootNode ( + VOID *EntryPointer + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer =3D Ent= ryPointer; + + PpttRootOffset =3D (UINT64)EntryPointer - (UINT64)PpttTablePointer; + + CopyMem ( + PpttProcessorEntryPointer, + &PPTTProcessorTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR) + ); + + PpttProcessorEntryPointer->Flags.IdenticalImplementation =3D 1; + + return PpttProcessorEntryPointer->Length; +} + +STATIC VOID +AcpiPpttFillCacheSizeInfo ( + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *Node, + UINT32 Level, + BOOLEAN DataCache, + BOOLEAN UnifiedCache + ) +{ + CSSELR_DATA CsselrData; + CCSIDR_DATA CcsidrData; + + CsselrData.Data =3D 0; + CsselrData.Bits.Level =3D Level - 1; + CsselrData.Bits.InD =3D (!DataCache && !UnifiedCache); + + CcsidrData.Data =3D ReadCCSIDR (CsselrData.Data); + + Node->Flags.LineSizeValid =3D 1; + Node->Flags.NumberOfSetsValid =3D 1; + Node->Flags.AssociativityValid =3D 1; + Node->Flags.SizePropertyValid =3D 1; + Node->Flags.CacheTypeValid =3D 1; + Node->NumberOfSets =3D (UINT16)CcsidrData.BitsNonCcidx.NumSets + 1; + Node->Associativity =3D (UINT16)CcsidrData.BitsNonCcidx.Associativity + = 1; + Node->LineSize =3D (UINT16)(1 << (CcsidrData.BitsNonCcidx.LineSize + 4))= ;; + Node->Size =3D Node->NumberOfSets * + Node->Associativity * + Node->LineSize; +} + +STATIC UINT32 +AcpiPpttL1DataCacheNode ( + VOID *EntryPointer, + UINT32 CpuId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer =3D EntryPointe= r; + + PpttL1DataCacheOffset[CpuId] =3D (UINT64)EntryPointer - (UINT64)PpttTabl= ePointer; + CopyMem ( + PpttCacheEntryPointer, + &PPTTCacheTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE) + ); + + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1, TRUE, FALSE); + PpttCacheEntryPointer->Attributes.CacheType =3D 0x0; /* Data Cache */ + PpttCacheEntryPointer->NextLevelOfCache =3D PpttL2CacheOffset[CpuId]; + + return PpttCacheEntryPointer->Length; +} + +STATIC UINT32 +AcpiPpttL1InstructionCacheNode ( + VOID *EntryPointer, + UINT32 CpuId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer =3D EntryPointe= r; + + PpttL1InstructionCacheOffset[CpuId] =3D (UINT64)EntryPointer - (UINT64)P= pttTablePointer; + CopyMem ( + PpttCacheEntryPointer, + &PPTTCacheTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE) + ); + + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 1, FALSE, FALSE); + PpttCacheEntryPointer->Attributes.CacheType =3D 0x1; /* Instruction Cach= e */ + PpttCacheEntryPointer->NextLevelOfCache =3D PpttL2CacheOffset[CpuId]; + + return PpttCacheEntryPointer->Length; +} + +STATIC UINT32 +AcpiPpttL2CacheNode ( + VOID *EntryPointer, + UINT32 CpuId + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE *PpttCacheEntryPointer =3D EntryPointe= r; + + PpttL2CacheOffset[CpuId] =3D (UINT64)EntryPointer - (UINT64)PpttTablePoi= nter; + CopyMem ( + PpttCacheEntryPointer, + &PPTTCacheTemplate, + sizeof (EFI_ACPI_6_3_PPTT_STRUCTURE_CACHE) + ); + + AcpiPpttFillCacheSizeInfo (PpttCacheEntryPointer, 2, FALSE, TRUE); + PpttCacheEntryPointer->Attributes.CacheType =3D 0x3; /* Unified Cache */ + PpttCacheEntryPointer->NextLevelOfCache =3D 0; + + return PpttCacheEntryPointer->Length; +} + +/* + * Install PPTT table. + */ +EFI_STATUS +AcpiInstallPpttTable ( + VOID + ) +{ + EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *PpttProcessorEntryPointer =3D NUL= L; + EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol; + UINTN PpttTableKey =3D 0; + INTN Count; + EFI_STATUS Status; + UINTN Size; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + + Size =3D 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_P= ROCESSOR)) + /* Socket node */ + (PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET * sizeof (EFI_AC= PI_6_3_PPTT_STRUCTURE_PROCESSOR)) + /* Cluster node */ + (PLATFORM_CPU_MAX_NUM_CORES * (sizeof (EFI_ACPI_6_3_PPTT_STRUCTU= RE_PROCESSOR) + 2 * sizeof (UINT32))) + /* Core node */ + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTUR= E_CACHE)) + /* L1I node */ + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTUR= E_CACHE)) + /* L1D node */ + (PLATFORM_CPU_MAX_NUM_CORES * sizeof (EFI_ACPI_6_3_PPTT_STRUCTUR= E_CACHE)); /* L2 node */ + + PpttTablePointer =3D + (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *)AllocateZer= oPool (Size); + if (PpttTablePointer =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + + PpttProcessorEntryPointer =3D + (EFI_ACPI_6_3_PPTT_STRUCTURE_PROCESSOR *)((UINT64)PpttTablePointer + + sizeof (EFI_ACPI_6_3_PROCESS= OR_PROPERTIES_TOPOLOGY_TABLE_HEADER)); + + Size =3D 0; + Size +=3D AcpiPpttRootNode ((VOID *)((UINT64)PpttProcessorEntryPointer += Size)); + + for (Count =3D 0; Count < PLATFORM_CPU_MAX_SOCKET; Count++) { + Size +=3D AcpiPpttSocketNode ((VOID *)((UINT64)PpttProcessorEntryPoint= er + Size), Count); + } + + for (Count =3D 0; Count < PLATFORM_CPU_MAX_CPM * PLATFORM_CPU_MAX_SOCKET= ; Count++) { + Size +=3D AcpiPpttClusterNode ((VOID *)((UINT64)PpttProcessorEntryPoin= ter + Size), Count); + } + + for (Count =3D 0; Count < PLATFORM_CPU_MAX_NUM_CORES; Count++) { + Size +=3D AcpiPpttL2CacheNode ((VOID *)((UINT64)PpttProcessorEntryPoin= ter + Size), Count); + Size +=3D AcpiPpttL1InstructionCacheNode ((VOID *)((UINT64)PpttProcess= orEntryPointer + Size), Count); + Size +=3D AcpiPpttL1DataCacheNode ((VOID *)((UINT64)PpttProcessorEntry= Pointer + Size), Count); + Size +=3D AcpiPpttProcessorCoreNode ((VOID *)((UINT64)PpttProcessorEnt= ryPointer + Size), Count); + } + + CopyMem ( + PpttTablePointer, + &PPTTTableHeaderTemplate, + sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER) + ); + + Size +=3D sizeof (EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADE= R); + PpttTablePointer->Header.Length =3D Size; + + AcpiUpdateChecksum ((UINT8 *)PpttTablePointer, PpttTablePointer->Header.= Length); + + Status =3D 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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c new file mode 100644 index 000000000000..0b534e739b4e --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSlit.c @@ -0,0 +1,187 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + 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 SLITTableHe= aderTemplate =3D { + __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 =3D 0; + *Y =3D 0; + break; + case 1: + *X =3D 1; + *Y =3D 0; + break; + case 2: + *X =3D 0; + *Y =3D 1; + break; + case 3: + *X =3D 1; + *Y =3D 1; + break; + default: + *X =3D 0; + *Y =3D 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 =3D ABS ((INTN)(X1 - X2)); + YDistance =3D 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 No= de 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 =3D 0; + RemoteDistance =3D 0; + if (LocalNode >=3D (MAX_NODES_PER_SOCKET / 2)) { + LocalDistance =3D 1; + } + if (RemoteNode >=3D (MAX_NODES_PER_SOCKET / 2)) { + RemoteDistance =3D 1; + } + + return (UINT8)(LocalDistance + RemoteDistance + REMOTE_DISTANCE); +} + +UINT8 +ComputeSlitDistance ( + UINTN Node1, + UINTN Node2, + UINTN DomainsPerSocket + ) +{ + UINT8 Distance; + + Distance =3D 0; + if ((Node1 / DomainsPerSocket) =3D=3D (Node2 / DomainsPerSocket)) { + Distance =3D ComputeSlitDistanceOnSocket ( + Node1 % DomainsPerSocket, + Node2 % DomainsPerSocket + ); + } else { + Distance =3D ComputeSlitDistanceOnRemoteSocket ( + Node1 % DomainsPerSocket, + Node2 % DomainsPerSocket + ); + } + + return Distance; +} + +EFI_STATUS +AcpiInstallSlitTable ( + VOID + ) +{ + EFI_ACPI_TABLE_PROTOCOL *AcpiTabl= eProtocol; + EFI_STATUS Status; + UINTN NumDomain= , Count, Count1; + EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_TABLE_HEADER *SlitTabl= ePointer; + UINT8 *TmpPtr; + UINTN SlitTable= Key; + UINTN NumDomain= PerSocket; + + Status =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + + NumDomainPerSocket =3D CpuGetNumberOfSubNumaRegion (); + NumDomain =3D NumDomainPerSocket * GetNumberOfActiveSockets (); + + SlitTablePointer =3D (EFI_ACPI_6_3_SYSTEM_LOCALITY_DISTANCE_INFORMATION_= TABLE_HEADER *) + AllocateZeroPool (sizeof (SLITTableHeaderTemplate) + = NumDomain * NumDomain); + if (SlitTablePointer =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + CopyMem ((VOID *)SlitTablePointer, (VOID *)&SLITTableHeaderTemplate, siz= eof (SLITTableHeaderTemplate)); + SlitTablePointer->NumberOfSystemLocalities =3D NumDomain; + TmpPtr =3D (UINT8 *)SlitTablePointer + sizeof (SLITTableHeaderTemplate); + for (Count =3D 0; Count < NumDomain; Count++) { + for (Count1 =3D 0; Count1 < NumDomain; Count1++, TmpPtr++) { + *TmpPtr =3D ComputeSlitDistance (Count, Count1, NumDomainPerSocket); + } + } + + SlitTablePointer->Header.Length =3D sizeof (SLITTableHeaderTemplate) + N= umDomain * NumDomain; + + AcpiUpdateChecksum ((UINT8 *)SlitTablePointer, SlitTablePointer->Header.= Length); + + Status =3D 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/P= latform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c new file mode 100644 index 000000000000..906b771a250c --- /dev/null +++ b/Platform/Ampere/JadePkg/Drivers/AcpiPlatformDxe/AcpiSrat.c @@ -0,0 +1,271 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include "AcpiPlatform.h" + +EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER SRATTableHeaderTemplate= =3D { + __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 =3D { + .Type =3D EFI_ACPI_6_3_GIC_ITS_AFFINITY, + sizeof (EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE), + .ProximityDomain =3D 0, /* ProximityDomain */ + { EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE }, + .ItsId =3D 0, +}; + +STATIC +UINTN +SratCalculateNumMemoryRegion ( + VOID + ) +{ + PLATFORM_INFO_HOB *PlatformHob; + UINTN Count; + UINT64 TmpVal; + VOID *Hob; + UINTN Result; + + /* Get the Platform HOB */ + Hob =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL) { + return 0; + } + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + Result =3D 0; + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) { + TmpVal =3D 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 =3D GetFirstGuidHob (&gPlatformInfoHobGuid); + if (Hob =3D=3D NULL) { + return EFI_INVALID_PARAMETER; + } + PlatformHob =3D (PLATFORM_INFO_HOB *)GET_GUID_HOB_DATA (Hob); + + NumRegion =3D 0; + + for (Count =3D 0; Count < PlatformHob->DramInfo.NumRegion; Count++) { + RegionSize =3D PlatformHob->DramInfo.Size[Count]; + RegionBase =3D PlatformHob->DramInfo.Base[Count]; + ProximityDomain =3D PlatformHob->DramInfo.Node[Count]; + if (RegionSize > 0) { + ZeroMem ((VOID *)&SratMemAffinity[NumRegion], sizeof (SratMemAffinit= y[NumRegion])); + SratMemAffinity[NumRegion].Flags =3D EFI_ACPI_6_3_MEMORY_ENABLED; + if (PlatformHob->DramInfo.NvdRegion[Count] !=3D 0) { + /* Mark NVDIMM-N region as HOT_PLUGGABLE and NON-VOLATILE */ + SratMemAffinity[NumRegion].Flags |=3D EFI_ACPI_6_3_MEMORY_HOT_PLUG= GABLE | + EFI_ACPI_6_3_MEMORY_NONVOLATIL= E; + } + SratMemAffinity[NumRegion].LengthLow =3D + (UINT32)(RegionSize & 0xFFFFFFFF); + SratMemAffinity[NumRegion].LengthHigh =3D + (UINT32)((RegionSize & 0xFFFFFFFF00000000ULL) >> 32); + SratMemAffinity[NumRegion].AddressBaseLow =3D + (UINT32)(RegionBase & 0xFFFFFFFF); + SratMemAffinity[NumRegion].AddressBaseHigh =3D + (UINT32)((RegionBase & 0xFFFFFFFF00000000ULL) >> 32); + SratMemAffinity[NumRegion].ProximityDomain =3D (UINT32)(ProximityDom= ain); + SratMemAffinity[NumRegion].Type =3D EFI_ACPI_6_3_MEMORY_AFFINITY; + SratMemAffinity[NumRegion].Length =3D sizeof (EFI_ACPI_6_3_MEMORY_AF= FINITY_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 =3D 0; Idx < gST->NumberOfTableEntries; Idx++) { + if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Idx].V= endorGuid))) { + ArmProcessorTable =3D (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable= [Idx].VendorTable; + ArmCoreInfoTable =3D ArmProcessorTable->ArmCpus; + break; + } + } + + if (Idx =3D=3D gST->NumberOfTableEntries) { + return EFI_INVALID_PARAMETER; + } + + Count =3D 0; + NumNode =3D 0; + while (Count !=3D ArmProcessorTable->NumberOfEntries) { + for (Idx =3D 0; Idx < ArmProcessorTable->NumberOfEntries; Idx++ ) { + Socket =3D ArmCoreInfoTable[Idx].ClusterId; + Cpm =3D (ArmCoreInfoTable[Idx].CoreId >> PLATFORM_CPM_UID_BIT_OFFSET= ); + if (CpuGetSubNumNode (Socket, Cpm) !=3D NumNode) { + /* We add nodes based on ProximityDomain order */ + continue; + } + AcpiProcessorUid =3D (ArmCoreInfoTable[Idx].ClusterId << PLATFORM_SO= CKET_UID_BIT_OFFSET) + + ArmCoreInfoTable[Idx].CoreId; + ZeroMem ((VOID *)&SratGiccAffinity[Count], sizeof (SratGiccAffinity[= Count])); + SratGiccAffinity[Count].AcpiProcessorUid =3D AcpiProcessorUid; + SratGiccAffinity[Count].Flags =3D 1; + SratGiccAffinity[Count].Length =3D sizeof (EFI_ACPI_6_3_GICC_AFFINIT= Y_STRUCTURE); + SratGiccAffinity[Count].Type =3D EFI_ACPI_6_3_GICC_AFFINITY; + SratGiccAffinity[Count].ProximityDomain =3D CpuGetSubNumNode (Socket= , Cpm); + Count++; + } + NumNode++; + } + + return EFI_SUCCESS; +} + +STATIC UINT32 +InstallGicItsAffinity ( + VOID *EntryPointer, + UINT32 Index + ) +{ + EFI_ACPI_6_3_GIC_ITS_AFFINITY_STRUCTURE *ItsAffinityEntryPointer =3D Ent= ryPointer; + UINTN Size; + + Size =3D sizeof (GicItsAffinityTemplate); + CopyMem (ItsAffinityEntryPointer, &GicItsAffinityTemplate, Size); + return Size; +} + +STATIC +EFI_STATUS +SratAddGicItsAffinity ( + VOID *TmpPtr + ) +{ + UINTN Size =3D 0; + UINTN Index; + + /* Install Gic ITSAffinity */ + if (!IsSlaveSocketAvailable ()) { + for (Index =3D 0; Index <=3D 1; Index++) { /* RCA0/1 */ + GicItsAffinityTemplate.ItsId =3D Index; + GicItsAffinityTemplate.ProximityDomain =3D 0; + Size +=3D InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), In= dex); + } + } + + for (Index =3D SOCKET0_FIRST_RC; Index <=3D SOCKET0_LAST_RC; Index++) { + GicItsAffinityTemplate.ItsId =3D Index; + GicItsAffinityTemplate.ProximityDomain =3D 0; + Size +=3D InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), Inde= x); + } + + if (IsSlaveSocketActive ()) { + for (Index =3D SOCKET1_FIRST_RC; Index <=3D SOCKET1_LAST_RC; Index++) = { + GicItsAffinityTemplate.ItsId =3D Index; + GicItsAffinityTemplate.ProximityDomain =3D 1; + Size +=3D InstallGicItsAffinity ((VOID *)((UINT64)TmpPtr + Size), In= dex); + } + } + + 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 =3D gBS->LocateProtocol ( + &gEfiAcpiTableProtocolGuid, + NULL, + (VOID **)&AcpiTableProtocol + ); + if (EFI_ERROR (Status)) { + return Status; + } + + Size =3D sizeof (SRATTableHeaderTemplate) + + SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMORY_AFF= INITY_STRUCTURE) + + GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINITY_ST= RUCTURE) + + ((SOCKET0_LAST_RC - SOCKET0_FIRST_RC + 1) * sizeof (GicItsAffini= tyTemplate)); + if (IsSlaveSocketActive ()) { + Size +=3D (SOCKET1_LAST_RC - SOCKET1_FIRST_RC + 1) * sizeof (GicItsAf= finityTemplate); + } else if (!IsSlaveSocketAvailable ()) { + Size +=3D 2 * sizeof (GicItsAffinityTemplate); /* RCA0/1 */ + } + + SratTablePointer =3D (EFI_ACPI_6_3_SYSTEM_RESOURCE_AFFINITY_TABLE_HEADER= *)AllocateZeroPool (Size); + if (SratTablePointer =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + CopyMem ((VOID *)SratTablePointer, (VOID *)&SRATTableHeaderTemplate, siz= eof (SRATTableHeaderTemplate)); + + TmpPtr =3D (UINT8 *)SratTablePointer + sizeof (SRATTableHeaderTemplate); + Status =3D SratAddMemAffinity ((EFI_ACPI_6_3_MEMORY_AFFINITY_STRUCTURE *= )TmpPtr); + ASSERT_EFI_ERROR (Status); + + TmpPtr +=3D SratCalculateNumMemoryRegion () * sizeof (EFI_ACPI_6_3_MEMOR= Y_AFFINITY_STRUCTURE); + Status =3D SratAddGiccAffinity ((EFI_ACPI_6_3_GICC_AFFINITY_STRUCTURE *)= TmpPtr); + ASSERT_EFI_ERROR (Status); + + TmpPtr +=3D GetNumberOfActiveCores () * sizeof (EFI_ACPI_6_3_GICC_AFFINI= TY_STRUCTURE); + SratAddGicItsAffinity ((VOID *)(UINT64)TmpPtr); + SratTablePointer->Header.Length =3D Size; + + AcpiUpdateChecksum ((UINT8 *)SratTablePointer, SratTablePointer->Header.= Length); + + Status =3D 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/Amper= e/JadePkg/AcpiTables/CPU-S0.asi new file mode 100644 index 000000000000..969cece130ad --- /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. + + 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x43c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x4bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x53c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x5bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x63c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x6bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x73c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x7bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x83c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x8bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x93c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x9bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xa3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xabc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xb3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xc3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xcbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xd3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xdbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xe3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xebc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xf3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xfbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x103c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x10bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x113c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x11bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x123c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x12bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x133c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x143c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x14bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x153c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x15bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x163c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x16bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x173c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x17bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x183c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x18bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x193c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x19bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1a3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1abc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1b3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1c3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1cbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1dbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1e3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ebc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1f3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1fbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x203c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x20bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x213c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x21bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x223c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x22bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x233c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x243c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x24bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x253c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x25bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x263c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x26bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x273c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x27bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x283c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x28bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x293c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x29bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2a3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2abc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2b3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2c3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2cbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2dbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2e3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ebc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2f3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2fbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x303c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x30bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x313c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x31bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x323c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x32bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x333c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x343c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x34bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x353c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x35bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x363c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x36bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x373c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x37bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x383c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x38bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x393c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x39bc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3a3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3abc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3b3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3cbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3dbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3e3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ebc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3f3c, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3fbc, 2)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Referen= ce 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/Amper= e/JadePkg/AcpiTables/CPU-S1.asi new file mode 100644 index 000000000000..e0def4064fd7 --- /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. + + 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x050, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x0d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x12c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x134, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x150, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x22c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x234, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x250, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x32c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x334, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x350, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x42c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x434, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x43c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x450, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x4ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x4b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x4bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x4d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x52c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x534, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x53c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x550, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x5ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x5b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x5bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x5d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x62c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x634, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x63c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x650, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x6ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x6b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x6bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x6d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x72c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x734, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x73c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x750, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x7ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x7b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x7bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x7d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x82c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x834, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x83c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x850, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x8ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x8b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x8bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x8d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x92c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x934, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x93c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x950, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x9ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x9b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x9bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x9d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xa2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xa34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xa3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xa50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xaac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xab4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xabc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xad0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xb2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xb34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xb3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xb50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xbac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xbb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xbd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xc2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xc34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xc3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xc50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xcac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xcb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xcbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xcd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xd2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xd34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xd3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xd50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xdac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xdb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xdbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xdd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xe2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xe34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xe3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xe50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xeac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xeb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xebc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xed0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xf2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xf34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xf3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xf50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0xfac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0xfb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0xfbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0xfd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x102c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1034, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x103c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1050, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x10ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x10b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x10bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x10d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x112c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1134, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x113c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1150, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x11ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x11b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x11bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x11d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x122c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1234, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x123c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1250, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x12ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x12b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x12bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x12d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x132c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1334, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x133c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1350, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x13ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x13b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x13d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x142c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1434, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x143c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1450, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x14ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x14b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x14bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x14d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x152c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1534, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x153c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1550, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x15ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x15b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x15bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x15d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x162c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1634, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x163c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1650, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x16ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x16b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x16bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x16d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x172c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1734, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x173c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1750, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x17ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x17b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x17bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x17d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x182c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1834, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x183c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1850, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x18ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x18b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x18bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x18d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x192c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1934, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x193c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1950, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x19ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x19b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x19bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x19d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1a2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1a34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1a3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1a50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1aac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1ab4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1abc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ad0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1b2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1b34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1b3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1b50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1bac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1bb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1bd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1c2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1c34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1c3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1c50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1cac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1cb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1cbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1cd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1d2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1d34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1d50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1dac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1db4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1dbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1dd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1e2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1e34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1e3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1e50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1eac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1eb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ebc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1ed0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1f2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1f34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1f3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1f50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x1fac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x1fb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1fbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x1fd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x202c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2034, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x203c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2050, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x20ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x20b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x20bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x20d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x212c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2134, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x213c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2150, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x21ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x21b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x21bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x21d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x222c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2234, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x223c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2250, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x22ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x22b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x22bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x22d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x232c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2334, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x233c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2350, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x23ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x23b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x23d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x242c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2434, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x243c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2450, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x24ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x24b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x24bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x24d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x252c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2534, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x253c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2550, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x25ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x25b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x25bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x25d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x262c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2634, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x263c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2650, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x26ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x26b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x26bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x26d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x272c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2734, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x273c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2750, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x27ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x27b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x27bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x27d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x282c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2834, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x283c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2850, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x28ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x28b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x28bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x28d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x292c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2934, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x293c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2950, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x29ac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x29b4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x29bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x29d0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2a2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2a34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2a3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2a50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2aac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2ab4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2abc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ad0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2b2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2b34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2b3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2b50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2bac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2bb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2bd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2c2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2c34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2c3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2c50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2cac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2cb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2cbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2cd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2d2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2d34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2d50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2dac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2db4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2dbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2dd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2e2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2e34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2e3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2e50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2eac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2eb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ebc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2ed0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2f2c, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2f34, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2f3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2f50, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x2fac, 17)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x2fb4, 17)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2fbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x2fd0, 17)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x302c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3034, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x303c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3050, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x30ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x30b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x30bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x30d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x312c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3134, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x313c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3150, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x31ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x31b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x31bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x31d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x322c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3234, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x323c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3250, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x32ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x32b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x32bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x32d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x332c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3334, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x333c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3350, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x33ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x33b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x33d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x342c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3434, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x343c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3450, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x34ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x34b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x34bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x34d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x352c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3534, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x353c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3550, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x35ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x35b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x35bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x35d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x362c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3634, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x363c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3650, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x36ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x36b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x36bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x36d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x372c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3734, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x373c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3750, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x37ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x37b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x37bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x37d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x382c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3834, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x383c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3850, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x38ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x38b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x38bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x38d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x392c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3934, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x393c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3950, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x39ac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x39b4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x39bc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x39d0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3a2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3a34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3a3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3a50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3aac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3ab4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3abc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ad0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3b2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3b34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3b3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3b50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3bac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3bb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3bd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3c2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3c34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3c50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3cac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3cb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3cbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3cd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3d2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3d34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3d50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3dac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3db4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3dbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3dd0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3e2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3e34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3e3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3e50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3eac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3eb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ebc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3ed0, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3f2c, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3f34, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3f3c, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3f50, 2)}, // Referen= ce 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, // NumEntr= ies + 3, // Revisio= n + 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)}, // Guarant= eed 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)}, // Perform= ance Reduction Tolerance Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Time Wi= ndow Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Counter= Wraparound Time + ResourceTemplate(){Register(PCC, 64, 0, 0x3fac, 2)}, // Referen= ce Counter Register + ResourceTemplate(){Register(PCC, 64, 0, 0x3fb4, 2)}, // Deliver= ed Counter Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3fbc, 17)}, // Perform= ance Limited Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Enable = Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Selection Enable + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Autonom= ous Activity Window Register + ResourceTemplate(){Register(SystemMemory, 0, 0, 0, 0)}, // Energy = Performance Preference Register + ResourceTemplate(){Register(PCC, 32, 0, 0x3fd0, 2)}, // Referen= ce 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/J= adePkg/AcpiTables/CPU.asi new file mode 100644 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.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +Name (CPCE, 1) // CPPC Enable +Name (LPIE, 0) // LPI Enable + +Method (_OSC, 4, Serialized) { // _OSC: Operating System Capabilit= ies + CreateDWordField (Arg3, 0x00, STS0) + CreateDWordField (Arg3, 0x04, CAP0) + If (LEqual(Arg0, ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48")) /* Pla= tform-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 100644 index 000000000000..9c0ee4c44f94 --- /dev/null +++ b/Platform/Ampere/JadePkg/AcpiTables/Dsdt.asl @@ -0,0 +1,531 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +DefinitionBlock("Dsdt.aml", "DSDT", 0x02, "Ampere", "Jade", 1) { + // + // Board Model + Name(\BDMD, "Jade Board") + 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(_SRV) { + Return(0x0200) // IPMI Specification Revision + } + Name(_CRS, ResourceTemplate () + { + I2cSerialBusV2 (0x0010, ControllerInitiated, 0x00061A80, + AddressingMode7Bit, "\\_SB.I2C4", + 0x00, ResourceConsumer,, Exclusive, + // Vendor specific data: + // "BMC0", + // Flags (2 bytes): SMBUS variable length (Bit 0), Read Checks= um (Bit 1), Verify Checksum (Bit 2) + RawDataBuffer () { 0x42, 0x4D, 0x43, 0x30, 0x7, 0x0 } + ) + }) + } + 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 =3D Generic Event Device (ACPI0013) + // HED =3D 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(_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) + } + } + } + + 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/Amp= ere/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.
+ + 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 100644 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. + + 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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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/Amper= e/JadePkg/AcpiTables/PCI-S0.asi new file mode 100644 index 000000000000..f6d788cd99b0 --- /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. + + 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 disab= led + // 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-9fd= e-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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 + 0x0000000004000000, // AddressMinimum - MIN + 0x0000000007FFFFFF, // AddressMinimum - MAX + 0x0000000000000000, // AddressTranslation - TRA + 0x0000000004000000 // 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 disab= led + // 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-9fd= e-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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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/Amper= e/JadePkg/AcpiTables/PCI-S1.asi new file mode 100644 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. + + 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 disab= led + // 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-9fd= e-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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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. Unfor= tunately, it breaks + // run-time patching as the repres= entation 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 disab= led + // 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-9fd= e-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/Amper= e/JadePkg/AcpiTables/PMU-S0.asi new file mode 100644 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.
+ + 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/Amper= e/JadePkg/AcpiTables/PMU-S1.asi new file mode 100644 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.
+ + 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/J= adePkg/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.
+ + 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/Sil= icon/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.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include + +#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 =3D { + __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 remov= ing +// the data structure from the executable +// +VOID* CONST ReferenceAcpiTable =3D &Bert; diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Dbg2.aslc b/Sil= icon/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include +#include +#include +#include + +#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_NAMES= PACESTRING_FIELD_SIZE]; +} DBG2_DEBUG_DEVICE_INFORMATION; + +typedef struct { + EFI_ACPI_DEBUG_PORT_2_DESCRIPTION_TABLE Description; + DBG2_DEBUG_DEVICE_INFORMATION Dbg2DeviceInfo[DBG2_NUM_DE= BUG_PORTS]; +} DBG2_TABLE; + + +#define DBG2_DEBUG_PORT_DDI(NumReg, SubType, UartBase, UartAddrLen, UartNa= meStr) { \ + { = \ + EFI_ACPI_DBG2_DEBUG_DEVICE_INFORMATION_STRUCT_REVISION, /* U= INT8 Revision */ \ + sizeof (DBG2_DEBUG_DEVICE_INFORMATION), /* U= INT16 Length */ \ + NumReg, /* U= INT8 NumberofGenericAddressRegisters */ \ + DBG2_NAMESPACESTRING_FIELD_SIZE, /* U= INT16 NameSpaceStringLength */ \ + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, NameSpaceString), /* U= INT16 NameSpaceStringOffset */ \ + 0, /* U= INT16 OemDataLength */ \ + 0, /* U= INT16 OemDataOffset */ \ + EFI_ACPI_DBG2_PORT_TYPE_SERIAL, /* U= INT16 Port Type */ \ + SubType, /* U= INT16 Port Subtype */ \ + {EFI_ACPI_RESERVED_BYTE, EFI_ACPI_RESERVED_BYTE}, /* U= INT8 Reserved[2] */ \ + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, BaseAddressRegister), /* U= INT16 BaseAddressRegister Offset */ \ + OFFSET_OF (DBG2_DEBUG_DEVICE_INFORMATION, AddressSize) /* U= INT16 AddressSize Offset */ \ + }, = \ + ARM_GAS32 (UartBase), /* EFI_ACPI_6_3_GENER= IC_ADDRESS_STRUCTURE BaseAddressRegister */ \ + UartAddrLen, /* UINT32 AddressSiz= e */ \ + UartNameStr /* UINT8 NameSpaceS= tring[DBG2_NAMESPACESTRING_FIELD_SIZE] */ \ + } + + +STATIC DBG2_TABLE Dbg2 =3D { + { + __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 Number= DbgDeviceInfo */ + }, + { + // 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 remov= ing +// the data structure from the executable +// +VOID* CONST ReferenceAcpiTable =3D &Dbg2; diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl b/Sili= con/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl new file mode 100644 index 000000000000..bf2cca55e935 --- /dev/null +++ b/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Einj.asl @@ -0,0 +1,165 @@ +/** @file + + Copyright (c) 2020 - 2021, Ampere Computing LLC. All rights reserved. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ +[0004] Signature : "EINJ" [Error Injection tab= le] +[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 : 03 [Write 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 : 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 Addres= s] +[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 : B1700000 +[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/Sil= icon/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include + +// +// 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 =3D { + __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 remov= ing the +// data structure from the executable +// +VOID* CONST ReferenceAcpiTable =3D &Fadt; diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Gtdt.aslc b/Sil= icon/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include +#include + +#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_INT= ERRUPT_MODE +#define GTDT_TIMER_LEVEL_TRIGGERED 0 +#define GTDT_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_TIMER_FLAG_TIMER_INT= ERRUPT_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_A= CTIVE_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_F= LAG_TIMER_INTERRUPT_MODE +#define GTX_TIMER_LEVEL_TRIGGERED 0 +#define GTX_TIMER_ACTIVE_LOW EFI_ACPI_6_3_GTDT_GT_BLOCK_TIMER_F= LAG_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_TIME= R_SECURE) +#define GTX_COMMON_FLAGS_NS (GTX_TIMER_SAVE_CONTEXT | GTX_TIME= R_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_WATC= HDOG_FLAG_TIMER_INTERRUPT_MODE +#define SBSA_WATCHDOG_LEVEL_TRIGGERED 0 +#define SBSA_WATCHDOG_ACTIVE_LOW EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATC= HDOG_FLAG_TIMER_INTERRUPT_POLARITY +#define SBSA_WATCHDOG_ACTIVE_HIGH 0 +#define SBSA_WATCHDOG_SECURE EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATC= HDOG_FLAG_SECURE_TIMER +#define SBSA_WATCHDOG_NON_SECURE 0 + +#define SBSA_WATCHDOG_FLAGS (SBSA_WATCHDOG_NON_SECURE | SBSA_WA= TCHDOG_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_FRAME= S_COUNT]; +#if (WATCHDOG_COUNT !=3D 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 =3D { + { + __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 Cnt= ControlBasePhysicalAddress + EFI_ACPI_RESERVED_DWORD, // UINT32 Res= erved + SECURE_TIMER_EL1_GSIV, // UINT32 Sec= urePL1TimerGSIV + GTDT_GTIMER_FLAGS, // UINT32 Sec= urePL1TimerFlags + NON_SECURE_TIMER_EL1_GSIV, // UINT32 Non= SecurePL1TimerGSIV + GTDT_GTIMER_FLAGS, // UINT32 Non= SecurePL1TimerFlags + VIRTUAL_TIMER_GSIV, // UINT32 Vir= tualTimerGSIV + GTDT_GTIMER_FLAGS, // UINT32 Vir= tualTimerFlags + NON_SECURE_EL2_GSIV, // UINT32 Non= SecurePL2TimerGSIV + GTDT_GTIMER_FLAGS, // UINT32 Non= SecurePL2TimerFlags + CNT_READ_BASE_ADDRESS, // UINT64 Cnt= ReadBasePhysicalAddress + PLATFORM_TIMER_COUNT, // UINT32 Pla= tformTimerCount + sizeof (EFI_ACPI_6_3_GENERIC_TIMER_DESCRIPTION_TABLE), // UINT32 Pla= tformTimerOffset + }, + { + 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 Reserve= d + GT_BLOCK_CTL_BASE, // UINT64 CntCtl= Base + TIMER_FRAMES_COUNT, // UINT32 GTBloc= kTimerCount + sizeof(EFI_ACPI_6_3_GTDT_GT_BLOCK_STRUCTURE) // UINT32 GTBloc= kTimerOffset + }, + { + { + 0, // UINT8 GTFra= meNumber + {EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reser= ved[3] + GT_BLOCK_FRAME0_CTL_BASE, // UINT64 CntB= aseX + GT_BLOCK_FRAME0_CTL_EL0_BASE, // UINT64 CntE= L0BaseX + GT_BLOCK_FRAME0_GSIV, // UINT32 GTxP= hysicalTimerGSIV + GTX_TIMER_FLAGS, // UINT32 GTxP= hysicalTimerFlags + 0, // UINT32 GTxV= irtualTimerGSIV + 0, // UINT32 GTxV= irtualTimerFlags + GTX_COMMON_FLAGS_NS // UINT32 GTxC= ommonFlags + }, + { + 1, // UINT8 GTFra= meNumber + {EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reser= ved[3] + GT_BLOCK_FRAME1_CTL_BASE, // UINT64 CntB= aseX + GT_BLOCK_FRAME1_CTL_EL0_BASE, // UINT64 CntE= L0BaseX + GT_BLOCK_FRAME1_GSIV, // UINT32 GTxP= hysicalTimerGSIV + GTX_TIMER_FLAGS, // UINT32 GTxP= hysicalTimerFlags + 0, // UINT32 GTxV= irtualTimerGSIV + 0, // UINT32 GTxV= irtualTimerFlags + GTX_COMMON_FLAGS_NS // UINT32 GTxC= ommonFlags + }, + { + 2, // UINT8 GTFra= meNumber + {EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE, + EFI_ACPI_RESERVED_BYTE}, // UINT8 Reser= ved[3] + GT_BLOCK_FRAME2_CTL_BASE, // UINT64 CntB= aseX + GT_BLOCK_FRAME2_CTL_EL0_BASE, // UINT64 CntE= L0BaseX + GT_BLOCK_FRAME2_GSIV, // UINT32 GTxP= hysicalTimerGSIV + GTX_TIMER_FLAGS, // UINT32 GTxP= hysicalTimerFlags + 0, // UINT32 GTxV= irtualTimerGSIV + 0, // UINT32 GTxV= irtualTimerFlags + GTX_COMMON_FLAGS_NS // UINT32 GTxC= ommonFlags + }, + }, +#if (WATCHDOG_COUNT !=3D 0) + { + { + EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG, // UIN= T8 Type + sizeof(EFI_ACPI_6_3_GTDT_SBSA_GENERIC_WATCHDOG_STRUCTURE), // UIN= T16 Length + EFI_ACPI_RESERVED_BYTE, // UIN= T8 Reserved + SBSA_WATCHDOG_REFRESH_BASE, // UIN= T64 RefreshFramePhysicalAddress + SBSA_WATCHDOG_CONTROL_BASE, // UIN= T64 WatchdogControlFramePhysicalAddress + SBSA_WATCHDOG_GSIV, // UIN= T32 WatchdogTimerGSIV + SBSA_WATCHDOG_FLAGS // UIN= T32 WatchdogTimerFlags + } + } +#endif +}; + +// +// Reference the table being generated to prevent the optimizer from remov= ing the +// data structure from the executable +// +VOID* CONST ReferenceAcpiTable =3D &Gtdt; diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Hest.asl b/Sili= con/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ +[0004] Signature : "HEST" [Hardware Error Sour= ce 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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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 S= ource 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 S= tructure] +[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/Sili= con/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. + + 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/Sil= icon/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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include +#include +#include + +STATIC EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE Spcr =3D { + __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) =3D=3D 9600) + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_9600, +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) =3D=3D 19200) + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_19200, +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) =3D=3D 57600) + EFI_ACPI_SERIAL_PORT_CONSOLE_REDIRECTION_TABLE_BAUD_RATE_57600, +#elif (FixedPcdGet64 (PcdUartDefaultBaudRate) =3D=3D 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 remov= ing the +// data structure from the executable +// +VOID* CONST ReferenceAcpiTable =3D &Spcr; diff --git a/Silicon/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl b/Sili= con/Ampere/AmpereAltraPkg/AcpiCommonTables/Ssdt.asl new file mode 100644 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. + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +DefinitionBlock("Ssdt.aml", "SSDT", 2, "Ampere", "Altra ", 0x00000001) +{ + Method (MAIN, 0, NotSerialized) + { + Return (Zero) + } +} --=20 2.17.1