diff options
| author | raywu <raywu0301@gmail.com> | 2018-06-15 00:00:50 +0800 |
|---|---|---|
| committer | raywu <raywu0301@gmail.com> | 2018-06-15 00:00:50 +0800 |
| commit | b7c51c9cf4864df6aabb99a1ae843becd577237c (patch) | |
| tree | eebe9b0d0ca03062955223097e57da84dd618b9a /ReferenceCode/AcpiTables/Dptf | |
| download | zprj-master.tar.xz | |
Diffstat (limited to 'ReferenceCode/AcpiTables/Dptf')
68 files changed, 11961 insertions, 0 deletions
diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Art.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Art.asl new file mode 100644 index 0000000..03831ac --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Art.asl @@ -0,0 +1,91 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Art.asl + +Abstract: + + Intel ACPI Reference Code for Intel Dynamic Power Performance Management + +--*/ + + Scope(\_SB.IETM) + { + + Name(ART1, Package() // ART package when in Quiet Mode / Passive Cooling Mode + { + 0, // Revision + // Source Target Weight, AC0MaxLevel, AC1MaxLevel, AC21MaxLevel, AC31MaxLevel, AC41MaxLevel, AC51MaxLevel, AC61MaxLevel, AC71MaxLevel, AC81MaxLevel, AC91MaxLevel + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.TPCH, 100, 55, 45, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.TMEM, 100, 60, 50, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 60, 50, 40, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TAMB, 100, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.T_VR, 100, 70, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TEFN, 100, 40, 35, 30, 25, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.B0D4, 100, 70, 50, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.LPCB.H_EC.T_VR, 100, 65, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.B0D4, 100, 75, 20, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + }) + + Name(ART0, Package() // ART package when in Performance Mode / Active Cooling Mode + { + 0, // Revision + // Source Target Weight, AC0MaxLevel, AC1MaxLevel, AC21MaxLevel, AC31MaxLevel, AC41MaxLevel, AC51MaxLevel, AC61MaxLevel, AC71MaxLevel, AC81MaxLevel, AC91MaxLevel + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.TPCH, 100, 70, 50, 40, 30, 20, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.TMEM, 100, 80, 60, 50, 30, 10, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 90, 75, 50, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TAMB, 100, 75, 55, 35, 15, 5, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.T_VR, 100, 90, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TEFN, 100, 60, 50, 40, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.B0D4, 100, 100, 80, 65, 45, 25, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.LPCB.H_EC.T_VR, 100, 95, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.B0D4, 100, 100, 50, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + }) + + // _ART (Active Cooling Relationship Table) + // + // Arguments: + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Active Relationship Packages as described below: + // + // Return Value Information + // Package { + // Revision, // Integer - Current revision is: 0 + // ActiveRelationship[0] // Package + // ... + // ActiveRelationship[n] // Package + // } + // + Method(_ART,,,,PkgObj) + { // TODO: Add system-specific _ART code here + If(\ECON) + { + If(\_SB.PCI0.LPCB.H_EC.TSKN.CTYP) + { + Return(ART1) + } Else { + Return(ART0) + } + } + } // End _ART +} diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4CtdpPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4CtdpPolicy.asl new file mode 100644 index 0000000..553612f --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4CtdpPolicy.asl @@ -0,0 +1,376 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + B0d4CtdpPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Intel Configurable TDP + +--*/ + + +Scope(\_SB.IETM) +{ + Name (CTSP, Package () + { + // + // ConfigTDP Policy + // + ToUUID("E145970A-E4C1-4d73-900E-C9C5A69DD067") + }) +} + +Scope(\_SB.PCI0.B0D4) +{ + // TDPL (Thermal Design Power List) + // + // Returns the list of all supported Configurable TDP points available for the participant device. + // + // Arguments: (0) + // None + // Return Value: + // Package () // Zeroth TDP State + // { + // TDPPower, // DWordConst + // Frequency, // DWordConst + // TDPControl, // DWordConst + // FrequencyControl, // DWordConst + // Reserved1, // DWordConst + // }, + // . + // . + // . + // Package () // Last TDP State + // { + // TDPPower, // DWordConst + // Frequency, // DWordConst + // TDPControl, // DWordConst + // FrequencyControl, // DWordConst + // Reserved1, // DWordConst + // } + // + Method(TDPL,,,,PkgObj) + { + Name(AAAA,0) // PACKAGE_POWER_SKU + Name(BBBB,0) // CONFIG_TDP_LEVEL1 + Name(CCCC,0) // CONFIG_TDP_LEVEL2 + Name(PPUU,0) // PACKAGE_POWER_SKU_UNIT + + Store(CTNL, Local0) // CONFIG_TDP_NUM_LEVELS + If(LOr(LEqual(Local0,1),LEqual(Local0,2))){ // check for CTDP support + Store(\_PR.CLVL,Local0) // use PPM supplied value for CTDP level + } + Else{ + Return(Package (){0}) // no CTDP support + } + + If(LEqual(CLCK,1)){ // check the CONFIG_TDP_LOCK bit + Store(1,Local0) + } + + Store(CPNU(\_PR.PL10,1),AAAA) // convert Custom 0 Power Limit1 to milliwatts + Store(CPNU(\_PR.PL11,1),BBBB) // convert Custom 1 Power Limit1 to milliwatts + Store(CPNU(\_PR.PL12,1),CCCC) // convert Custom 2 Power Limit1 to milliwatts + + // + // Define a package of packages that contain 5 DWords. + // + Name (TMP1, Package (1){ + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000} + }) + Name (TMP2, Package (2){ + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000}, + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000} + }) + Name (TMP3, Package (3){ + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000}, + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000}, + Package (){0x80000000,0x80000000,0x80000000,0x80000000,0x80000000} + }) + + // + // if 3 TDP's, use PL0, PL1 and PL2 values + // + If(LEqual(Local0,3)){ + If (LGreater(AAAA,BBBB)){ + If (LGreater(AAAA,CCCC)){ + If (LGreater(BBBB,CCCC)){ + // abc + Store(0,Local3) + Store(0,LEV0) + Store(1,Local4) + Store(1,LEV1) + Store(2,Local5) + Store(2,LEV2) + }Else{ + // acb + Store(0,Local3) + Store(0,LEV0) + Store(1,Local5) + Store(2,LEV1) + Store(2,Local4) + Store(1,LEV2) + } + }Else{ + // cab + Store(0,Local5) + Store(2,LEV0) + Store(1,Local3) + Store(0,LEV1) + Store(2,Local4) + Store(1,LEV2) + } + }Else{ // b > a here + If(LGreater(BBBB,CCCC)){ + If(LGreater(AAAA,CCCC)){ + // bac + Store(0,Local4) + Store(1,LEV0) + Store(1,Local3) + Store(0,LEV1) + Store(2,Local5) + Store(2,LEV2) + }Else{ + // bca + Store(0,Local4) + Store(1,LEV0) + Store(1,Local5) + Store(2,LEV1) + Store(2,Local3) + Store(0,LEV2) + } + }Else{ + // cba + Store(0,Local5) + Store(2,LEV0) + Store(1,Local4) + Store(1,LEV1) + Store(2,Local3) + Store(0,LEV2) + } + } + + // copy for PL0 + Store(Add(\_PR.TAR0,1),Local1) + Multiply(Local1,100,Local2) + Store(AAAA,Index(DeRefOf(Index(TMP3, Local3)),0)) + Store(Local2,Index(DeRefOf(Index(TMP3, Local3)),1)) + Store(\_PR.CTC0,Index(DeRefOf(Index(TMP3, Local3)),2)) + Store(Local1,Index(DeRefOf(Index(TMP3, Local3)),3)) + Store(0,Index(DeRefOf(Index(TMP3, Local3)),4)) + + // copy for PL1 + Store(Add(\_PR.TAR1,1),Local1) + Multiply(Local1,100,Local2) + Store(BBBB,Index(DeRefOf(Index(TMP3, Local4)),0)) + Store(Local2,Index(DeRefOf(Index(TMP3, Local4)),1)) + Store(\_PR.CTC1,Index(DeRefOf(Index(TMP3, Local4)),2)) + Store(Local1,Index(DeRefOf(Index(TMP3, Local4)),3)) + Store(0,Index(DeRefOf(Index(TMP3, Local4)),4)) + + // copy for PL2 + Store(Add(\_PR.TAR2,1),Local1) + Multiply(Local1,100,Local2) + Store(CCCC,Index(DeRefOf(Index(TMP3, Local5)),0)) + Store(Local2,Index(DeRefOf(Index(TMP3, Local5)),1)) + Store(\_PR.CTC2,Index(DeRefOf(Index(TMP3, Local5)),2)) + Store(Local1,Index(DeRefOf(Index(TMP3, Local5)),3)) + Store(0,Index(DeRefOf(Index(TMP3, Local5)),4)) + + Return(TMP3) + } + + // + // if 2 TDP's, use PL0 and PL1 values + // + If(LEqual(Local0,2)){ + If(LGreater(AAAA,BBBB)){ + Store(0,Local3) // store PL0 in Zeroth package + Store(1,Local4) // store PL1 in next package + Store(0,LEV0) + Store(1,LEV1) + Store(0,LEV2) // level 2 is not used so put 0 for safety + }Else{ + Store(0,Local4) // store PL1 in Zeroth package + Store(1,Local3) // store PL0 in next package + Store(1,LEV0) + Store(0,LEV1) + Store(0,LEV2) // level 2 is not used so put 0 for safety + } + + // copy for PL0 + Store(Add(\_PR.TAR0,1),Local1) + Multiply(Local1,100,Local2) + Store(AAAA,Index(DeRefOf(Index(TMP2, Local3)),0)) + Store(Local2,Index(DeRefOf(Index(TMP2, Local3)),1)) + Store(\_PR.CTC0,Index(DeRefOf(Index(TMP2, Local3)),2)) + Store(Local1,Index(DeRefOf(Index(TMP2, Local3)),3)) + Store(0,Index(DeRefOf(Index(TMP2, Local3)),4)) + + // copy for PL1 + Store(Add(\_PR.TAR1,1),Local1) + Multiply(Local1,100,Local2) + Store(BBBB,Index(DeRefOf(Index(TMP2, Local4)),0)) + Store(Local2,Index(DeRefOf(Index(TMP2, Local4)),1)) + Store(\_PR.CTC1,Index(DeRefOf(Index(TMP2, Local4)),2)) + Store(Local1,Index(DeRefOf(Index(TMP2, Local4)),3)) + Store(0,Index(DeRefOf(Index(TMP2, Local4)),4)) + + Return(TMP2) + } + + // + // if 1 TDP, return one PL based on boot index + // + If(LEqual(Local0,1)){ + Switch(ToInteger(\_PR.CBMI)){ + case(0){ + // copy for PL0 + Store(Add(\_PR.TAR0,1),Local1) + Multiply(Local1,100,Local2) + Store(AAAA,Index(DeRefOf(Index(TMP1, 0)),0)) + Store(Local2,Index(DeRefOf(Index(TMP1, 0)),1)) + Store(\_PR.CTC0,Index(DeRefOf(Index(TMP1, 0)),2)) + Store(Local1,Index(DeRefOf(Index(TMP1, 0)),3)) + Store(0,Index(DeRefOf(Index(TMP1, 0)),4)) + Store(0,LEV0) + Store(0,LEV1) + Store(0,LEV2) + } + + case(1){ + // copy for PL1 + Store(Add(\_PR.TAR1,1),Local1) + Multiply(Local1,100,Local2) + Store(BBBB,Index(DeRefOf(Index(TMP1, 0)),0)) + Store(Local2,Index(DeRefOf(Index(TMP1, 0)),1)) + Store(\_PR.CTC1,Index(DeRefOf(Index(TMP1, 0)),2)) + Store(Local1,Index(DeRefOf(Index(TMP1, 0)),3)) + Store(0,Index(DeRefOf(Index(TMP1, 0)),4)) + Store(1,LEV0) + Store(1,LEV1) + Store(1,LEV2) + } + + case(2){ + // copy for PL2 + Store(Add(\_PR.TAR2,1),Local1) + Multiply(Local1,100,Local2) + Store(CCCC,Index(DeRefOf(Index(TMP1, 0)),0)) + Store(Local2,Index(DeRefOf(Index(TMP1, 0)),1)) + Store(\_PR.CTC2,Index(DeRefOf(Index(TMP1, 0)),2)) + Store(Local1,Index(DeRefOf(Index(TMP1, 0)),3)) + Store(0,Index(DeRefOf(Index(TMP1, 0)),4)) + Store(2,LEV0) + Store(2,LEV1) + Store(2,LEV2) + } + } + + Return(TMP1) + } + + Return(0) // we should never get here, this eliminates a compiler warning + } // End of TDPL object + + // + // Returns the max TDP configurable for the platform. + // + Name(MAXT,0) + + // TDPC (Thermal Design Power Capabilities) + // + // The TDPC object evaluates to an integer that identifies the maximum usable TDP point + // from the table returned by the TDPL object at any given time. + // + // Arguments: (0) + // None + // Return Value: + // This value is the zero based index into the TDPL object's entries. + // + Method(TDPC) // For CRB, please return 0. + { + Return(MAXT) // Return valid TDP point. + }//end Method(TDPC) + + Name(LEV0,0) + Name(LEV1,0) + Name(LEV2,0) + + // STDP (Set current operating TDP Point) + // + // The STDP object communicates to the platform BIOS the current operating TDP point whenever it is changed due to any reason. + // In response to this object evaluation, the platform BIOS modifies the packages returned in PPCC object and notifies the driver of + // a change in power limit capabilities as appropriate. + // + // Arguments: (1) + // Arg0 = Config TDP level selected + // 0 = Highest Level values from MSR + // 1 = Middle Level values from MSR + // 2 = Lowest Level values from MSR + // 3 = reserved + // Return Value: + // None + // + // Currently we are using hard coded values for the PPCC values. + // A future reference code release will use PPCC values from the PPM reference code. + // This will allow PPCC values to be selected from SETUP options. + // + Method(STDP,1,Serialized) + { + If (LGreaterEqual(Arg0,\_PR.CLVL)){ // bounds check the input + Return() // invalid input + } + + // + // translate requested index value to the correct PL using the sorted TDPL value. + // + Switch (ToInteger(Arg0)){ + Case (0) { + Store(LEV0,Local0) + } + Case (1) { + Store(LEV1,Local0) + } + Case (2) { + Store(LEV2,Local0) + } + } + + Switch (ToInteger(Local0)){ + Case (0) { + CPL0() // copy PL0 values to PPCC + } + Case (1) { + CPL1() // copy PL1 values to PPCC + } + Case (2) { + CPL2() // copy PL2 values to PPCC + } + } + + Notify (\_SB.PCI0.B0D4, 0x83) // Send a Power Capabilities Changed notification to self + }//end Method(STDP) + +}//end Scope(\_SB.PCI0.B0D4) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4DppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4DppmPolicy.asl new file mode 100644 index 0000000..1967ea4 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4DppmPolicy.asl @@ -0,0 +1,177 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + B0d4DppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + + +Scope(\_SB.PCI0.B0D4) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTMC),Local1) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATMC),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTMC),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATMC),Local0) // Active Cooling Policy + } + Subtract(Local0, 50, Local0) + + If(LGreaterEqual(LSTM,Local0)) + { + Return(Subtract(Local0,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local0) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SACR)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SAHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV,0,Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(ATMC)) // Passive Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(PTMC)) // Active Cooling Policy + } + } + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP,3,Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(B0D4, 0x91) + } + } + +} // End Scope(\_SB.PCI0.B0D4) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4LpmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4LpmPolicy.asl new file mode 100644 index 0000000..331b322 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4LpmPolicy.asl @@ -0,0 +1,64 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + B0d4LpmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Intel Low Power Mode + +--*/ + + +Scope(\_SB.IETM) +{ + Name (LPSP, Package () + { + // + // LPM Policy + // + ToUUID("B9455B06-7949-40c6-ABF2-363A70C8706C") + }) + + // CLPM (Current Low Power Mode Setting) + // + // This object evaluates to an integer that indicates the current platform desired LPM mode setting. + // + // Arguments: (0) + // None + // Return Value: + // 0 - Disable LPM + // 1 - Enable LPM + // 2 - Application Specific LPM + // 3 - Use the LPM setting as requested by the OS level interfaces either through the OS Power Plan settings or + // through the LPM API exposed to OS software. + // + Method (CLPM) + { + If(LEqual(\_SB.PCI0.B0D4.LPMS,0)){ // check LPM support in CPU + Return (0) + } + Return (LPMV) // Update LPMV based on current platform desire. + } // End of CLPM object + +}//end Scope(\_SB.IETM) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4Participant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4Participant.asl new file mode 100644 index 0000000..69d69d6 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/B0d4Participant.asl @@ -0,0 +1,931 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + B0d4Participant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +//AMI override for fix BSOD issue +Scope(\_SB.PCI0.B0D4) +{ +/* +Scope(\_SB.PCI0) +{ + Device(B0D4) // SA Thermal Device + { + Name(_ADR, 0x00040000) +*/ +//AMI override for fix BSOD issue + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(SADE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // + // Define an OpRegion for the DPTF MSR's accessed via MCHBAR+0x5000 + // + OperationRegion (MBAR, SystemMemory, Add(ShiftLeft(MHBR,15),0x5000), 0x1000) + Field (MBAR, ByteAcc, NoLock, Preserve) + { + Offset (0x930), // PACKAGE_POWER_SKU (MCHBAR+0x5930) + PTDP, 15, // TDP Package Power [14:0] + , 1, // reserved [15] + PMIN, 15, // Minimal Package Power [30:16] + , 1, // Reserved [31] + PMAX, 15, // Maximal Package Power [46:32] + , 1, // Reserved [47] + TMAX, 7, // Maximal Time Window [54:48] + Offset (0x938), // PACKAGE_POWER_SKU_UNIT (MCHBAR+0x5938) + PWRU, 4, // Power Units [3:0] + , 4, // Reserved [7:4] + EGYU, 5, // Energy Units [12:8] + , 3, // Reserved [15:13] + TIMU, 4, // Time Units [19:16] + Offset (0x958), // PLATFORM_INFO (MCHBAR+0x5958) + , 32, // [31:0] + LPMS, 1, // LPM Support [32] + CTNL, 2, // CONFIG_TDP_NUM_LEVELS [34:33] + Offset (0x998), // RP_STATE_CAP_0_0_0_MCHBAR_PCU (MCHBAR+0x5998) + RP0C, 8, // [7:0] RP0_CAP, These fields indicate the maximum RPx base frequency capability for the Integrated GFX Engine (GT). + RP1C, 8, // [15:8] RP1_CAP, Values are in units of 100 MHz. + RPNC, 8, // [23:16] RPN_CAP + Offset (0xF3C), // CONFIG_TDP_NOMINAL (MCHBAR+0x5F3C) + TRAT, 8, // TDP Ratio [7:0] + Offset (0xF40), // CONFIG_TDP_LEVEL1 (MCHBAR+0x5F40) + PTD1, 15, // Package TDP [14:0] + , 1, // reserved [15] + TRA1, 8, // TDP Ratio [23:16] + , 8, // reserved [31:24] + PMX1, 15, // Package MAX Power [46:32] + , 1, // reserved [47] + PMN1, 15, // Package MIN Power [62:48] + Offset (0xF48), // CONFIG_TDP_LEVEL2 (MCHBAR+0x5F48) + PTD2, 15, // Package TDP [14:0] + , 1, // reserved [15] + TRA2, 8, // TDP Ratio [23:16] + , 8, // reserved [31:24] + PMX2, 15, // Package MAX Power [46:32] + , 1, // reserved [47] + PMN2, 15, // Package MIN Power [62:48] + Offset (0xF50), // CONFIG_TDP_CONTROL (MCHBAR+0x5F50) + CTCL, 2, // TDP Level [1:0] + , 29, // reserved [30:2] + CLCK, 1, // Config TDP Lock [31] + Offset (0xF54), // TURBO_ACTIVATION_RATIO (MCHBAR+0x5F54) + MNTR, 8, // Max Non Turbo Ratio [7:0] + } + + Name(XPCC,0) // semaphore to record when PPCC gets called for the first time + + // PPCC (Participant Power Control Capabilities) + // + // The PPCC object evaluates to a package of packages that indicates to DPTF processor + // participant the power control capabilities. + // + // Arguments: (0) + // None + // Return Value: + // PPCC package of packages + // + Method(PPCC,0,Serialized,,PkgObj) + { + If(LAnd(LEqual(XPCC,0),CondRefOf(\_PR.CBMI))){ + Switch(ToInteger(\_PR.CBMI)){ // use the boot index from PPM to choose the PL for PPCC + case(0){ + If(LAnd(LGreaterEqual(\_PR.CLVL,1),LLessEqual(\_PR.CLVL,3))){ + CPL0() // copy PL0 values to PPCC + Store(1,XPCC) + } + } + case(1){ + If(LOr(LEqual(\_PR.CLVL,2),LEqual(\_PR.CLVL,3))){ + CPL1() // copy PL1 values to PPCC + Store(1,XPCC) + } + } + case(2){ + If(LEqual(\_PR.CLVL,3)){ + CPL2() // copy PL2 values to PPCC + Store(1,XPCC) + } + } + } + } + Return(NPCC) + } + + // PPCC (Participant Power Control Capabilities) + // + // The PPCC object evaluates to a package of packages that indicates to DPTF processor + // participant the power control capabilities. + // + // Arguments: (0) + // None + // Return Value: + // PPCC package of packages + // + // PPCC will be initialized by the _INI method with power on default values from the PPM code. + // + Name (NPCC, Package() + { // Field Name : Field Type + 2, // Revision : DWordConst + + Package () // Power Limit 1 + { + 0, // PowerLimitIndex : DWordConst = 0 + 35000, // PowerLimitMinimum : DWordConst + 45000, // PowerLimitMaximum : DWordConst + 28, // TimeWindowMinimum : DWordConst + 32, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + }, + Package () // Power Limit 2 + { + 1, // PowerLimitIndex : DWordConst = 1 + 56250, // PowerLimitMinimum : DWordConst + 56250, // PowerLimitMaximum : DWordConst + 0, // TimeWindowMinimum : DWordConst + 0, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + } + }) // End of PPCC object + + + // CPNU (Convert Power Number from MMIO register to correct Units) + // + // Arguments: (1) + // Arg0 = Number to be converted + // Arg1 = Units desired + // 0 = Watts + // 1 = MilliWatts + // Return Value: + // Converted integer + // + Method(CPNU,2,Serialized,,IntObj) + { + Name(CNVT,0) // converted number + Name(PPUU,0) // units + Name(RMDR,0) // remainder + + if (LEqual(PWRU,0)) { // use PACKAGE_POWER_SKU_UNIT - Power Units[3:0] + Store(1,PPUU) + } else { + ShiftLeft(Decrement(PWRU),2,PPUU) // get units + } + Divide(Arg0,PPUU,RMDR,CNVT) // convert Arg0 to Watts + + if(LEqual(Arg1,0)){ + Return(CNVT) // return in watts + } else { + Multiply(CNVT,1000,CNVT) // convert to milliwatts + Multiply(RMDR,1000,RMDR) // convert remainder to a useful integer + Divide(RMDR,PPUU,Local0,RMDR) // convert remainder to watts + Add(CNVT,RMDR,CNVT) // add the integer part and the fraction part together + Return(CNVT) // return in milliwatts + } + } + + // MIN4 (find next lower rounded multiple of 4) + // + // Arguments: (1) + // Number to be converted + // Return Value: + // Converted integer + // + Method(MIN4,1,Serialized,,IntObj) + { + Name(RMDR,0) // remainder + Name(DIVD,0) // dividend + + Store(CPNU(Arg0,0),DIVD) // to convert Arg0 to Watts + + Subtract(DIVD,1,DIVD) + If(LOr(LLess(DIVD,4),LEqual(DIVD,0))){ + Return(1) + } Else{ + Divide(DIVD,4,RMDR) + } + + While(LNotEqual(RMDR,0)){ + Subtract(DIVD,1,DIVD) + If(LNotEqual(DIVD,0)){ + Divide(DIVD,4,RMDR) + } + } + + Return(Multiply(DIVD,1000)) // return in milliwatts + } + + // MAX4 (find next higher rounded multiple of 4) + // + // Arguments: (1) + // Number to be converted + // Return Value: + // Converted integer + // + Method(MAX4,1,Serialized,,IntObj) + { + Name(RMDR,0) // remainder + Name(DIVD,0) // dividend + + Store(CPNU(Arg0,0),DIVD) // to convert Arg0 to Watts + + Add(DIVD,1,DIVD) + Divide(DIVD,4,RMDR) + + While(LNotEqual(RMDR,0)){ + Add(DIVD,1,DIVD) + Divide(DIVD,4,RMDR) + } + + Return(Multiply(DIVD,1000)) // return in milliwatts + } + + // CPL0 (Copy PL0 power limits to PPCC) + // + // Arguments: + // None + // Return Value: + // None + // + Method(CPL0,0) + { + Store (2,Index(\_SB.PCI0.B0D4.NPCC,0)) // Revision + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),0)) // PowerLimitIndex + If (LEqual(\MPLT, 0)){ + Store (MIN4(\_PR.PL10),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } Else { + Store (\MPLT,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } + Store (CPNU(\_PR.PL10,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),2)) // PowerLimitMaximum + Store (\_PR.PLW0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),3)) // TimeWindowMinimum + Add (\_PR.PLW0,4,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),5)) // StepSize + Store (1,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),0)) // PowerLimitIndex + Store (CPNU(\_PR.PL20,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),1)) // PowerLimitMinimum + Store (CPNU(\_PR.PL20,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),2)) // PowerLimitMaximum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),3)) // TimeWindowMinimum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),5)) // StepSize + } + + // CPL1 (Copy PL1 power limits to PPCC) + // + // Arguments: + // None + // Return Value: + // None + // + Method(CPL1,0) + { + Store (2,Index(\_SB.PCI0.B0D4.NPCC,0)) // Revision + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),0)) // PowerLimitIndex + If (LEqual(\MPLT, 0)){ + Store (MIN4(\_PR.PL11),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } Else { + Store (\MPLT,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } + Store (CPNU(\_PR.PL11,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),2)) // PowerLimitMaximum + Store (\_PR.PLW1,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),3)) // TimeWindowMinimum + Add (\_PR.PLW1,4,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),5)) // StepSize + Store (1,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),0)) // PowerLimitIndex + Store (CPNU(\_PR.PL21,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),1)) // PowerLimitMinimum + Store (CPNU(\_PR.PL21,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),2)) // PowerLimitMaximum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),3)) // TimeWindowMinimum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),5)) // StepSize + } + + // CPL2 (Copy PL2 power limits to PPCC) + // + // Arguments: + // None + // Return Value: + // None + // + Method(CPL2,0) + { + Store (2,Index(\_SB.PCI0.B0D4.NPCC,0)) // Revision + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),0)) // PowerLimitIndex + If (LEqual(\MPLT, 0)){ + Store (MIN4(\_PR.PL12),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } Else { + Store (\MPLT,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),1)) // PowerLimitMinimum + } + Store (CPNU(\_PR.PL12,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),2)) // PowerLimitMaximum + Store (\_PR.PLW2,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),3)) // TimeWindowMinimum + Add (\_PR.PLW2,4,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,1)),5)) // StepSize + Store (1,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),0)) // PowerLimitIndex + Store (CPNU(\_PR.PL22,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),1)) // PowerLimitMinimum + Store (CPNU(\_PR.PL22,1),Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),2)) // PowerLimitMaximum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),3)) // TimeWindowMinimum + Store (0,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),4)) // TimeWindowMaximum + Store (PPSZ,Index(DerefOf(Index(\_SB.PCI0.B0D4.NPCC,2)),5)) // StepSize + } + + Name (LSTM,0) // Last temperature reported + + // _PPC (Performance Present Capabilities) + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the range of states supported + // 0 - States 0 through nth state are available (all states available) + // 1 - States 1 through nth state are available + // 2 - States 2 through nth state are available + // ... + // n - State n is available only + // + Name(_PPC,0) + + // SPPC (Set Participant Performance Capability) + // + // SPPC is a control method object that takes one integer parameter that will indicate the maximum allowable + // P-State for OSPM to use at any given time. + // + // Arguments: (1) + // Arg0 - integer + // Return Value: + // None + // + Method(SPPC,1,Serialized) + { + Store(Arg0, \_PR.CPU0._PPC) // Note: CPU0._PPC is an Integer not a Method + + If(CondRefOf(\_SB.PCCD.PENB)) { // is CPPC enabled in SETUP? + Notify(\_SB.PCCD,0x82) // CPPC notify + } Else { + Switch(ToInteger(TCNT)){ + Case(8){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + Notify(\_PR.CPU2, 0x80) // Tell CPU2 driver to re-eval _PPC + Notify(\_PR.CPU3, 0x80) // Tell CPU3 driver to re-eval _PPC + Notify(\_PR.CPU4, 0x80) // Tell CPU4 driver to re-eval _PPC + Notify(\_PR.CPU5, 0x80) // Tell CPU5 driver to re-eval _PPC + Notify(\_PR.CPU6, 0x80) // Tell CPU6 driver to re-eval _PPC + Notify(\_PR.CPU7, 0x80) // Tell CPU7 driver to re-eval _PPC + } + Case(4){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + Notify(\_PR.CPU2, 0x80) // Tell CPU2 driver to re-eval _PPC + Notify(\_PR.CPU3, 0x80) // Tell CPU3 driver to re-eval _PPC + } + Case(2){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + } + Default{ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + } + } + } + } + + Name (TLPO, Package() + { + 1, // Revision, DwordConst + 1, // LPOEnable, DwordConst + 0, // LPOStartPState, DwordConst + 1, // LPOStepSize, DwordConst + 1, // LPOPowerControlSetting, DwordConst + 2 // LPOPerformanceControlSetting, DwordConst + }) + + // CLPO (Current Logical Processor Off lining Setting) + // + // This object is utilized only by DPPM Passive policy. It is not required to implement this object for LPM. + // + // Arguments: (0) + // None + // Return Value: + // This object evaluates to a package that indicates the LPO Control preferences. + // + Method(CLPO,,,,PkgObj) + { + Store (LPOE,Index(TLPO,1)) // LPOEnable + + If(CondRefOf(\_PR.CPU0._PSS)){ // LPOStartPState + Store(SizeOf(\_PR.CPU0._PSS()),Local1) // bounds check with _PSS + } // + Else // + { // + Store (0,Local1) // + } // + If(LLess(LPOP,Local1)){ // + Store (LPOP,Index(TLPO,2)) // + } // + Else // + { // + Decrement(Local1) // Index of LFM entry in _PSS + Store (Local1,Index(TLPO,2)) // + } // + + Store (LPOS,Index(TLPO,3)) // LPOStepSize + Store (LPOW,Index(TLPO,4)) // LPOPowerControlSetting + Store (LPER,Index(TLPO,5)) // LPOPerformanceControlSetting + + Return(TLPO) + } + + // AEXL (Application Exclusion List) + // + // There is a limit of 256 strings for this package. If the list is a bigger number than the limit, it is not effective to use LPO. + // + // Arguments: (0) + // None + // Return Value: + // This object evaluates to a package of strings representing the application names that the DPTF processor participant + // will exclude from core off lining when LPO is triggered. + // + Name (AEXL, Package() + { + "svchost.exe", "dllhost.exe", "smss.exe", "WinSAT.exe" + }) + + // PCCC (Participant Current Control Capabilities) + // + // The PCCC object evaluates to a package of packages that indicates to DPTF processor participant the Icc control capabilities. + // + // Arguments: (0) + // None + // + // Return Value: + // A package of packages as described below: + // + // Package() + // { + // 0x80000000, // DWordConst, Revision + // Package () + // { + // 0x80000000, // DWordConst, CurrentLimitMinimum in milli Amps + // 0x80000000, // DWordConst, CurrentLimitMaximum in milli Amps + // } + // } + Method(PCCC,0,Serialized,,PkgObj) + { + Store (1,Index(PCCX,0)) // Revision + Switch(ToInteger(CPNU(PTDP,0))){ // SKU check + case(57){ + Store (43000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (95000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + case(47){ + Store (39000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (85000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + case(37){ + Store (29000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (55000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + case(25){ + Store (16000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (32000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + case(15){ + Store (14000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (32000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + case(11){ + Store (14000,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (25000,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + Default{ // UNKNOWN SKU + Store (0xFF,Index(DerefOf(Index(PCCX,1)),0)) // CurrentLimitMinimum + Store (0xFF,Index(DerefOf(Index(PCCX,1)),1)) // CurrentLimitMaximum + } + } // End of Switch(PTDP) + + Return(PCCX) + } // End of PCCC object + + // PCCX (Participant Current Control Capabilities temp structure) + // + // This is used to pass data from the PCCC object to the PDRT object. + // + Name (PCCX, Package() + { + 0x80000000, // DWordConst, Revision + + Package () + { + 0x80000000, // DWordConst, CurrentLimitMinimum + 0x80000000, // DWordConst, CurrentLimitMaximum + } + }) // End of PCCC object + + // KEFF (VR efficiency Table) + // + // This object evaluates to a package of packages that indicates the VR efficiency factor for various processor power. + // + // Arguments: (0) + // None + // + // Return Value: + // A package of packages. + // + Name(KEFF, Package() + { + // Processor PMAX, Efficiency + Package () {444, 0}, + Package () {463, 39}, + Package () {481, 75}, + Package () {499, 108}, + Package () {518, 139}, + Package () {536, 168}, + Package () {554, 195}, + Package () {573, 221}, + Package () {591, 244}, + Package () {609, 267}, + Package () {628, 287}, + Package () {812, 445}, + Package () {983, 551}, + Package () {1163, 621}, + Package () {1342, 673}, + Package () {1527, 710}, + Package () {1704, 742}, + Package () {1885, 767}, + Package () {2072, 785}, + Package () {2255, 802}, + Package () {6044, 897}, + Package () {11740, 924}, + Package () {17576, 926}, + Package () {23605, 919}, + Package () {29821, 909}, + Package () {36223, 898}, + Package () {42856, 886}, + Package () {49723, 873}, + Package () {56870, 858}, + Package () {64380, 842} + }) + + Name (CEUP, Package() + { + 0x80000000, + 0x80000000, + 0x80000000, + 0x80000000, + 0x80000000, + 0x80000000 + }) + + // CEUC (Current Execution Unit Configuration) + // + // This object evaluates to a package that indicates the Execution Unit Control preferences. + // + // Arguments: (0) + // None + // Return Value: + // Package { + // Revision // DWordConst - 0x1 for Sharkbay and Clovertrail platform. + // EUEnable // DwordConst - If this option is 0 then policy does not use any active core controls for graphics. + // TargetGfxFreq // DwordConst - Returns graphics frequency in MHz. + // MaxActiveEUs // DwordConst - Provides the max limit for the number of EUs that driver can request while in passive control. + // MinActiveEUs // DwordConst - Provides the min limit for the number of EUs that driver can request while in passive control. + // StepSize // DwordConst - Instructs the policy to take away EU in the specified percentage steps. E.g. if StepSize is 50% then policy would take away 1/2 of EUs at a time. + // } + // + Method(CEUC,,,,PkgObj) + { + Store(0x1, Index(CEUP,0)) // Revision + Store(ECEU, Index(CEUP,1)) // Enable/disable + Store(TGFG, Index(CEUP,2)) // Gfx frequency + Store(40, Index(CEUP,3)) // Max + Store(20, Index(CEUP,4)) // Min + Store(20, Index(CEUP,5)) // step size + + Return(CEUP) + } // end of CEUC object + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + //AMI override begin + //Method(_TMP) + Method(TMPX) + //AMI override end + { + // Return the temperature to the OS if EC access is enabled. + If(\ECON) + { + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PMAX)))) + } + Else + { + // Return a static value if EC access is disabled. + Return(3000) + } + } + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(B0D4, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + // _PSS (Performance Supported States) + // + // This optional object indicates to OSPM the number of supported processor performance states that any given system can support. + // + // Arguments: (1) + // None + // Return Value: + // A variable-length Package containing a list of Pstate sub-packages as described below + // + // Return Value Information + // Package { + // PState [0] // Package - Performance state 0 + // .... + // PState [n] // Package - Performance state n + // } + // + // Each Pstate sub-Package contains the elements described below: + // Package { + // CoreFrequency // Integer (DWORD) + // Power // Integer (DWORD) + // Latency // Integer (DWORD) + // BusMasterLatency // Integer (DWORD) + // Control // Integer (DWORD) + // Status // Integer (DWORD) + // } + // + // Stub for the Actual CPU _PSS method. + // + Method(_PSS,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._PSS)) + { // Ensure _PSS is present + Return(\_PR.CPU0._PSS()) + } Else { + Return(Package(){ + Package(){0,0,0,0,0,0}, + Package(){0,0,0,0,0,0}}) + } + } + + // _TSS (Throttling Supported States) + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of Tstate sub-packages as described below + // + // Return Value Information + // Package { + // TState [0] // Package - Throttling state 0 + // .... + // TState [n] // Package - Throttling state n + // } + // + // Each Tstate sub-Package contains the elements described below: + // Package { + // Percent // Integer (DWORD) + // Power // Integer (DWORD) + // Latency // Integer (DWORD) + // Control // Integer (DWORD) + // Status // Integer (DWORD) + // } + // + // Stub for the Actual CPU _TSS method. + // + Method(_TSS,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._TSS)) + { // Ensure _TSS is present + Return(\_PR.CPU0._TSS()) + } Else { + Return(Package(){ + Package(){0,0,0,0,0}, + Package(){0,0,0,0,0}}) + } + } + + // _TPC (Throttling Present Capabilities) + // + // This optional object is a method that dynamically indicates to OSPM the number of throttling states currently supported by the platform. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the number of states supported: + // 0 - states 0 .. nth state available (all states available) + // 1 - state 1 .. nth state available + // 2 - state 2 .. nth state available + // ... + // n - state n available only + // + Method(_TPC) + { + If(CondRefOf(\_PR.CPU0._TPC)) + { // Ensure _TPC is present + Return(\_PR.CPU0._TPC) + } Else { + Return(0) + } + } + + // _PTC (Processor Throttling Control) + // + // _PTC is an optional object that defines a processor throttling control interface alternative to the I/O address spaced-based P_BLK throttling control register (P_CNT) + // + // PDC0[2] = ACPI object indicating if OSPM is capable of direct access to On Demand throttling MSR + // + // Arguments: (0) + // None + // Return Value: + // A Package as described below + // + // Return Value Information + // Package { + // ControlRegister // Buffer (Resource Descriptor) + // StatusRegister // Buffer (Resource Descriptor) + // } + // + Method(_PTC,,,,PkgObj) + { + If(LAnd(CondRefOf(\PDC0),LNotEqual(\PDC0,0x80000000))) // is object present and initialized? + { + If(And(\PDC0, 0x0004)) { // does OS support MSR interface? + Return(Package() { + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)}, + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)} }) // if OS supports MSR interface + } Else { + Return(Package() { + ResourceTemplate(){Register(SystemIO, 5, 0, PCH_ACPI_PBLK)}, + ResourceTemplate(){Register(SystemIO, 5, 0, PCH_ACPI_PBLK)} }) // if OS support IO based interface + } + } Else { + Return(Package() { + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)}, + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)} }) // if object is not present or not initialized then return MSR interface + } + } + + // _TSD (T-State Dependency) + // + // This optional object provides T-state control cross logical processor dependency information to OSPM. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of T-state dependency Packages as described below. + // + // Return Value Information + // Package { + // NumEntries // Integer + // Revision // Integer (BYTE) + // Domain // Integer (DWORD) + // CoordType // Integer (DWORD) + // NumProcessors // Integer (DWORD) + // } + // + Method(_TSD,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._TSD)) + { // Ensure _TSD is present + Return(\_PR.CPU0._TSD()) + } Else { + Return(Package(){ + Package(){5,0,0,0,0}, + Package(){5,0,0,0,0}}) + } + } + + // _TDL (T-state Depth Limit) + // + // This optional object evaluates to the _TSS entry number of the lowest power throttling state that OSPM may use. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the Throttling Depth Limit _TSS entry number: + // 0 - throttling disabled. + // 1 - state 1 is the lowest power T-state available. + // 2 - state 2 is the lowest power T-state available. + // ... + // n - state n is the lowest power T-state available. + // + Method(_TDL) + { + If(LAnd(CondRefOf(\_PR.CPU0._TSS),CondRefOf(\_PR.CFGD))) + { // Ensure _TSS is present + If(And(\_PR.CFGD, PPM_TSTATE_FINE_GRAINED)) + { + Return(Subtract(SizeOf(\_PR.CPU0.TSMF),1)) + } Else { + Return(Subtract(SizeOf(\_PR.CPU0.TSMC),1)) + } + } Else { + Return(0) + } + } + + // _PDL (P-state Depth Limit) + // + // This optional object evaluates to the _PSS entry number of the lowest performance P-state that OSPM may use when performing passive thermal control. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the P-state Depth Limit _PSS entry number: + // Integer containing the P-state Depth Limit _PSS entry number: + // 0 - P0 is the only P-state available for OSPM use + // 1 - state 1 is the lowest power P-state available + // 2 - state 2 is the lowest power P-state available + // ... + // n - state n is the lowest power P-state available + // + Method(_PDL) + { + If(CondRefOf(\_PR.CPU0._PSS)) + { // Ensure _PSS is present + Return(Subtract(SizeOf(\_PR.CPU0._PSS),1)) + } Else { + Return(0) + } + } +//AMI override for BSOD issue +} // End Scope(\_SB.PCI0.B0D4) +/* + }// End Device(B0D4) +} // End Scope(\_SB.PCI0) +*/ +//AMI override for BSOD issue
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/DplyParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DplyParticipant.asl new file mode 100644 index 0000000..d27182c --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DplyParticipant.asl @@ -0,0 +1,176 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + DplyParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ +Scope(\_SB.PCI0) +{ + + Device(DPLY) // Display participant + { + Name(_HID, EISAID("INT3406")) + Name(_UID, 0) + + Name(BDLI, 32) // Brightness depth limit index corresponding to 30% + Name(BDHI, 82) // Brightness peformance/power ceiling limit index corresponding to 80% + + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(DISE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // DDDL ( Dptf Display Depth Limit) + // + // The DDDL object indicates dynamically a lower limit on the brightness control levels currently supported by the platform + // for the participant. Value returned indicates a Power/Percentage value that is in the _BCL brightness list. + // + // Arguments: (0) + // None + // Return Value: + // Index in Brightness level list + // + Method(DDDL, 0) + { + Return(BDLI) + } + + // DDPC ( Dptf Display Power/performance Control) + // + // The DDPC object indicates dynamically a higher limit (ceiling) on the brightness control levels currently supported by + // the platform for the participant. + // + // Arguments: (0) + // None + // Return Value: + // Index in Brightness level list + // + Method(DDPC, 0) + { + Return(BDHI) + } + + // _BCL (Query List of Brightness Control Levels Supported) + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of Integers representing the supported brightness levels. + // Each integer has 8 bits of significant data. + // List of supported brightness levels in the following sequence: + // Level when machine has full power. + // Level when machine is on batteries. + // Other supported levels. + // Package(){80, 50, 0, 1, 2, 3, 4, 5, ..., 96, 97, 98, 99, 100} + // + Method(_BCL,,,,PkgObj) + { + If(CondRefOf(\_SB.PCI0.GFX0.DD1F._BCL)) + { + Return(\_SB.PCI0.GFX0.DD1F._BCL()) + } Else { + Return(Package(){0}) + } + } + + // _BCM (Set the Brightness Level) + // + // Arguments: (1) + // Arg0 - An Integer containing the new brightness level + // Return Value: + // None + // + Method(_BCM,1) + { + If(CondRefOf(\_SB.PCI0.GFX0.DD1F._BCM)) + { + \_SB.PCI0.GFX0.DD1F._BCM(Arg0) + } + } + + // _BQC (Brightness Query Current level) + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current brightness level (must be one of the values returned from the _BCL method) + // + Method(_BQC,0) + { + If(CondRefOf(\_SB.PCI0.GFX0.DD1F._BQC)) + { + Return(\_SB.PCI0.GFX0.DD1F._BQC()) + } Else { + Return(0x00) + } + } + + // _DCS (Return the Status of Output Device) + // + //Arguments: (0) + // None + // Return Value: + // An Integer containing the device status (32 bits) + // Bit Definitions + // [0] - Output connector exists in the system now + // [1] - Output is activated + // [2] - Output is ready to switch + // [3] - Output is not defective (it is functioning properly) + // [4] - Device is attached (this is optional) + // [31:5] Reserved (must be zero) + // + Method(_DCS,0) + { + If(CondRefOf(\_SB.PCI0.GFX0.DD1F._DCS)) + { + Return(\_SB.PCI0.GFX0.DD1F._DCS()) + } Else { + Return(0x00) + } + } + + } // End DPLY Device +}// end Scope(\_SB.PCI0) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dppm.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dppm.asl new file mode 100644 index 0000000..f912020 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dppm.asl @@ -0,0 +1,66 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Dppm.asl + +Abstract: + + Intel ACPI Reference Code for Intel Dynamic Power Performance Management + +--*/ + + +Scope(\_SB.IETM) +{ + + // + // DPPM Passive Policy + // + Name (DPSP, Package () + { + ToUUID("42A441D6-AE6A-462B-A84B-4A8CE79027D3"), + }) + + // + // DPPM Active Policy + // + Name (DASP, Package () + { + ToUUID("3A95C389-E4B8-4629-A526-C52C88626BAE"), + }) + + // + // DPPM Crtical Policy + // + Name (DCSP, Package () + { + ToUUID("97C68AE7-15FA-499c-B8C9-5DA81D606E0A"), + }) + + // + // DPPM Cooling Mode Policy + // + Name (DMSP, Package () + { + ToUUID("16CAF1B7-DD38-40ed-B1C1-1B8A1913D531") + }) +} // End Scope(\_SB.IETM) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dptf.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dptf.asl new file mode 100644 index 0000000..38244b1 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Dptf.asl @@ -0,0 +1,852 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Dptf.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +#include "PowerMgmtDefinitions.h" + +DefinitionBlock ( + "Dptf.aml", + "SSDT", + 1, + "DptfTabl", + "DptfTabl", + 0x1000 + ) +{ + + +External(P8XH, MethodObj) +External(ECON, IntObj) +External(TSOD, IntObj) +External(PNHM, IntObj) +External(TCNT, IntObj) +External(\MPLT, IntObj) +External(\PWRS, Intobj) +External(LPMV, IntObj) +External(CRTT, IntObj) +External(ATMC, IntObj) +External(PTMC, IntObj) +External(ATRA, IntObj) +External(PTRA, IntObj) +External(ACTT, IntObj) +External(PSVT, IntObj) +External(ATPC, IntObj) +External(PTPC, IntObj) + +External(DPTF, IntObj) // EnableDptf +External(SADE, IntObj) // EnableSaDevice +External(SACR, IntObj) // CriticalThermalTripPointSa +External(SAHT, IntObj) // HotThermalTripPointSa + +External(PCHD, IntObj) // EnablePchDevice +External(PCHC, IntObj) // CriticalThermalTripPointPch +External(PCHH, IntObj) // HotThermalTripPointPch + +External(MEMD, IntObj) // EnableMemoryDevice +External(MEMC, IntObj) // CriticalThermalTripPointTMEM +External(MEMH, IntObj) // HotThermalTripPointTMEM + +External(FND1, IntObj) // EnableFan1Device +External(FND2, IntObj) // EnableFan2Device + +External(AMBD, IntObj) // EnableAmbientDevice +External(AMAT, IntObj) // ActiveThermalTripPointAmbient +External(AMPT, IntObj) // PassiveThermalTripPointAmbient +External(AMCT, IntObj) // CriticalThermalTripPointAmbient +External(AMHT, IntObj) // HotThermalTripPointAmbient + +External(SKDE, IntObj) // EnableSkinDevice +External(SKAT, IntObj) // ActiveThermalTripPointSkin +External(SKPT, IntObj) // PassiveThermalTripPointSkin +External(SKCT, IntObj) // CriticalThermalTripPointSkin +External(SKHT, IntObj) // HotThermalTripPointSkin + +External(EFDE, IntObj) // EnableExhaustFanDevice +External(EFAT, IntObj) // ActiveThermalTripPointExhaustFan +External(EFPT, IntObj) // PassiveThermalTripPointExhaustFan +External(EFCT, IntObj) // CriticalThermalTripPointExhaustFan +External(EFHT, IntObj) // HotThermalTripPointExhaustFan + +External(VRDE, IntObj) // EnableVRDevice +External(VRAT, IntObj) // ActiveThermalTripPointVR +External(VRPT, IntObj) // PassiveThermalTripPointVR +External(VRCT, IntObj) // CriticalThermalTripPointVR +External(VRHT, IntObj) // HotThermalTripPointVR + +External(WIFD, IntObj) // EnableWifiDevice +External(WFAT, IntObj) // ActiveThermalTripPointWifi +External(WFPT, IntObj) // PassiveThermalTripPointWifi +External(WFCT, IntObj) // CriticalThermalTripPointWifi +External(WFHT, IntObj) // ActiveHotThermalTripPointWifi + +External(WAND, IntObj) // EnableWWANDevice +External(WWAT, IntObj) // ActiveThermalTripPointWWAN +External(WWPT, IntObj) // PassiveThermalTripPointWWAN +External(WWCT, IntObj) // CriticalThermalTripPointWWAN +External(WWHT, IntObj) // ActiveHotThermalTripPointWWAN + +External(WGID, IntObj) // EnableWGigDevice +External(WGAT, IntObj) // ActiveThermalTripPointWGig +External(WGPT, IntObj) // PassiveThermalTripPointWGig +External(WGCT, IntObj) // CriticalThermalTripPointWGig +External(WGHT, IntObj) // ActiveHotThermalTripPointWGig + +External(CTDP, IntObj) // EnableCtdpPolicy +External(LPMP, IntObj) // EnableLpmPolicy +External(DPAP, IntObj) // EnableActivePolicy +External(DPPP, IntObj) // EnablePassivePolicy +External(DPCP, IntObj) // EnableCriticalPolicy +External(DCMP, IntObj) // EnableCoolingModePolicy +External(ECEU, IntObj) // EnableCurrentExecutionUnit +External(TGFG, IntObj) // TargetGfxFreq +External(TRTV, IntObj) // TrtRevision +External(PWRE, IntObj) // EnablePowerDevice +External(PWRP, IntObj) // EnablePowerPolicy + +External(LPOE, IntObj) // LPOEnable +External(LPOP, IntObj) // LPOStartPState +External(LPOS, IntObj) // LPOStepSize +External(LPOW, IntObj) // LPOPowerControlSetting +External(LPER, IntObj) // LPOPerformanceControlSetting + +External(PPSZ, IntObj) // PPCC Step Size +External(\PDC0, IntObj) // CPU0 _PDC Flags + +External(\_TZ.ETMD, IntObj) +External(\_TZ.TZ00, ThermalZoneObj) +External(\_TZ.TZ01, ThermalZoneObj) + +External(\_SB.PCI0, DeviceObj) +External(\_SB.PCI0.B0D4, DeviceObj) +External(\_SB.PCI0.MHBR, FieldUnitObj) + +External(\_SB.PCI0.LPCB.H_EC, DeviceObj) +External(\_SB.PCI0.LPCB.H_EC.ECAV, IntObj) +External(\_SB.PCI0.LPCB.H_EC.ECMD, MethodObj) +External(\_SB.PCI0.LPCB.H_EC.ECRD, MethodObj) // EC Read Method +External(\_SB.PCI0.LPCB.H_EC.ECWT, MethodObj) // EC Write Method +External(\_SB.PCI0.LPCB.H_EC.ECF2, OpRegionObj) +External(\_SB.PCI0.LPCB.H_EC.SKNT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CVRT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.FANT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.AMBT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPSL, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPSH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PINV, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PENV, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PSTP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CMDR, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSD0, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSD1, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.DIM0, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.DIM1, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CFSP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CPUP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CPAP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PMAX, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PECH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CFAN, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSI, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.HYST, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSHT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSLT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSSR, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1RC, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1FC, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.BAT1._BST, MethodObj) +External(\_SB.PCI0.LPCB.H_EC.B1ML, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1MH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPWR, FieldUnitObj) + +External(\_PR.CPU0, ProcessorObj) +External(\_PR.CPU0._PSS, MethodObj) +External(\_PR.CPU0._PPC, IntObj) +External(\_PR.CPU0._TSS, MethodObj) +External(\_PR.CFGD, FieldUnitObj) +External(\_PR.CPU0.TSMF, PkgObj) +External(\_PR.CPU0.TSMC, PkgObj) +External(\_PR.CPU0._PTC, MethodObj) +External(\_PR.CPU0._TSD, MethodObj) +External(\_PR.CPU0._TPC, IntObj) +External(\_PR.CPU1, ProcessorObj) +External(\_PR.CPU2, ProcessorObj) +External(\_PR.CPU3, ProcessorObj) +External(\_PR.CPU4, ProcessorObj) +External(\_PR.CPU5, ProcessorObj) +External(\_PR.CPU6, ProcessorObj) +External(\_PR.CPU7, ProcessorObj) + +External(\_PR.CLVL, FieldUnitObj) +External(\_PR.CBMI, FieldUnitObj) +External(\_PR.PL10, FieldUnitObj) +External(\_PR.PL20, FieldUnitObj) +External(\_PR.PLW0, FieldUnitObj) +External(\_PR.CTC0, FieldUnitObj) +External(\_PR.TAR0, FieldUnitObj) +External(\_PR.PL11, FieldUnitObj) +External(\_PR.PL21, FieldUnitObj) +External(\_PR.PLW1, FieldUnitObj) +External(\_PR.CTC1, FieldUnitObj) +External(\_PR.TAR1, FieldUnitObj) +External(\_PR.PL12, FieldUnitObj) +External(\_PR.PL22, FieldUnitObj) +External(\_PR.PLW2, FieldUnitObj) +External(\_PR.CTC2, FieldUnitObj) +External(\_PR.TAR2, FieldUnitObj) + +External(\_PR.APSV, FieldUnitObj) +External(\_PR.AAC0, FieldUnitObj) +External(\_PR.ACRT, FieldUnitObj) + +External(\_SB.PCCD.PENB, IntObj) + +// Display participant externals +External(DISE, IntObj) // EnableDisplayParticipant +External(\_SB.PCI0.GFX0.DD1F._BCL, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._BCM, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._BQC, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._DCS, MethodObj) + +Scope(\_SB) +{ + // + // DPTF Thermal Zone Device + // + // + Device(IETM) + { + // + // Intel DPTF Thermal Framework Device + // + Name(_HID, EISAID("INT3400")) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(DPTF,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // + // Note: there are seven GUID packages in TMPP and up to seven matching store statements in IDSP. + // The store statements must never exceed the number of package elements to prevent an overrun. + // + Name(TMPP,Package() + { + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000") + }) + + // + // Save original trip points so _OSC method can enable/disable Legacy thermal policies by manipulating trip points. + // + Name (PTRP,0) // Passive trip point + Name (PSEM,0) // Passive semaphore + Name (ATRP,0) // Active trip point + Name (ASEM,0) // Active semaphore + Name (YTRP,0) // Critical trip point + Name (YSEM,0) // Critical semaphore + + // IDSP (Intel DPTF Supported Policies) + // + // This object evaluates to a package of packages, with each package containing the UUID + // values to represent a policy implemented and supported by the Intel DPTF software stack. + // + // Arguments: (0) + // None + // Return Value: + // Package of Guid packages + // + Method(IDSP,0,Serialized,,PkgObj) + { + Name(TMPI,0) + + // Passive Policy GUID + If(LAnd(LEqual(DPPP,1),CondRefOf(DPSP))){ + Store(DeRefOf(Index(DPSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Active Policy GUID + If(LAnd(LEqual(DPAP,1),CondRefOf(DASP))){ + Store(DeRefOf(Index(DASP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Critical Policy GUID + If(LAnd(LEqual(DPCP,1),CondRefOf(DCSP))){ + Store(DeRefOf(Index(DCSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Cooling Mode Policy GUID + If(LAnd(LEqual(DCMP,1),CondRefOf(DMSP))){ + Store(DeRefOf(Index(DMSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // LPM policy GUID + If(LAnd(LEqual(LPMP,1),CondRefOf(LPSP))){ + Store(DeRefOf(Index(LPSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // CTDP Policy GUID + If(LAnd(LEqual(CTDP,1),CondRefOf(CTSP))){ + Store(DeRefOf(Index(CTSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + //Power Policy GUID + If(LAnd(LEqual(PWRP,1),CondRefOf(WPSP))){ + Store(DeRefOf(Index(WPSP,0)), Index(TMPP,TMPI)) + } + + Return(TMPP) + } + + // _OSC (Operating System Capabilities) + // + // This object is evaluated by each DPTF policy implementation to communicate to the platform of the existence and/or control transfer. + // + // Arguments: (4) + // 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 + // + Method(_OSC, 4,Serialized,,BuffObj,{BuffObj,IntObj,IntObj,BuffObj}) + { + Name(NUMP,0) + Name (UID2,ToUUID("FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF")) + + // Point to Status DWORD in the Arg3 buffer (STATUS) + CreateDWordField(Arg3, 0, STS1) + + // Point to Caps DWORDs of the Arg3 buffer (CAPABILITIES) + CreateDWordField(Arg3, 4, CAP1) + + // + // _OSC needs to validate the UUID and Revision. + // + // IF Unrecognized UUID + // Return Unrecognized UUID _OSC Failure + // IF Unsupported Revision + // Return Unsupported Revision _OSC Failure + // + // STS0[0] = Reserved + // STS0[1] = _OSC Failure + // STS0[2] = Unrecognized UUID + // STS0[3] = Unsupported Revision + // STS0[4] = Capabilities masked + // + // Get the platform UUID's that are available, this will be a package of packages. + // + IDSP() // initialize TMPP with GUID's + Store(SizeOf(TMPP),NUMP) // how many GUID's in the package? + + // Note: The comparison method used is necessary due to + // limitations of certain OSes which cannot perform direct + // buffer comparisons. + // + // Create a set of "Input" UUID fields. + // + CreateDWordField(Arg0, 0x0, IID0) + CreateDWordField(Arg0, 0x4, IID1) + CreateDWordField(Arg0, 0x8, IID2) + CreateDWordField(Arg0, 0xC, IID3) + // + // Create a set of "Expected" UUID fields. + // + CreateDWordField(UID2, 0x0, EID0) + CreateDWordField(UID2, 0x4, EID1) + CreateDWordField(UID2, 0x8, EID2) + CreateDWordField(UID2, 0xC, EID3) + // + // Compare the input UUID to the list of UUID's in the system. + // + While(NUMP){ + // + // copy one uuid from TMPP to UID2 + // + Store(DeRefOf (Index (TMPP, Subtract(NUMP,1))),UID2) + // + // Verify the input UUID matches the expected UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + Break // break out of while loop when matching UUID is found + } + Decrement(NUMP) + } + + If(LEqual(NUMP,0)){ + // + // Return Unrecognized UUID _OSC Failure + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0x6,STS1) + Return(Arg3) + } + + If(LNot(LEqual(Arg1, 1))) + { + // + // Return Unsupported Revision _OSC Failure + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0xA,STS1) + Return(Arg3) + } + + If(LNot(LEqual(Arg2, 2))) + { + // + // Return Argument 3 Buffer Count not sufficient + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0x2,STS1) + Return(Arg3) + } + + // + // Passive Policy GUID + // + If(LAnd(LEqual(DPPP,1),CondRefOf(\_PR.APSV))){ + If(LEqual(PSEM,0)){ + Store(1,PSEM) + Store(\_PR.APSV,PTRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DPSP)){ + Store(DeRefOf (Index (DPSP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do passive notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(110,\_PR.APSV) + } Else { // Passive unloading, re-enable legacy thermal zone + Store(PTRP,\_PR.APSV) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + Notify(\_TZ.TZ01, 0x80) + } + Return(Arg3) + } + } + + // + // Active Policy GUID + // + If(LAnd(LEqual(DPAP,1),CondRefOf(\_PR.AAC0))){ + If(LEqual(ASEM,0)){ + Store(1,ASEM) + Store(\_PR.AAC0,ATRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DASP)){ + Store(DeRefOf (Index (DASP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do active notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(110,\_PR.AAC0) + } Else { // Passive unloading, re-enable legacy thermal zone + Store(ATRP,\_PR.AAC0) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + Notify(\_TZ.TZ01, 0x80) + } + Return(Arg3) + } + } + + // + // Critical Policy GUID + // + If(LAnd(LEqual(DPCP,1),CondRefOf(\_PR.ACRT))){ + If(LEqual(YSEM,0)){ + Store(1,YSEM) + Store(\_PR.ACRT,YTRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DCSP)){ + Store(DeRefOf (Index (DCSP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do critical notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(210,\_PR.ACRT) + } Else { // Passive unloading, re-enable legacy thermal zone + Store(YTRP,\_PR.ACRT) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + Notify(\_TZ.TZ01, 0x80) + } + Return(Arg3) + } + } + + Return(Arg3) + } + // KTOC (Kelvin to Celsius) + // + // This control method converts from 10ths of degree Kelvin to Celsius. + // + // Arguments: (1) + // Arg0 - Temperature in 10ths of degree Kelvin + // Return Value: + // Temperature in Celsius + // + Method(KTOC,1) + { + Subtract(Arg0, 2732, Local1) + If(LGreater(Local1,0)) // make sure we don't have a negative number + { + Return(Divide(Local1, 10)) + } + Else + { + Return(0) + } + } + + // CTOK (Celsius to Kelvin) + // + // This control method converts from Celsius to 10ths of degree Kelvin. + // + // Arguments: (1) + // Arg0 - Temperature in Celsius + // Return Value: + // Temperature in 10ths of degree Kelvin + // + Method(CTOK, 1) + { + If(And(Arg0, 0x1000)) // Round negative values up to Zero + { + Return(2372) + } + Multiply(Arg0,10,Local0) + And(Local0, 0x0FFF, Local1) + Add(Local1, 2732, Local2) + Return(Local2) + } + + // PDRT (power device relation table) + // + // This object evaluates to a package of packages that indicates the relation between charge rates and target devices. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length package of packages as described below. + // + // Return Value Information + // Package { + // Package [0] // Package + // .... + // Package [n] // Package + // } + // + // Each sub-Package contains the elements described below: + // Package { + // ChargeRate // Integer (DWORD) + // TargetDevice // Integer (DWORD) + // PTYP // Integer (DWORD) + // ControlBuffer // Package + // } + // + Method(PDRT,,,,PkgObj) + { + \_SB.PCI0.B0D4.PCCC() // init global variable PCCX + If (\PWRS){ // check power source + PDAC() // AC table + } Else { + PDDC() // DC table + } + } // end Method(PDRT) + + Method(PDDC,,,,PkgObj) + { + Name(TMPD,Package() + { + Package() {80, \_SB.PCI0.B0D4, 0x09, Package () {0x00010001,0x80000000}}, // Package domain, PL2, target power from CPU PPM + Package() {60, \_SB.PCI0.B0D4, 0x09, Package () {0x00010000,0x80000000}}, // Package domain, PL1, target power from CPU PPM + Package() {55, \_SB.PCI0.B0D4, 0x09, Package () {0x00070000,1}}, // Package domain, Power Control Turbo Disable + Package() {50, \_SB.PCI0.B0D4, 0x09, Package () {0x00030000,0x80000000}}, // Imax Controls - 30A + Package() {50, \_SB.PCI0.B0D4, 0x00, Package () {0x00040000,2}}, // Core control - 2 cores + Package() {40, \_SB.PCI0.DPLY, 0x0A, Package () {0x00050000,60}}, // Display brightness - 60 + Package() {40, \_SB.PCI0.TMEM, 0x02, Package () {0x00010000,1000}}, // Memory domain, PL1, target power from TMEM.PPCC + Package() {30, \_SB.PCI0.B0D4, 0x00, Package () {0x00020000,80}}, // System Agent Thermal Device, target frequency - P State 80% + Package() {20, \_SB.PCI0.B0D4, 0x00, Package () {0x00020001,50}} // System Agent Thermal Device, target frequency - T State 50% + }) + + If(CondRefOf(\_PR.CBMI)){ + Switch(ToInteger(\_PR.CBMI)){ // use the boot index from PPM to choose the Power Limit values and copy them to local variables + case(0){ + If(LAnd(LGreaterEqual(\_PR.CLVL,1),LLessEqual(\_PR.CLVL,3))){ // copy PL0 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL20,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL10),Local1) // PL1 minimum power + } + } + case(1){ + If(LOr(LEqual(\_PR.CLVL,2),LEqual(\_PR.CLVL,3))){ // copy PL1 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL21,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL11),Local1) // PL1 minimum power + } + } + case(2){ + If(LEqual(\_PR.CLVL,3)){ // copy PL2 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL22,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL12),Local1) // PL1 minimum power + } + } + } + } + + // get the iMax value from the PCCC object and copy it to a local variable + Store (DerefOf(Index(DerefOf(Index(\_SB.PCI0.B0D4.PCCX,1)),0)),Local2) // CurrentLimitMinimum + + // update the first three packages with the values that we had to dynamically determine + // this section might have to be updated any time the PDRT is changed + Store(Local0,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 0)),3)),1)) // Package domain, PL2, target power from CPU PPM + Store(Local1,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 1)),3)),1)) // Package domain, PL1, target power from CPU PPM + Store(Local2,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 3)),3)),1)) // Imax Controls - 30A + + Return(TMPD) + } // Method(PDDC) + + Method(PDAC,,,,PkgObj) + { + Name(TMPD,Package() + { + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00010001,0x80000000}}, // Package domain, PL2, target power from CPU PPM + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00010000,0x80000000}}, // Package domain, PL1, target power from CPU PPM + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00070000,0}}, // Package domain, Power Control Turbo Enable + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00030000,0x80000000}}, // Imax Controls - 30A + Package() {100, \_SB.PCI0.B0D4, 0x00, Package () {0x00040000,0x80000000}}, // Core control - cores from TCNT + Package() {100, \_SB.PCI0.DPLY, 0x0A, Package () {0x00050000,100}}, // Display brightness - 100% + Package() {100, \_SB.PCI0.TMEM, 0x02, Package () {0x00010000,5000}}, // Memory domain, PL1, target power from TMEM.PPCC + Package() {100, \_SB.PCI0.B0D4, 0x00, Package () {0x00020000,100}} // System Agent Thermal Device, target frequency - P State 0% + }) + + If(CondRefOf(\_PR.CBMI)){ + Switch(ToInteger(\_PR.CBMI)){ // use the boot index from PPM to choose the Power Limit values and copy them to local variables + case(0){ + If(LAnd(LGreaterEqual(\_PR.CLVL,1),LLessEqual(\_PR.CLVL,3))){ // copy PL0 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL20,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL10,1),Local1) // PL1 maximum power + } + } + case(1){ + If(LOr(LEqual(\_PR.CLVL,2),LEqual(\_PR.CLVL,3))){ // copy PL1 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL21,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL11,1),Local1) // PL1 maximum power + } + } + case(2){ + If(LEqual(\_PR.CLVL,3)){ // copy PL2 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL22,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL12,1),Local1) // PL1 maximum power + } + } + } + } + + // get the iMax value from the PCCC object and copy it to a local variable + Store (DerefOf(Index(DerefOf(Index(\_SB.PCI0.B0D4.PCCX,1)),1)),Local2) // CurrentLimitMaximum + + // update the first four packages with the values that we had to dynamically determine + // this section might have to be updated any time the PDRT is changed + Store(Local0,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 0)),3)),1)) // Package domain, PL2, target power from CPU PPM + Store(Local1,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 1)),3)),1)) // Package domain, PL1, target power from CPU PPM + Store(Local2,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 3)),3)),1)) // Imax Controls - 30A + Store(TCNT,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 4)),3)),1)) // Core control - cores from TCNT + + Return(TMPD) + } // Method(PDAC) + + } // End IETM Device +} // End \_SB Scope + +// +// EC support code +// +Scope(\_SB.PCI0.LPCB.H_EC) // Open scope to Embedded Controller +{ + // + // Create a Mutex for PATx methods to prevent Sx resume race condition problems asscociated with EC commands. + // + Mutex(PATM, 0) + + // _QF1 (Query - Embedded Controller Query F1) + // + // Handler for EC generated SCI number F1. + // + // Arguments: (0) + // None + // Return Value: + // None + // + Method(_QF1) + { // Thermal sensor threshold crossing event handler + P8XH(0, 0xf1) + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)), Local0) + While(Local0) // Ensure that events occuring during execution + { // of this handler are not dropped + \_SB.PCI0.LPCB.H_EC.ECWT(0, RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)) // clear all status bits + If(And(Local0, 0x10, Local1)) + { // Memory temp threshold crossed + Notify(\_SB.PCI0.TMEM, 0x90) + } + If(And(Local0, 0x8, Local1)) + { // Ambient temp threshold crossed + Notify(\_SB.PCI0.LPCB.H_EC.TAMB, 0x90) + } + If(And(Local0, 0x4, Local1)) + { // Skin temp threshold crossed + Notify(\_SB.PCI0.LPCB.H_EC.TSKN, 0x90) + } + If(And(Local0, 0x2, Local1)) + { // Fan temp threshold crossed + Notify(\_SB.PCI0.LPCB.H_EC.TEFN, 0x90) + } + If(And(Local0, 0x01, Local1)) + { // VR temp threshold crossed + Notify(\_SB.PCI0.LPCB.H_EC.T_VR, 0x90) + } + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)), Local0) + } + } +} // End \_SB.PCI0.LPCB.H_EC Scope + +// +// Processor files. +// + Include("B0d4Participant.asl") + Include("B0d4DppmPolicy.asl") + Include("B0d4CtdpPolicy.asl") + Include("B0d4LpmPolicy.asl") + +// +// CPU files +// + Include("TcpuParticipant.asl") + Include("TcpuDppmPolicy.asl") + +// +// PCH files +// + Include("TpchParticipant.asl") + Include("TpchDppmPolicy.asl") + +// +// These participants, TAMB, TEFN, TFN1, TFN2, TMEM, TSKN, T_VR, are currently used by DPPM policies only. +// Refer to the specific technology BIOS specification. +// + Include("TAmbParticipant.asl") + Include("TAmbDppmPolicy.asl") + Include("TEfnParticipant.asl") + Include("TEfnDppmPolicy.asl") + Include("TFN1Participant.asl") + Include("TFN2Participant.asl") + Include("TMemParticipant.asl") + Include("TMemDppmPolicy.asl") + Include("TSknParticipant.asl") + Include("TSknDppmPolicy.asl") + Include("T_VRParticipant.asl") + Include("T_VRDppmPolicy.asl") + Include("DplyParticipant.asl") + Include("TPwrParticipant.asl") + Include("WWANParticipant.asl") + Include("WWANDppmPolicy.asl") + +// +// DPPM support files +// + Include("Ertm.asl") + Include("Trt.asl") + Include("Art.asl") + Include("Dppm.asl") + + +} // End SSDT diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.cif b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.cif new file mode 100644 index 0000000..a374599 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.cif @@ -0,0 +1,41 @@ +<component> + name = "DptfAcpiTables" + category = ModulePart + LocalRoot = "ReferenceCode\AcpiTables\Dptf\AcpiTables\" + RefName = "DptfAcpiTables" +[files] +"DptfAcpiTables.sdl" +"DptfAcpiTables.mak" +"Art.asl" +"B0d4CtdpPolicy.asl" +"B0d4DppmPolicy.asl" +"B0d4LpmPolicy.asl" +"B0d4Participant.asl" +"Dppm.asl" +"Dptf.asl" +"DplyParticipant.asl" +"DptfAcpiTables.inf" +"Ertm.asl" +"T_VRDppmPolicy.asl" +"T_VRParticipant.asl" +"TAmbDppmPolicy.asl" +"TAmbParticipant.asl" +"TcpuDppmPolicy.asl" +"TcpuParticipant.asl" +"TEfnDppmPolicy.asl" +"TEfnParticipant.asl" +"TFN1Participant.asl" +"TFN2Participant.asl" +"TMemDppmPolicy.asl" +"TMemParticipant.asl" +"TpchDppmPolicy.asl" +"TpchParticipant.asl" +"Trt.asl" +"TSknDppmPolicy.asl" +"TSknParticipant.asl" +"TPwrParticipant.asl" +"WWANParticipant.asl" +"WWANDppmPolicy.asl" +[parts] +"DptfAcpiTablesFfrd" +<endComponent> diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.inf b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.inf new file mode 100644 index 0000000..dd03937 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.inf @@ -0,0 +1,67 @@ +## @file +# Component description file for the ACPI tables +# +#@copyright +# Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +# This software and associated documentation (if any) is furnished +# under a license and may only be used or copied in accordance +# with the terms of the license. Except as permitted by such +# license, no part of this software or documentation may be +# reproduced, stored in a retrieval system, or transmitted in any +# form or by any means without the express written consent of +# Intel Corporation. +# +# This file contains an 'Intel Peripheral Driver' and uniquely +# identified as "Intel Reference Module" and is +# licensed for Intel CPUs and chipsets under the terms of your +# license agreement with Intel or your vendor. This file may +# be modified by the user, subject to additional terms of the +# license agreement +# + + +[defines] +BASE_NAME = DptfAcpiTables +# +# If the value of this GUID is changed then make sure to change the corresponding GUID (DPTF_ACPI_TABLE_STORAGE_GUID) +# in DptfAcpiTableStorage.h. +# +FILE_GUID = EA139578-FEA0-4dd2-91B5-6953819EF1E4 +COMPONENT_TYPE = ACPITABLE +FFS_EXT = .ffs + +[sources.common] + Dptf.ASL + +[libraries.common] + +[includes.common] + . + $(EFI_SOURCE) + $(EFI_SOURCE)/Include + $(EDK_SOURCE)/Foundation/Efi + $(EDK_SOURCE)/Foundation/Include + $(EDK_SOURCE)/Foundation/Efi/Include + $(EDK_SOURCE)/Foundation/Framework/Include + $(EFI_SOURCE)/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Framework + $(EFI_SOURCE)/$(PROJECT_CPU_ROOT)/Include + +# +# Edk II Glue Library, some header are not included by R9 header so have to include +# + $(EFI_SOURCE) + $(EFI_SOURCE)/Framework + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Framework + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Core/Dxe + $(EDK_SOURCE)/Foundation/Include/Pei + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include/Library + +[nmake.common] diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.mak b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.mak new file mode 100644 index 0000000..f5dbc7e --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.mak @@ -0,0 +1,106 @@ +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* + +#********************************************************************** +# $Header: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfAcpiTables/DptfAcpiTables.mak 5 6/02/13 8:18a Joshchou $ +# +# $Revision: 5 $ +# +# $Date: 6/02/13 8:18a $ +#********************************************************************** +# Revision History +# ---------------- +# $Log: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfAcpiTables/DptfAcpiTables.mak $ +# +# 5 6/02/13 8:18a Joshchou +# [TAG] None +# [Category] Improvement +# [Description] Change IASL compiler path to +# $(ACPIPLATFORM_ASL_COMPILER) in SharkBay project. +# +# 4 1/28/13 10:02p Joshchou +# [TAG] None +# [Category] Improvement +# [Description] Change the build tool path. +# +# 3 11/20/12 4:24a Joshchou +# [TAG] None +# [Category] Improvement +# [Description] Create Token for OEM clone +# +# 2 9/26/12 1:58a Victortu +# +# 1 4/24/12 9:25a Victortu +# Intel DPTF initialization. +# +#********************************************************************** +#<AMI_FHDR_START> +# +# Name: DptfAcpiTables.mak +# +# Description: MAke file to build Intel DPTF ACPI ASL components +# +#<AMI_FHDR_END> +#********************************************************************** +#----------------------------------------------------------------------- +# ASL compiler definition +#----------------------------------------------------------------------- +!IF "$(ACPIPLATFORM_ASL_COMPILER)"=="" +!ERROR It is an invalid path, please check your ASL compiler path. +!ENDIF + +IASL = $(ACPIPLATFORM_ASL_COMPILER) +#----------------------------------------------------------------------- +EDK : DPTFACPI + +ALLDPTFSEC = $(BUILD_DIR)\Dptf.sec + +DPTFACPI : $(BUILD_DIR)\DptfAcpiTables.ffs + +$(BUILD_DIR)\Dptf.aml : $(INTEL_DPTF_ASL_FILE) + $(ASLEXPANDER) $(INTEL_DPTF_ASL_FILE) $(BUILD_DIR)\Dptf.asl $(PROJECT_CPU_ROOT)\Include + $(IASL) -p $(BUILD_DIR)\Dptf.aml $(BUILD_DIR)\Dptf.asl + +$(BUILD_DIR)\Dptf.sec: $(BUILD_DIR)\Dptf.aml + $(GENSECTION) -I $** -O $@ -S EFI_SECTION_RAW + +$(BUILD_DIR)\DptfAcpiTables.ffs: $(ALLDPTFSEC) $(INTEL_DPTF_ACPI_TABLE_DIR)\DptfAcpiTables.mak + $(GENFFSFILE) -B $(BUILD_DIR) -V -o $@ -P1 <<$(BUILD_DIR)\DptfAcpiTables.pkg +PACKAGE.INF +[.] +BASE_NAME = DptfAcpiTables +FFS_FILEGUID = EA139578-FEA0-4dd2-91B5-6953819EF1E4 +FFS_FILETYPE = EFI_FV_FILETYPE_FREEFORM +FFS_ATTRIB_CHECKSUM = TRUE + +IMAGE_SCRIPT = +{ + Compress (dummy) { + $(PROJECT_DIR)\$(BUILD_DIR)\Dptf.sec + } +} +<<KEEP +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.sdl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.sdl new file mode 100644 index 0000000..50d6780 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/DptfAcpiTables.sdl @@ -0,0 +1,31 @@ +TOKEN + Name = DptfAcpiTables_SUPPORT + Value = 1 + TokenType = Boolean + TargetEQU = Yes + TargetMAK = Yes + Master = Yes + Help = "Main switch to enable DptfAcpiTables support in Project" +End + +MODULE + Help = "Includes DptfAcpiTables.mak to Project" + File = "DptfAcpiTables.mak" +End + +PATH + Name = "INTEL_DPTF_ACPI_TABLE_DIR" +End + +TOKEN + Name = "INTEL_DPTF_ASL_FILE" + Value = "$(INTEL_DPTF_ACPI_TABLE_DIR)\Dptf.asl" + TokenType = Expression + TargetMAK = Yes +End + +ELINK + Name = "$(BUILD_DIR)\DptfAcpiTables.ffs" + Parent = "FV_MAIN" + InvokeOrder = AfterParent +End
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ertm.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ertm.asl new file mode 100644 index 0000000..a2f0a50 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ertm.asl @@ -0,0 +1,55 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Ertm.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.IETM) +{ + // ETRM (Intel DPTF Participant List) + // + // The ETRM object evaluates to a package of packages each of which describes one participant device. + // + Name(ETRM, Package() + { // TODO: Replace with system-specific ETRM data here + Package() {\_SB.TCPU, "INT3401", 0x06, "0"}, // Processor Device + Package() {\_SB.PCI0.TMEM, "INT3402", 0x06, "0"}, // Memory Device + Package() {\_SB.PCI0.LPCB.H_EC.TSKN, "INT3403", 0x06, "0"}, // Skin Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TAMB, "INT3403", 0x06, "1"}, // Ambient Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.T_VR, "INT3403", 0x06, "2"}, // VR Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TEFN, "INT3403", 0x06, "3"}, // Exhaust Fan Temperature Sensor + Package() {\_SB.PCI0.WWAN, "INT3408", 0x06, "1"}, // Wireless WWAN temperature sensor Device + Package() {\_SB.PCI0.LPCB.H_EC.TFN1, "INT3404", 0x06, "0"}, // Fan Control Device + Package() {\_SB.PCI0.LPCB.H_EC.TFN2, "INT3404", 0x06, "1"}, // Fan Control Device + Package() {\_SB.PCI0.DPLY, "INT3406", 0x06, "0"}, // Display Participant Device + Package() {\_SB.PCI0.B0D4, "8086_0C03", 0x00, "0x00040000"}, // HSW SA Thermal Device + Package() {\_SB.PCI0.TPCH, "8086_8C24", 0x00, "0x001F0006"}, // LPT PCH Thermal Device + Package() {\_SB.PCI0.B0D4, "8086_0A03", 0x00, "0x00040000"}, // HSW ULT SA Thermal Device + Package() {\_SB.PCI0.TPCH, "8086_9C24", 0x00, "0x001F0006"}, // LPT ULT PCH Thermal Device + Package() {\_SB.PCI0.B0D4, "8086_0D03", 0x00, "0x00040000"} // CRW SA Thermal Device + }) +} diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Art.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Art.asl new file mode 100644 index 0000000..54c7fa0 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Art.asl @@ -0,0 +1,81 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Art.asl + +Abstract: + + Intel ACPI Reference Code for Intel Dynamic Power Performance Management + +--*/ + + Scope(\_SB.IETM) + { + + Name(ART1, Package() // ART package when in Quiet Mode / Passive Cooling Mode + { + 0, // Revision + // Source Target Weight, AC0MaxLevel, AC1MaxLevel, AC21MaxLevel, AC31MaxLevel, AC41MaxLevel, AC51MaxLevel, AC61MaxLevel, AC71MaxLevel, AC81MaxLevel, AC91MaxLevel + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.B0D4, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.B0D4, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + }) + + Name(ART0, Package() // ART package when in Performance Mode / Active Cooling Mode + { + 0, // Revision + // Source Target Weight, AC0MaxLevel, AC1MaxLevel, AC21MaxLevel, AC31MaxLevel, AC41MaxLevel, AC51MaxLevel, AC61MaxLevel, AC71MaxLevel, AC81MaxLevel, AC91MaxLevel + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.LPCB.H_EC.TSKN, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN1, \_SB.PCI0.B0D4, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + Package(){\_SB.PCI0.LPCB.H_EC.TFN2, \_SB.PCI0.B0D4, 100, 65, 50, 30, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, + }) + + // _ART (Active Cooling Relationship Table) + // + // Arguments: + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Active Relationship Packages as described below: + // + // Return Value Information + // Package { + // Revision, // Integer - Current revision is: 0 + // ActiveRelationship[0] // Package + // ... + // ActiveRelationship[n] // Package + // } + // + Method(_ART,,,,PkgObj) + { // TODO: Add system-specific _ART code here + If(\ECON) + { + If(\_SB.PCI0.LPCB.H_EC.TSKN.CTYP) + { + Return(ART1) + } Else { + Return(ART0) + } + } + } // End _ART +} diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/B0d4DppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/B0d4DppmPolicy.asl new file mode 100644 index 0000000..d46e240 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/B0d4DppmPolicy.asl @@ -0,0 +1,192 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + B0d4DppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + + +Scope(\_SB.PCI0.B0D4) +{ + Name(CTYP,0) // Device-specific cooling policy preference + Name(AHYS,60) // Active Cooling Hysteresis configuration. Use this in conjuction with GTSH to define _ACx hysteresis points. (in 1/10 of K) + Name(AC1D,40) // _AC1 Delta from _AC0 (in 1/10 of K) + Name(AC2D,80) // _AC2 Delta from _AC0 (in 1/10 of K) + Name(GTSH, 0) // No HW Hysteresis for B0D4 + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + Store(\_SB.IETM.CTOK(ATMC),Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + Store(\_SB.IETM.CTOK(ATMC),Local0) // Active Cooling Policy + Subtract(Local0, AC1D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC2) + { + Store(\_SB.IETM.CTOK(ATMC),Local0) // Active Cooling Policy + Subtract(Local0, AC2D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SACR)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SAHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV,0,Serialized) + { + Return(\_SB.IETM.CTOK(PTMC)) + } + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP,3,Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(B0D4, 0x91) + } + } + +} // End Scope(\_SB.PCI0.B0D4) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.cif b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.cif new file mode 100644 index 0000000..9d67abb --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.cif @@ -0,0 +1,25 @@ +<component> + name = "DptfAcpiTablesFfrd" + category = ModulePart + LocalRoot = "ReferenceCode\AcpiTables\Dptf\AcpiTables\Ffrd\" + RefName = "DptfAcpiTablesFfrd" +[files] +"DptfAcpiTablesFfrd.sdl" +"DptfAcpiTablesFfrd.mak" +"DptfAcpiTablesFfrd.inf" +"B0d4DppmPolicy.asl" +"Art.asl" +"DptfFfrd.asl" +"Ertm.asl" +"TAmbParticipant.asl" +"TEfnParticipant.asl" +"TFN1Participant.asl" +"TFN2Participant.asl" +"TMemDppmPolicy.asl" +"TInlDppmPolicy.asl" +"TInlParticipant.asl" +"TMemParticipant.asl" +"Trt.asl" +"TSknParticipant.asl" +"TSknDppmPolicy.asl" +<endComponent> diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.inf b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.inf new file mode 100644 index 0000000..6a73ca0 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.inf @@ -0,0 +1,68 @@ +## @file +# Component description file for the ACPI tables +# +#@copyright +# Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +# This software and associated documentation (if any) is furnished +# under a license and may only be used or copied in accordance +# with the terms of the license. Except as permitted by such +# license, no part of this software or documentation may be +# reproduced, stored in a retrieval system, or transmitted in any +# form or by any means without the express written consent of +# Intel Corporation. +# +# This file contains an 'Intel Peripheral Driver' and uniquely +# identified as "Intel Reference Module" and is +# licensed for Intel CPUs and chipsets under the terms of your +# license agreement with Intel or your vendor. This file may +# be modified by the user, subject to additional terms of the +# license agreement +# + + +[defines] +BASE_NAME = DptfAcpiTablesFfrd +# +# If the value of this GUID is changed then make sure to change the corresponding GUID (DPTF_ACPI_TABLE_STORAGE_GUID) +# in DptfAcpiTableStorage.h. +# +FILE_GUID = 2820908B-87F6-446b-A100-74EEE36E2918 +COMPONENT_TYPE = ACPITABLE +FFS_EXT = .ffs + +[sources.common] + DptfFfrd.ASL + +[libraries.common] + +[includes.common] + . + .. + $(EFI_SOURCE) + $(EFI_SOURCE)/Include + $(EDK_SOURCE)/Foundation/Efi + $(EDK_SOURCE)/Foundation/Include + $(EDK_SOURCE)/Foundation/Efi/Include + $(EDK_SOURCE)/Foundation/Framework/Include + $(EFI_SOURCE)/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Framework + $(EFI_SOURCE)/$(PROJECT_CPU_ROOT)/Include + +# +# Edk II Glue Library, some header are not included by R9 header so have to include +# + $(EFI_SOURCE) + $(EFI_SOURCE)/Framework + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Framework + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Core/Dxe + $(EDK_SOURCE)/Foundation/Include/Pei + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include/Library + +[nmake.common] diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.mak b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.mak new file mode 100644 index 0000000..7fa30fa --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.mak @@ -0,0 +1,81 @@ +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2013, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* + +#************************************************************************* +#<AMI_FHDR_START> +# +# Name: DptfAcpiTablesFfrd.mak +# +# Description: MAke file to build Aptio ACPI ASL components +# +# +#<AMI_FHDR_END> +#************************************************************************* +all : BuildDptfAcpiTablesFfrd + +BuildDptfAcpiTablesFfrd : $(BUILD_DIR)\DptfAcpiTablesFfrd.ffs + +#----------------------------------------------------------------------- +# ASL compiler definition +#----------------------------------------------------------------------- +!IF "$(ACPIPLATFORM_ASL_COMPILER)"=="" +!ERROR It is an invalid path, please check your ASL compiler path. +!ENDIF + +IASL = $(ACPIPLATFORM_ASL_COMPILER) +#----------------------------------------------------------------------- + +$(BUILD_DIR)\DptfAcpiTablesFfrd.aml : $(INTEL_DptfAcpiTablesFfrd_DIR)\DptfFfrd.asl + $(ASLEXPANDER) $(INTEL_DptfAcpiTablesFfrd_DIR)\DptfFfrd.asl $(BUILD_DIR)\DptfFfrd.asl $(PROJECT_CPU_ROOT)\Include + $(IASL) -p $(BUILD_DIR)\DptfAcpiTablesFfrd.aml $(BUILD_DIR)\DptfFfrd.asl + +$(BUILD_DIR)\DptfAcpiTablesFfrd.sec: $(BUILD_DIR)\DptfAcpiTablesFfrd.aml + $(GENSECTION) -I $*.aml -O $@ -S EFI_SECTION_RAW + +#Note. Expand the package with DptfAcpiTablesFfrd tables. +# DXE phase will load the tables +# and update Aml contents if provided in Acpiplatform.c + +$(BUILD_DIR)\DptfAcpiTablesFfrd.ffs: $(BUILD_DIR)\DptfAcpiTablesFfrd.sec + $(GENFFSFILE) -B $(BUILD_DIR) -V -o $@ -P1 <<$(BUILD_DIR)\DptfAcpiTablesFfrd.pkg + +PACKAGE.INF +[.] +BASE_NAME = DptfAcpiTablesFfrd +FFS_FILEGUID = 2820908B-87F6-446b-A100-74EEE36E2918 +FFS_FILETYPE = EFI_FV_FILETYPE_FREEFORM +FFS_ATTRIB_CHECKSUM = TRUE + +IMAGE_SCRIPT = +{ + Compress (dummy) { + $(PROJECT_DIR)\$(BUILD_DIR)\DptfAcpiTablesFfrd.sec + } +} +<<KEEP + + +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2013, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.sdl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.sdl new file mode 100644 index 0000000..5285e7e --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfAcpiTablesFfrd.sdl @@ -0,0 +1,25 @@ +TOKEN + Name = "DptfAcpiTablesFfrd_SUPPORT" + Value = "1" + Help = "Main switch to enable DptfAcpiTablesFfrd support in Project" + TokenType = Boolean + TargetMAK = Yes + TargetH = Yes + Master = Yes +End + +PATH + Name = "INTEL_DptfAcpiTablesFfrd_DIR" +End + +MODULE + Help = "Includes DptfAcpiTablesFfrd.mak to Project" + File = "DptfAcpiTablesFfrd.mak" +End + +ELINK + Name = "$(BUILD_DIR)\DptfAcpiTablesFfrd.ffs" + Parent = "FV_MAIN" + InvokeOrder = AfterParent + Token = "DptfAcpiTablesFfrd_SUPPORT" "=" "1" +End diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfFfrd.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfFfrd.asl new file mode 100644 index 0000000..0afa8d7 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/DptfFfrd.asl @@ -0,0 +1,874 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + DptfFfrd.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +#include "PowerMgmtDefinitions.h" + +DefinitionBlock ( + "DptfFfrd.aml", + "SSDT", + 1, + "DptfFf", + "DptfFfrd", + 0x1000 + ) +{ + + +External(P8XH, MethodObj) +External(ECON, IntObj) +External(TSOD, IntObj) +External(PNHM, IntObj) +External(TCNT, IntObj) +External(\MPLT, IntObj) +External(\PWRS, Intobj) +External(LPMV, IntObj) +External(CRTT, IntObj) +External(ATMC, IntObj) +External(PTMC, IntObj) +External(ATRA, IntObj) +External(PTRA, IntObj) +External(ACTT, IntObj) +External(PSVT, IntObj) +External(ATPC, IntObj) +External(PTPC, IntObj) + +External(DPTF, IntObj) // EnableDptf +External(SADE, IntObj) // EnableSaDevice +External(SACR, IntObj) // CriticalThermalTripPointSa +External(SAHT, IntObj) // HotThermalTripPointSa + +External(PCHD, IntObj) // EnablePchDevice +External(PCHC, IntObj) // CriticalThermalTripPointPch +External(PCHH, IntObj) // HotThermalTripPointPch + +External(MEMD, IntObj) // EnableMemoryDevice +External(MEMC, IntObj) // CriticalThermalTripPointTMEM +External(MEMH, IntObj) // HotThermalTripPointTMEM + +External(FND1, IntObj) // EnableFan1Device +External(FND2, IntObj) // EnableFan2Device + +External(AMBD, IntObj) // EnableAmbientDevice +External(AMAT, IntObj) // ActiveThermalTripPointAmbient +External(AMPT, IntObj) // PassiveThermalTripPointAmbient +External(AMCT, IntObj) // CriticalThermalTripPointAmbient +External(AMHT, IntObj) // HotThermalTripPointAmbient + +External(SKDE, IntObj) // EnableSkinDevice +External(SKAT, IntObj) // ActiveThermalTripPointSkin +External(SKPT, IntObj) // PassiveThermalTripPointSkin +External(SKCT, IntObj) // CriticalThermalTripPointSkin +External(SKHT, IntObj) // HotThermalTripPointSkin + +External(EFDE, IntObj) // EnableExhaustFanDevice +External(EFAT, IntObj) // ActiveThermalTripPointExhaustFan +External(EFPT, IntObj) // PassiveThermalTripPointExhaustFan +External(EFCT, IntObj) // CriticalThermalTripPointExhaustFan +External(EFHT, IntObj) // HotThermalTripPointExhaustFan + +External(VRDE, IntObj) // EnableVRDevice +External(VRAT, IntObj) // ActiveThermalTripPointVR +External(VRPT, IntObj) // PassiveThermalTripPointVR +External(VRCT, IntObj) // CriticalThermalTripPointVR +External(VRHT, IntObj) // HotThermalTripPointVR + +External(WIFD, IntObj) // EnableWifiDevice +External(WFAT, IntObj) // ActiveThermalTripPointWifi +External(WFPT, IntObj) // PassiveThermalTripPointWifi +External(WFCT, IntObj) // CriticalThermalTripPointWifi +External(WFHT, IntObj) // ActiveHotThermalTripPointWifi + +External(WAND, IntObj) // EnableWWANDevice +External(WWAT, IntObj) // ActiveThermalTripPointWWAN +External(WWPT, IntObj) // PassiveThermalTripPointWWAN +External(WWCT, IntObj) // CriticalThermalTripPointWWAN +External(WWHT, IntObj) // ActiveHotThermalTripPointWWAN + +External(CTDP, IntObj) // EnableCtdpPolicy +External(LPMP, IntObj) // EnableLpmPolicy +External(DPAP, IntObj) // EnableActivePolicy +External(DPPP, IntObj) // EnablePassivePolicy +External(DPCP, IntObj) // EnableCriticalPolicy +External(DCMP, IntObj) // EnableCoolingModePolicy +External(ECEU, IntObj) // EnableCurrentExecutionUnit +External(TGFG, IntObj) // TargetGfxFreq +External(TRTV, IntObj) // TrtRevision +External(PWRE, IntObj) // EnablePowerDevice +External(PWRP, IntObj) // EnablePowerPolicy + +External(LPOE, IntObj) // LPOEnable +External(LPOP, IntObj) // LPOStartPState +External(LPOS, IntObj) // LPOStepSize +External(LPOW, IntObj) // LPOPowerControlSetting +External(LPER, IntObj) // LPOPerformanceControlSetting + +External(PPSZ, IntObj) // PPCC Step Size +External(\PDC0, IntObj) // CPU0 _PDC Flags + +External(WWSD,IntObj) // EnableWwanTempSensorDevice +External(CVSD,IntObj) // EnableCpuVrTempSensorDevice +External(SSDD,IntObj) // EnableSsdTempSensorDevice +External(INLD,IntObj) // EnableInletFanTempSensorDevice +External(IFAT,IntObj) // ActiveThermalTripPointInletFan +External(IFPT,IntObj) // PassiveThermalTripPointInletFan +External(IFCT,IntObj) // CriticalThermalTripPointInletFan +External(IFHT,IntObj) // HotThermalTripPointInletFan + +External(\_TZ.ETMD, IntObj) +External(\_TZ.TZ00, ThermalZoneObj) +External(\_TZ.FAN0, DeviceObj) +External(\_TZ.FAN0._FST, PkgObj) + +External(\_SB.PCI0, DeviceObj) +External(\_SB.PCI0.B0D4, DeviceObj) +External(\_SB.PCI0.MHBR, FieldUnitObj) + +External(\_SB.PCI0.LPCB.H_EC, DeviceObj) +External(\_SB.PCI0.LPCB.H_EC.ECAV, IntObj) +External(\_SB.PCI0.LPCB.H_EC.ECMD, MethodObj) +External(\_SB.PCI0.LPCB.H_EC.ECRD, MethodObj) // EC Read Method +External(\_SB.PCI0.LPCB.H_EC.ECWT, MethodObj) // EC Write Method +External(\_SB.PCI0.LPCB.H_EC.ECF2, OpRegionObj) +External(\_SB.PCI0.LPCB.H_EC.SKNT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CVRT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.FANT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.AMBT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPSL, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPSH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PINV, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PENV, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PSTP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CMDR, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSD0, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSD1, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.DIM0, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.DIM1, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CFSP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CFS2, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CPUP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CPAP, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PMAX, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PECH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.CFAN, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSI, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.HYST, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSHT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSLT, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.TSSR, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1RC, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1FC, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.BAT1._BST, MethodObj) +External(\_SB.PCI0.LPCB.H_EC.B1ML, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.B1MH, FieldUnitObj) +External(\_SB.PCI0.LPCB.H_EC.PPWR, FieldUnitObj) + +External(\_PR.CPU0, ProcessorObj) +External(\_PR.CPU0._PSS, MethodObj) +External(\_PR.CPU0._PPC, IntObj) +External(\_PR.CPU0._TSS, MethodObj) +External(\_PR.CFGD, FieldUnitObj) +External(\_PR.CPU0.TSMF, PkgObj) +External(\_PR.CPU0.TSMC, PkgObj) +External(\_PR.CPU0._PTC, MethodObj) +External(\_PR.CPU0._TSD, MethodObj) +External(\_PR.CPU0._TPC, IntObj) +External(\_PR.CPU1, ProcessorObj) +External(\_PR.CPU2, ProcessorObj) +External(\_PR.CPU3, ProcessorObj) +External(\_PR.CPU4, ProcessorObj) +External(\_PR.CPU5, ProcessorObj) +External(\_PR.CPU6, ProcessorObj) +External(\_PR.CPU7, ProcessorObj) + +External(\_PR.CLVL, FieldUnitObj) +External(\_PR.CBMI, FieldUnitObj) +External(\_PR.PL10, FieldUnitObj) +External(\_PR.PL20, FieldUnitObj) +External(\_PR.PLW0, FieldUnitObj) +External(\_PR.CTC0, FieldUnitObj) +External(\_PR.TAR0, FieldUnitObj) +External(\_PR.PL11, FieldUnitObj) +External(\_PR.PL21, FieldUnitObj) +External(\_PR.PLW1, FieldUnitObj) +External(\_PR.CTC1, FieldUnitObj) +External(\_PR.TAR1, FieldUnitObj) +External(\_PR.PL12, FieldUnitObj) +External(\_PR.PL22, FieldUnitObj) +External(\_PR.PLW2, FieldUnitObj) +External(\_PR.CTC2, FieldUnitObj) +External(\_PR.TAR2, FieldUnitObj) + +External(\_PR.APSV, FieldUnitObj) +External(\_PR.AAC0, FieldUnitObj) +External(\_PR.ACRT, FieldUnitObj) + +External(\_SB.PCCD.PENB, IntObj) + +// Display participant externals +External(DISE, IntObj) // EnableDisplayParticipant +External(\_SB.PCI0.GFX0.DD1F._BCL, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._BCM, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._BQC, MethodObj) +External(\_SB.PCI0.GFX0.DD1F._DCS, MethodObj) + +Scope(\_SB) +{ + // + // DPTF Thermal Zone Device + // + // + Device(IETM) + { + // + // Intel DPTF Thermal Framework Device + // + Name(_HID, EISAID("INT3400")) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(DPTF,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // + // Note: there are seven GUID packages in TMPP and up to seven matching store statements in IDSP. + // The store statements must never exceed the number of package elements to prevent an overrun. + // + Name(TMPP,Package() + { + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000"), + ToUUID("00000000-0000-0000-0000-000000000000") + }) + + // + // Save original trip points so _OSC method can enable/disable Legacy thermal policies by manipulating trip points. + // + Name (PTRP,0) // Passive trip point + Name (PSEM,0) // Passive semaphore + Name (ATRP,0) // Active trip point + Name (ASEM,0) // Active semaphore + Name (YTRP,0) // Critical trip point + Name (YSEM,0) // Critical semaphore + + // IDSP (Intel DPTF Supported Policies) + // + // This object evaluates to a package of packages, with each package containing the UUID + // values to represent a policy implemented and supported by the Intel DPTF software stack. + // + // Arguments: (0) + // None + // Return Value: + // Package of Guid packages + // + Method(IDSP,0,Serialized,,PkgObj) + { + Name(TMPI,0) + + // Passive Policy GUID + If(LAnd(LEqual(DPPP,1),CondRefOf(DPSP))){ + Store(DeRefOf(Index(DPSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Active Policy GUID + If(LAnd(LEqual(DPAP,1),CondRefOf(DASP))){ + Store(DeRefOf(Index(DASP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Critical Policy GUID + If(LAnd(LEqual(DPCP,1),CondRefOf(DCSP))){ + Store(DeRefOf(Index(DCSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // Cooling Mode Policy GUID + If(LAnd(LEqual(DCMP,1),CondRefOf(DMSP))){ + Store(DeRefOf(Index(DMSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // LPM policy GUID + If(LAnd(LEqual(LPMP,1),CondRefOf(LPSP))){ + Store(DeRefOf(Index(LPSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + // CTDP Policy GUID + If(LAnd(LEqual(CTDP,1),CondRefOf(CTSP))){ + Store(DeRefOf(Index(CTSP,0)), Index(TMPP,TMPI)) + Increment(TMPI) + } + + //Power Policy GUID + If(LAnd(LEqual(PWRP,1),CondRefOf(WPSP))){ + Store(DeRefOf(Index(WPSP,0)), Index(TMPP,TMPI)) + } + + Return(TMPP) + } + + // _OSC (Operating System Capabilities) + // + // This object is evaluated by each DPTF policy implementation to communicate to the platform of the existence and/or control transfer. + // + // Arguments: (4) + // 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 + // + Method(_OSC, 4,Serialized,,BuffObj,{BuffObj,IntObj,IntObj,BuffObj}) + { + Name(NUMP,0) + Name (UID2,ToUUID("FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF")) + + // Point to Status DWORD in the Arg3 buffer (STATUS) + CreateDWordField(Arg3, 0, STS1) + + // Point to Caps DWORDs of the Arg3 buffer (CAPABILITIES) + CreateDWordField(Arg3, 4, CAP1) + + // + // _OSC needs to validate the UUID and Revision. + // + // IF Unrecognized UUID + // Return Unrecognized UUID _OSC Failure + // IF Unsupported Revision + // Return Unsupported Revision _OSC Failure + // + // STS0[0] = Reserved + // STS0[1] = _OSC Failure + // STS0[2] = Unrecognized UUID + // STS0[3] = Unsupported Revision + // STS0[4] = Capabilities masked + // + // Get the platform UUID's that are available, this will be a package of packages. + // + IDSP() // initialize TMPP with GUID's + Store(SizeOf(TMPP),NUMP) // how many GUID's in the package? + + // Note: The comparison method used is necessary due to + // limitations of certain OSes which cannot perform direct + // buffer comparisons. + // + // Create a set of "Input" UUID fields. + // + CreateDWordField(Arg0, 0x0, IID0) + CreateDWordField(Arg0, 0x4, IID1) + CreateDWordField(Arg0, 0x8, IID2) + CreateDWordField(Arg0, 0xC, IID3) + // + // Create a set of "Expected" UUID fields. + // + CreateDWordField(UID2, 0x0, EID0) + CreateDWordField(UID2, 0x4, EID1) + CreateDWordField(UID2, 0x8, EID2) + CreateDWordField(UID2, 0xC, EID3) + // + // Compare the input UUID to the list of UUID's in the system. + // + While(NUMP){ + // + // copy one uuid from TMPP to UID2 + // + Store(DeRefOf (Index (TMPP, Subtract(NUMP,1))),UID2) + // + // Verify the input UUID matches the expected UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + Break // break out of while loop when matching UUID is found + } + Decrement(NUMP) + } + + If(LEqual(NUMP,0)){ + // + // Return Unrecognized UUID _OSC Failure + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0x6,STS1) + Return(Arg3) + } + + If(LNot(LEqual(Arg1, 1))) + { + // + // Return Unsupported Revision _OSC Failure + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0xA,STS1) + Return(Arg3) + } + + If(LNot(LEqual(Arg2, 2))) + { + // + // Return Argument 3 Buffer Count not sufficient + // + And(STS1,0xFFFFFF00,STS1) + Or(STS1,0x2,STS1) + Return(Arg3) + } + + // + // Passive Policy GUID + // + If(LAnd(LEqual(DPPP,1),CondRefOf(\_PR.APSV))){ + If(LEqual(PSEM,0)){ + Store(1,PSEM) + Store(\_PR.APSV,PTRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DPSP)){ + Store(DeRefOf (Index (DPSP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do passive notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(110,\_PR.APSV) + } Else { // Passive unloading, re-enable legacy thermal zone + Store(PTRP,\_PR.APSV) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + } + Return(Arg3) + } + } + + // + // Active Policy GUID + // + If(LAnd(LEqual(DPAP,1),CondRefOf(\_PR.AAC0))){ + If(LEqual(ASEM,0)){ + Store(1,ASEM) + Store(\_PR.AAC0,ATRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DASP)){ + Store(DeRefOf (Index (DASP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do active notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(110,\_PR.AAC0) + Store(0, \_TZ.ETMD) // Legacy Active TM Management relies on this variable. + } Else { // Passive unloading, re-enable legacy thermal zone + Store(ATRP,\_PR.AAC0) + Store(1, \_TZ.ETMD) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + } + Return(Arg3) + } + } + + // + // Critical Policy GUID + // + If(LAnd(LEqual(DPCP,1),CondRefOf(\_PR.ACRT))){ + If(LEqual(YSEM,0)){ + Store(1,YSEM) + Store(\_PR.ACRT,YTRP) // use semaphore so variable is only initialized once + } + // + // copy the GUID to UID2 + // + If(CondRefOf(DCSP)){ + Store(DeRefOf (Index (DCSP, 0)),UID2) + } + // + // Verify the test UUID matches the input UUID. + // + If(LAnd(LAnd(LEqual(IID0, EID0), LEqual(IID1, EID1)), LAnd(LEqual(IID2, EID2), LEqual(IID3, EID3)))){ + // do critical notify + If(Not(And(STS1, 0x01))) // Test Query Flag + { // Not a query operation, so process the request + If(And(CAP1, 0x01)) + { // Enable DPTF + // Nullify the legacy thermal zone. + Store(210,\_PR.ACRT) + } Else { // Passive unloading, re-enable legacy thermal zone + Store(YTRP,\_PR.ACRT) + } + // Send notification to legacy thermal zone for legacy policy to be enabled/disabled + Notify(\_TZ.TZ00, 0x80) + } + Return(Arg3) + } + } + + Return(Arg3) + } + // KTOC (Kelvin to Celsius) + // + // This control method converts from 10ths of degree Kelvin to Celsius. + // + // Arguments: (1) + // Arg0 - Temperature in 10ths of degree Kelvin + // Return Value: + // Temperature in Celsius + // + Method(KTOC,1) + { + Subtract(Arg0, 2732, Local1) + If(LGreater(Local1,0)) // make sure we don't have a negative number + { + Return(Divide(Local1, 10)) + } + Else + { + Return(0) + } + } + + // CTOK (Celsius to Kelvin) + // + // This control method converts from Celsius to 10ths of degree Kelvin. + // + // Arguments: (1) + // Arg0 - Temperature in Celsius + // Return Value: + // Temperature in 10ths of degree Kelvin + // + Method(CTOK, 1) + { + If(And(Arg0, 0x1000)) // Round negative values up to Zero + { + Return(2372) + } + Multiply(Arg0,10,Local0) + And(Local0, 0x0FFF, Local1) + Add(Local1, 2732, Local2) + Return(Local2) + } + + // PDRT (power device relation table) + // + // This object evaluates to a package of packages that indicates the relation between charge rates and target devices. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length package of packages as described below. + // + // Return Value Information + // Package { + // Package [0] // Package + // .... + // Package [n] // Package + // } + // + // Each sub-Package contains the elements described below: + // Package { + // ChargeRate // Integer (DWORD) + // TargetDevice // Integer (DWORD) + // PTYP // Integer (DWORD) + // ControlBuffer // Package + // } + // + Method(PDRT,,,,PkgObj) + { + \_SB.PCI0.B0D4.PCCC() // init global variable PCCX + If (\PWRS){ // check power source + PDAC() // AC table + } Else { + PDDC() // DC table + } + } // end Method(PDRT) + + Method(PDDC,,,,PkgObj) + { + Name(TMPD,Package() + { + Package() {80, \_SB.PCI0.B0D4, 0x09, Package () {0x00010001,0x80000000}}, // Package domain, PL2, target power from CPU PPM + Package() {60, \_SB.PCI0.B0D4, 0x09, Package () {0x00010000,0x80000000}}, // Package domain, PL1, target power from CPU PPM + Package() {55, \_SB.PCI0.B0D4, 0x09, Package () {0x00070000,1}}, // Package domain, Power Control Turbo Disable + Package() {50, \_SB.PCI0.B0D4, 0x09, Package () {0x00030000,0x80000000}}, // Imax Controls - 30A + Package() {50, \_SB.PCI0.B0D4, 0x00, Package () {0x00040000,2}}, // Core control - 2 cores + Package() {40, \_SB.PCI0.DPLY, 0x0A, Package () {0x00050000,60}}, // Display brightness - 60 + Package() {40, \_SB.PCI0.TMEM, 0x02, Package () {0x00010000,1000}}, // Memory domain, PL1, target power from TMEM.PPCC + Package() {30, \_SB.PCI0.B0D4, 0x00, Package () {0x00020000,80}}, // System Agent Thermal Device, target frequency - P State 80% + Package() {20, \_SB.PCI0.B0D4, 0x00, Package () {0x00020001,50}} // System Agent Thermal Device, target frequency - T State 50% + }) + + If(CondRefOf(\_PR.CBMI)){ + Switch(ToInteger(\_PR.CBMI)){ // use the boot index from PPM to choose the Power Limit values and copy them to local variables + case(0){ + If(LAnd(LGreaterEqual(\_PR.CLVL,1),LLessEqual(\_PR.CLVL,3))){ // copy PL0 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL20,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL10),Local1) // PL1 minimum power + } + } + case(1){ + If(LOr(LEqual(\_PR.CLVL,2),LEqual(\_PR.CLVL,3))){ // copy PL1 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL21,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL11),Local1) // PL1 minimum power + } + } + case(2){ + If(LEqual(\_PR.CLVL,3)){ // copy PL2 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL22,1),Local0) // PL2 minimum power + Store (\_SB.PCI0.B0D4.MIN4(\_PR.PL12),Local1) // PL1 minimum power + } + } + } + } + + // get the iMax value from the PCCC object and copy it to a local variable + Store (DerefOf(Index(DerefOf(Index(\_SB.PCI0.B0D4.PCCX,1)),0)),Local2) // CurrentLimitMinimum + + // update the first three packages with the values that we had to dynamically determine + // this section might have to be updated any time the PDRT is changed + Store(Local0,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 0)),3)),1)) // Package domain, PL2, target power from CPU PPM + Store(Local1,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 1)),3)),1)) // Package domain, PL1, target power from CPU PPM + Store(Local2,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 3)),3)),1)) // Imax Controls - 30A + + Return(TMPD) + } // Method(PDDC) + + Method(PDAC,,,,PkgObj) + { + Name(TMPD,Package() + { + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00010001,0x80000000}}, // Package domain, PL2, target power from CPU PPM + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00010000,0x80000000}}, // Package domain, PL1, target power from CPU PPM + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00070000,0}}, // Package domain, Power Control Turbo Enable + Package() {100, \_SB.PCI0.B0D4, 0x09, Package () {0x00030000,0x80000000}}, // Imax Controls - 30A + Package() {100, \_SB.PCI0.B0D4, 0x00, Package () {0x00040000,0x80000000}}, // Core control - cores from TCNT + Package() {100, \_SB.PCI0.DPLY, 0x0A, Package () {0x00050000,100}}, // Display brightness - 100% + Package() {100, \_SB.PCI0.TMEM, 0x02, Package () {0x00010000,5000}}, // Memory domain, PL1, target power from TMEM.PPCC + Package() {100, \_SB.PCI0.B0D4, 0x00, Package () {0x00020000,100}} // System Agent Thermal Device, target frequency - P State 0% + }) + + If(CondRefOf(\_PR.CBMI)){ + Switch(ToInteger(\_PR.CBMI)){ // use the boot index from PPM to choose the Power Limit values and copy them to local variables + case(0){ + If(LAnd(LGreaterEqual(\_PR.CLVL,1),LLessEqual(\_PR.CLVL,3))){ // copy PL0 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL20,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL10,1),Local1) // PL1 maximum power + } + } + case(1){ + If(LOr(LEqual(\_PR.CLVL,2),LEqual(\_PR.CLVL,3))){ // copy PL1 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL21,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL11,1),Local1) // PL1 maximum power + } + } + case(2){ + If(LEqual(\_PR.CLVL,3)){ // copy PL2 values + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL22,1),Local0) // PL2 maximum power + Store (\_SB.PCI0.B0D4.CPNU(\_PR.PL12,1),Local1) // PL1 maximum power + } + } + } + } + + // get the iMax value from the PCCC object and copy it to a local variable + Store (DerefOf(Index(DerefOf(Index(\_SB.PCI0.B0D4.PCCX,1)),1)),Local2) // CurrentLimitMaximum + + // update the first four packages with the values that we had to dynamically determine + // this section might have to be updated any time the PDRT is changed + Store(Local0,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 0)),3)),1)) // Package domain, PL2, target power from CPU PPM + Store(Local1,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 1)),3)),1)) // Package domain, PL1, target power from CPU PPM + Store(Local2,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 3)),3)),1)) // Imax Controls - 30A + Store(TCNT,Index(DeRefOf(Index (DeRefOf (Index (TMPD, 4)),3)),1)) // Core control - cores from TCNT + + Return(TMPD) + } // Method(PDAC) + + } // End IETM Device +} // End \_SB Scope + +// +// EC support code +// +Scope(\_SB.PCI0.LPCB.H_EC) // Open scope to Embedded Controller +{ + // + // Create a Mutex for PATx methods to prevent Sx resume race condition problems asscociated with EC commands. + // + Mutex(PATM, 0) + + // _QF1 (Query - Embedded Controller Query F1) + // + // Handler for EC generated SCI number F1. + // + // Arguments: (0) + // None + // Return Value: + // None + // + Method(_QF1) + { // Thermal sensor threshold crossing event handler + P8XH(0, 0xf1) + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)), Local0) + While(Local0) // Ensure that events occuring during execution + { // of this handler are not dropped + \_SB.PCI0.LPCB.H_EC.ECWT(0, RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)) // clear all status bits + If(And(Local0, 0x20, Local1)) + { // BIT5: Board Fan Inlet Temperature Sensor Threshold Crossed + Notify(\_SB.PCI0.LPCB.H_EC.TINL, 0x90) + } + If(And(Local0, 0x10, Local1)) + { // BIT4: Memory Temperature Sensor Threshold Crossed + Notify(\_SB.PCI0.TMEM, 0x90) + } + If(And(Local0, 0x8, Local1)) + { // BIT3: WWAN Board Temperature Sensor Threshold Crossed + Notify(\_SB.PCI0.LPCB.H_EC.TAMB, 0x90) + } + If(And(Local0, 0x4, Local1)) + { // BIT2: CPU VR Board Temperature Sensor Threshold Crossed + Notify(\_SB.PCI0.LPCB.H_EC.TSKN, 0x90) + } + If(And(Local0, 0x2, Local1)) + { // BIT1: SSD Board Temperature Sensor Threshold Crossed. + Notify(\_SB.PCI0.LPCB.H_EC.TEFN, 0x90) + } + // BIT0: Not used on Harris Beach. + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSSR)), Local0) + } + } +} // End \_SB.PCI0.LPCB.H_EC Scope + +// +// Processor files. +// +// AMI MODIFY BEGIN + //Include("B0d4Participant.asl") + Include("B0d4DppmPolicy.asl") + //Include("B0d4CtdpPolicy.asl") + //Include("B0d4LpmPolicy.asl") + #Include "../B0d4Participant.asl" + #Include "../B0d4CtdpPolicy.asl" + #Include "../B0d4LpmPolicy.asl" +// AMI MODIFY END + +// +// PCH files +// +// AMI MODIFY BEGIN + //Include("TpchParticipant.asl") + //Include("TpchDppmPolicy.asl") + #Include "../TpchParticipant.asl" + #Include "../TpchDppmPolicy.asl" +// AMI MODIFY END + +// +// These participants are used by DPPM policies. +// + Include("TAmbParticipant.asl") + // AMI MODIFY BEGIN + //Include("TAmbDppmPolicy.asl") + #Include "../TAmbDppmPolicy.asl" + // AMI MODIFY END + Include("TEfnParticipant.asl") + // AMI MODIFY BEGIN + //Include("TEfnDppmPolicy.asl") + #Include "../TEfnDppmPolicy.asl" + // AMI MODIFY END + Include("TFN1Participant.asl") + Include("TFN2Participant.asl") + Include("TMemParticipant.asl") + Include("TMemDppmPolicy.asl") + Include("TSknParticipant.asl") + Include("TSknDppmPolicy.asl") + // AMI MODIFY BEGIN + //Include("DplyParticipant.asl") + //Include("TPwrParticipant.asl") + #Include "../DplyParticipant.asl" + #Include "../TPwrParticipant.asl" + // AMI MODIFY END + Include("TInlParticipant.asl") + Include("TInlDppmPolicy.asl") + // AMI MODIFY BEGIN + //Include("WWANParticipant.asl") + //Include("WWANDppmPolicy.asl") + #Include "../WWANParticipant.asl" + #Include "../WWANDppmPolicy.asl" + // AMI MODIFY END +// +// DPPM support files +// + Include("Ertm.asl") + Include("Trt.asl") + Include("Art.asl") + // AMI MODIFY BEGIN + //Include("Dppm.asl") + #Include "../Dppm.asl" + // AMI MODIFY END + +} // End SSDT diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Ertm.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Ertm.asl new file mode 100644 index 0000000..d92ce41 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Ertm.asl @@ -0,0 +1,53 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Ertm.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.IETM) +{ + // ETRM (Intel DPTF Participant List) + // + // The ETRM object evaluates to a package of packages each of which describes one participant device. + // + Name(ETRM, Package() + { // TODO: Replace with system-specific ETRM data here + Package() {\_SB.PCI0.TMEM, "INT3402", 0x06, "0"}, // Memory Device + Package() {\_SB.PCI0.LPCB.H_EC.TSKN, "INT3403", 0x06, "0"}, // CPU VR Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TAMB, "INT3403", 0x06, "1"}, // WWAN Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TEFN, "INT3403", 0x06, "3"}, // SSD Board Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TINL, "INT3403", 0x06, "5"}, // Board Fan Inlet Temperature Sensor + Package() {\_SB.PCI0.LPCB.H_EC.TPWR, "INT3407", 0x06, "0"}, // Platform Power Device + Package() {\_SB.PCI0.LPCB.H_EC.TFN1, "INT3404", 0x06, "0"}, // Fan Control Device + Package() {\_SB.PCI0.LPCB.H_EC.TFN2, "INT3404", 0x06, "1"}, // Fan Control Device + Package() {\_SB.PCI0.DPLY, "INT3406", 0x06, "0"}, // Display Participant Device + Package() {\_SB.PCI0.B0D4, "8086_0A03", 0x00, "0x00040000"}, // HSW ULT SA Thermal Device + Package() {\_SB.PCI0.TPCH, "8086_9C24", 0x00, "0x001F0006"}, // LPT ULT PCH Thermal Device + Package() {\_SB.PCI0.B0D4, "8086_0D03", 0x00, "0x00040000"} // CRW SA Thermal Device + }) +} + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TAmbParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TAmbParticipant.asl new file mode 100644 index 0000000..c9bb332 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TAmbParticipant.asl @@ -0,0 +1,184 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TambParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TAMB) // Ambient temperature sensor + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 1) + + Name(HITP, 0x64) + Name(AAUX, 0x10) + Name(_STR, Unicode ("WWAN Board Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(WWSD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP,0,Serialized) + { + If(\ECON) + { + // Get the Ambient Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.AMBT)))) + } Else { + Return(3000) + } + } + + // Returns Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),AAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x3, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(AAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x3, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TAMB, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TAMB Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TEfnParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TEfnParticipant.asl new file mode 100644 index 0000000..2907303 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TEfnParticipant.asl @@ -0,0 +1,184 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TEFNParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TEFN) + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 3) + + Name(HITP, 0x64) + Name(EAUX, 0x10) + Name(_STR, Unicode ("SSD Board Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(SSDD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP, 0, Serialized) + { + If(\ECON) + { + // Get the Exhaust Fan Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.FANT)))) + } Else { + Return(3000) + } + } + + // Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),EAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x1, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(EAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x1, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TEFN, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TEFN Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN1Participant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN1Participant.asl new file mode 100644 index 0000000..b76893e --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN1Participant.asl @@ -0,0 +1,172 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TFN1Participant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TFN1) + { + Name(_HID, EISAID("INT3404")) // Intel DPTF Fan Device + Name(_UID, 0) + Name(_STR, Unicode ("CPU Fan #1")) + + Name(FON, 1) // Indicates if Fan is ON Currently + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(FND1,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _FIF (Fan Information) + // + // The optional _FIF object provides OSPM with fan device capability information. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing the fan device parameters. + // + Method(_FIF) + { + Return (Package (){ + 0, // Revision:Integer + 1, // FineGrainControl:Integer Boolean + 2, // StepSize:Integer DWORD + 0 // LowSpeedNotificationSupport:Integer Boolean + }) + } + + // _FPS (Fan Performance States) + // + // Evaluates to a variable-length package containing a list of packages that describe the fan device's performance states. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Packages that describe the fan device's performance states. + // + Method(_FPS,,,,PkgObj) + { + Return (Package() + { + 0, // Revision:Integer + // Control, TripPoint, Speed, NoiseLevel, Power + Package(){100, 0xFFFFFFFF, 7000, 500, 5000}, + Package(){ 95, 0xFFFFFFFF, 6650, 475, 4750}, + Package(){ 90, 0xFFFFFFFF, 6300, 450, 4500}, + Package(){ 85, 0xFFFFFFFF, 5950, 425, 4250}, + Package(){ 80, 0xFFFFFFFF, 5600, 400, 4000}, + Package(){ 75, 0xFFFFFFFF, 5250, 375, 3750}, + Package(){ 70, 0xFFFFFFFF, 4900, 350, 3500}, + Package(){ 60, 0xFFFFFFFF, 4200, 300, 3000}, + Package(){ 50, 0xFFFFFFFF, 3500, 250, 2500}, + Package(){ 40, 0xFFFFFFFF, 2800, 200, 2000}, + Package(){ 25, 0xFFFFFFFF, 1750, 125, 1250}, + Package(){ 0, 0xFFFFFFFF, 0, 0, 0} // OFF + }) + } + + // _FSL (Fan Set Level) + // + // The optional _FSL object is a control method that OSPM evaluates to set a fan device's speed (performance state) to a specific level. + // + // Arguments: (1) + // Arg0 - Level (Integer): conveys to the platform the fan speed level to be set. + // Return Value: + // None + // + // Argument Information + // Arg0: Level. If the fan supports fine-grained control, Level is a percentage of maximum level (0-100) + // that the platform is to engage the fan. If the fan does not support fine-grained control, + // Level is a Control field value from a package in the _FPS object's package list. + // A Level value of zero causes the platform to turn off the fan. + // + Method(_FSL,1,Serialized) + { + If(\ECON) + { + \_SB.PCI0.LPCB.H_EC.ECWT(1, RefOf(\_SB.PCI0.LPCB.H_EC.PPSL)) + \_SB.PCI0.LPCB.H_EC.ECWT(0, RefOf(\_SB.PCI0.LPCB.H_EC.PPSH)) + \_SB.PCI0.LPCB.H_EC.ECWT(ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), RefOf(\_SB.PCI0.LPCB.H_EC.PINV)) + \_SB.PCI0.LPCB.H_EC.ECWT(Arg0, RefOf(\_SB.PCI0.LPCB.H_EC.PENV)) + \_SB.PCI0.LPCB.H_EC.ECWT(100, RefOf(\_SB.PCI0.LPCB.H_EC.PSTP)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x1a) // Command to turn the fan on + Notify(\_SB.IETM, 0x83) // Notify DPTF TZ that fan speed has changed + + // Notify OSPM on Fan Speed Changes via DPTF + Store(Arg0, Index(\_TZ.FAN0._FST, 1)) + Notify(\_TZ.FAN0, 0x80) + } + } + + Name(TFST, Package() + { + 0, // Revision:Integer + 0xFFFFFFFF, // Control:Integer DWORD + 0xFFFFFFFF // Speed:Integer DWORD + }) + + //_FST (Fan Status) + // + // The optional _FST object provides status information for the fan device. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing fan device status information + // + Method(_FST,,,,PkgObj) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), Index(TFST, 1)) + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.CFSP)), Index(TFST, 2)) + Return(TFST) + } + + } // End TFN1 Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN2Participant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN2Participant.asl new file mode 100644 index 0000000..82a36d4 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TFN2Participant.asl @@ -0,0 +1,166 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TFN2Participant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TFN2) + { + Name(_HID, EISAID("INT3404")) // Intel DPTF Fan Device + Name(_UID, 1) + Name(_STR, Unicode ("CPU Fan #2")) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(FND2,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _FIF (Fan Information) + // + // The optional _FIF object provides OSPM with fan device capability information. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing the fan device parameters. + // + Method(_FIF) + { + Return (Package (){ + 0, // Revision:Integer + 1, // FineGrainControl:Integer Boolean + 2, // StepSize:Integer DWORD + 0 // LowSpeedNotificationSupport:Integer Boolean + }) + } + + // _FPS (Fan Performance States) + // + // Evaluates to a variable-length package containing a list of packages that describe the fan device's performance states. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Packages that describe the fan device's performance states. + // + Method(_FPS,,,,PkgObj) + { + Return (Package() + { + 0, // Revision:Integer + // Control, TripPoint, Speed, NoiseLevel, Power + Package(){100, 0xFFFFFFFF, 7000, 500, 5000}, + Package(){ 95, 0xFFFFFFFF, 6650, 475, 4750}, + Package(){ 90, 0xFFFFFFFF, 6300, 450, 4500}, + Package(){ 85, 0xFFFFFFFF, 5950, 425, 4250}, + Package(){ 80, 0xFFFFFFFF, 5600, 400, 4000}, + Package(){ 75, 0xFFFFFFFF, 5250, 375, 3750}, + Package(){ 70, 0xFFFFFFFF, 4900, 350, 3500}, + Package(){ 60, 0xFFFFFFFF, 4200, 300, 3000}, + Package(){ 50, 0xFFFFFFFF, 3500, 250, 2500}, + Package(){ 40, 0xFFFFFFFF, 2800, 200, 2000}, + Package(){ 25, 0xFFFFFFFF, 1750, 125, 1250}, + Package(){ 0, 0xFFFFFFFF, 0, 0, 0} // OFF + }) + } + + // _FSL (Fan Set Level) + // + // The optional _FSL object is a control method that OSPM evaluates to set a fan device's speed (performance state) to a specific level. + // + // Arguments: (1) + // Arg0 - Level (Integer): conveys to the platform the fan speed level to be set. + // Return Value: + // None + // + // Argument Information + // Arg0: Level. If the fan supports fine-grained control, Level is a percentage of maximum level (0-100) + // that the platform is to engage the fan. If the fan does not support fine-grained control, + // Level is a Control field value from a package in the _FPS object's package list. + // A Level value of zero causes the platform to turn off the fan. + // + Method(_FSL,1,Serialized) + { + If(\ECON) + { + \_SB.PCI0.LPCB.H_EC.ECWT(2, RefOf(\_SB.PCI0.LPCB.H_EC.PPSL)) + \_SB.PCI0.LPCB.H_EC.ECWT(0, RefOf(\_SB.PCI0.LPCB.H_EC.PPSH)) + \_SB.PCI0.LPCB.H_EC.ECWT(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), RefOf(\_SB.PCI0.LPCB.H_EC.PINV)) + \_SB.PCI0.LPCB.H_EC.ECWT(Arg0, RefOf(\_SB.PCI0.LPCB.H_EC.PENV)) + \_SB.PCI0.LPCB.H_EC.ECWT(100, RefOf(\_SB.PCI0.LPCB.H_EC.PSTP)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x1a) // Command to turn the fan on + Notify(\_SB.IETM, 0x83) // Notify DPTF TZ that fan speed has changed + } + } + + Name(TFST, Package() + { + 0, // Revision:Integer + 0xFFFFFFFF, // Control:Integer DWORD + 0xFFFFFFFF // Speed:Integer DWORD + }) + + //_FST (Fan Status) + // + // The optional _FST object provides status information for the fan device. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing fan device status information + // + Method(_FST,,,,PkgObj) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), Index(TFST, 1)) + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.CFS2)), Index(TFST, 2)) + Return(TFST) + } + + } // End TFN2 Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlDppmPolicy.asl new file mode 100644 index 0000000..b4d1db3 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlDppmPolicy.asl @@ -0,0 +1,140 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TInlDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.TINL) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.TINL, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(IFPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(IFAT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT, 0, Serialized) + { + Return(\_SB.IETM.CTOK(IFCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(IFHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV, 0, Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(IFAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(IFPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.TINL) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlParticipant.asl new file mode 100644 index 0000000..45b85eb --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TInlParticipant.asl @@ -0,0 +1,186 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + InltParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TINL) + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 5) + + Name(HITP, 0x64) + Name(SAUX, 0x10) + Name(_STR, Unicode ("Board Fan Inlet Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(INLD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP) + { + If(\ECON) + { + Store(\_SB.PCI0.LPCB.H_EC.DIM1,Local1) // DIMM1 temperature + Return(\_SB.IETM.CTOK(Local1)) // EC reports in Celcius, convert to 10ths of degree Kelvin + } + Else + { + Return(3000) + } + } + + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x5, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x5, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TINL, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TINL Device + +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemDppmPolicy.asl new file mode 100644 index 0000000..440107c --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemDppmPolicy.asl @@ -0,0 +1,188 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TMemDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.TMEM) +{ + Name(CTYP,0) // Device-specific cooling policy preference + Name(AHYS,50) // Active Cooling Hysteresis configuration. Use this in conjuction with GTSH to define _ACx hysteresis points. (in 1/10 of K) + Name(AC1D,30) // _AC1 Delta from _AC0 (in 1/10 of K) + Name(AC2D,60) // _AC2 Delta from _AC0 (in 1/10 of K) + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT) + { + Return(\_SB.IETM.CTOK(MEMC)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(MEMH)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV) + { + Return(\_SB.IETM.CTOK(PTRA)) + } + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + Store(\_SB.IETM.CTOK(ATRA),Local1) + + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + Store(\_SB.IETM.CTOK(ATRA),Local0) // Active Cooling Policy + Subtract(Local0, AC1D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC2) + { + Store(\_SB.IETM.CTOK(ATRA),Local0) // Active Cooling Policy + Subtract(Local0, AC2D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } +} // End Scope(\_SB.PCI0.TMEM) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemParticipant.asl new file mode 100644 index 0000000..7ed96cd --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TMemParticipant.asl @@ -0,0 +1,252 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TMemParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0) +{ + + Device(TMEM) + { + Name(_HID, EISAID("INT3402")) // Intel DPTF Memory Device + Name(_UID, 0) + + Name(HITP, 0x64) + Name(SAUX, 0x10) + Name(_STR, Unicode ("Memory Participant")) + Name(LSTM,0) // Last temperature reported + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(MEMD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // PPCC (Participant Power Control Capabilities) + // + // The PPCC object evaluates to a package of packages that indicates to DPTF processor + // participant the power control capabilities. + // + // Arguments: (0) + // None + // Return Value: + // PPCC package of packages + // + Method(PPCC,0,Serialized,,PkgObj) + { + Return(NPCC) + } + + Name (NPCC, Package() + { // Field Name : Field Type + 2, // Revision : DWordConst + + Package () // Power Limit 1 + { + 0, // PowerLimitIndex : DWordConst = 0 + 1000, // PowerLimitMinimum : DWordConst + 5000, // PowerLimitMaximum : DWordConst + 1, // TimeWindowMinimum : DWordConst + 28, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + }, + Package () // Power Limit 2 + { + 1, // PowerLimitIndex : DWordConst = 1 + 1000, // PowerLimitMinimum : DWordConst + 10000, // PowerLimitMaximum : DWordConst + 0, // TimeWindowMinimum : DWordConst + 0, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + } + }) // End of PPCC object + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP) + { + If(\ECON) + { + If(\TSOD) // if TS-on-DIMM sensor present and selected in BIOS SETUP return higher temp + { + If(LGreater(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD0)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD1)))) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD0)),Local1) // TS-on-DIMM0 temperature + } + Else + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD1)),Local1) // TS-on-DIMM1 temperature + } + } + Else // else return higher On-Board DDR Thermal Sensor temp + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.DIM0)),Local1) // DIMM0 temperature + } + Return(\_SB.IETM.CTOK(Local1)) // EC reports in Celcius, convert to 10ths of degree Kelvin + } + Else + { + Return(3000) + } + } + + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x4, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x4, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TMEM, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + // PGMB (Pci GMch Bar) + // + // This object is required to be implemented on platforms supporting Intel code name Sandy Bridge processor. + // This object is not required for platforms supporting Intel code name Ivy Bridge processor. + // + // Arguments: (0) + // None + // Return Value: + // Return MCH Bar value. + // + Method(PGMB, 0) + { + Return(\_SB.PCI0.MHBR) // Return MCH Bar value + } + + } // End TMEM Device + +}// end Scope(\_SB.PCI0) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknDppmPolicy.asl new file mode 100644 index 0000000..f1fccab --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknDppmPolicy.asl @@ -0,0 +1,190 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TSknDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.TSKN) +{ + Name(CTYP,0) // Device-specific cooling policy preference + Name(AHYS,30) // Active Cooling Hysteresis configuration. Use this in conjuction with GTSH to define _ACx hysteresis points. (in 1/10 of K) + Name(AC1D,30) // _AC1 Delta from _AC0 (in 1/10 of K) + Name(AC2D,60) // _AC2 Delta from _AC0 (in 1/10 of K) + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP,3,Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.TSKN, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + Store(\_SB.IETM.CTOK(SKAT),Local1) + + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + Store(\_SB.IETM.CTOK(SKAT),Local0) // Active Cooling Policy + Subtract(Local0, AC1D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC2) + { + Store(\_SB.IETM.CTOK(SKAT),Local0) // Active Cooling Policy + Subtract(Local0, AC2D, Local1) + If(LGreaterEqual(LSTM,Local1)) + { + Subtract(AHYS, GTSH, Local2) + Subtract(Local1, Local2, Local3) // Include Hysteresis + Return(Local3) + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT) + { + Return(\_SB.IETM.CTOK(SKCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SKHT) ) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV) + { + Return(\_SB.IETM.CTOK(SKPT)) // Passive Cooling Policy + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.TSKN) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknParticipant.asl new file mode 100644 index 0000000..b2c2859 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/TSknParticipant.asl @@ -0,0 +1,183 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TSknParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TSKN) // Skin temperature sensor + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 0) + + Name(HITP, 0x64) + Name(SAUX, 0x10) + Name(_STR, Unicode ("CPU VR Board Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(CVSD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP,0,Serialized) + { + If(\ECON) + { // Get the Skin Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.SKNT)))) + } Else { + Return(3000) + } + } + + // Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + // Set High Trip to PSV or ACT + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TSKN, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TSKN Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Trt.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Trt.asl new file mode 100644 index 0000000..6dcd130 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Ffrd/Trt.asl @@ -0,0 +1,86 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Trt.asl + +Abstract: + + Intel ACPI Reference Code for Intel Dynamic Power Performance Management + +--*/ + +Scope(\_SB.IETM) +{ + + Name(TRT0, Package() + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 10, 100, 0, 0, 0, 0}, + + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 50, 0, 0, 0, 0}, + + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 300, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 300, 0, 0, 0, 0}, + + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TINL, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TINL, 20, 200, 0, 0, 0, 0} + }) + + // TRTR (Thermal Relationship Table Revision) + // + // This object evaluates to an integer value that defines the revision of the _TRT object. + // + // Arguments: (0) + // None + // Return Value: + // 0: Traditional TRT as defined by the ACPI Specification. + // 1: Priority based TRT + // + Method(TRTR) + { + Return(TRTV) + } + + // _TRT (Thermal Relationship Table) + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of Thermal Relationship Packages as described below. + // + // Return Value Information + // Package { + // ThermalRelationship[0] // Package + // ... + // ThermalRelationship[n] // Package + // } + // + Method(_TRT,,,,PkgObj) + { + Return(TRT0) + } // End _TRT +} + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbDppmPolicy.asl new file mode 100644 index 0000000..8546d23 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbDppmPolicy.asl @@ -0,0 +1,140 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TamdDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.TAMB) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.TAMB, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(AMPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(AMAT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT, 0, Serialized) + { + Return(\_SB.IETM.CTOK(AMCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(AMHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV, 0, Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(AMAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(AMPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.TAMB) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbParticipant.asl new file mode 100644 index 0000000..f7a91b9 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TAmbParticipant.asl @@ -0,0 +1,184 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TambParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TAMB) // Ambient temperature sensor + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 1) + + Name(HITP, 0x64) + Name(AAUX, 0x10) + Name(_STR, Unicode ("Ambience Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(AMBD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP,0,Serialized) + { + If(\ECON) + { + // Get the Ambient Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.AMBT)))) + } Else { + Return(3000) + } + } + + // Returns Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),AAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x3, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(AAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x3, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TAMB, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TAMB Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnDppmPolicy.asl new file mode 100644 index 0000000..9f696d1 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnDppmPolicy.asl @@ -0,0 +1,179 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TEFNDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.TEFN) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.TEFN, 0x91) + } + } + + // Returns the value at which the OS initiates Active + // cooling. + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(EFPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(EFAT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + Return(Subtract(_AC0(), 50)) + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC2) + { + Return(Subtract(_AC1(), 50)) + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC3) + { + Return(Subtract(_AC2(), 50)) + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT, 0, Serialized) + { + Return(\_SB.IETM.CTOK(EFCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(EFHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV, 0, Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(EFAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(EFPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.TEFN) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnParticipant.asl new file mode 100644 index 0000000..ad61fdb --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TEfnParticipant.asl @@ -0,0 +1,184 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TEFNParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TEFN) + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 3) + + Name(HITP, 0x64) + Name(EAUX, 0x10) + Name(_STR, Unicode ("Exhaust Fan Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(EFDE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP, 0, Serialized) + { + If(\ECON) + { + // Get the Exhaust Fan Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.FANT)))) + } Else { + Return(3000) + } + } + + // Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),EAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x1, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(EAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x1, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TEFN, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TEFN Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN1Participant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN1Participant.asl new file mode 100644 index 0000000..a119363 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN1Participant.asl @@ -0,0 +1,170 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TFN1Participant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TFN1) + { + Name(_HID, EISAID("INT3404")) // Intel DPTF Fan Device + Name(_UID, 0) + + Name(FON, 1) // Indicates if Fan is ON Currently + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(FND1,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _FIF (Fan Information) + // + // The optional _FIF object provides OSPM with fan device capability information. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing the fan device parameters. + // + Method(_FIF) + { + Return (Package (){ + 0, // Revision:Integer + 1, // FineGrainControl:Integer Boolean + 2, // StepSize:Integer DWORD + 0 // LowSpeedNotificationSupport:Integer Boolean + }) + } + + // _FPS (Fan Performance States) + // + // Evaluates to a variable-length package containing a list of packages that describe the fan device's performance states. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Packages that describe the fan device's performance states. + // + Method(_FPS,,,,PkgObj) + { + Return (Package() + { + 0, // Revision:Integer + // Control, TripPoint, Speed, NoiseLevel, Power + Package(){100, 0xFFFFFFFF, 7000, 500, 5000}, + Package(){ 95, 0xFFFFFFFF, 6650, 475, 4750}, + Package(){ 90, 0xFFFFFFFF, 6300, 450, 4500}, + Package(){ 85, 0xFFFFFFFF, 5950, 425, 4250}, + Package(){ 80, 0xFFFFFFFF, 5600, 400, 4000}, + Package(){ 75, 0xFFFFFFFF, 5250, 375, 3750}, + Package(){ 70, 0xFFFFFFFF, 4900, 350, 3500}, + Package(){ 60, 0xFFFFFFFF, 4200, 300, 3000}, + Package(){ 50, 0xFFFFFFFF, 3500, 250, 2500}, + Package(){ 40, 0xFFFFFFFF, 2800, 200, 2000}, + Package(){ 25, 0xFFFFFFFF, 1750, 125, 1250}, + Package(){ 0, 0xFFFFFFFF, 0, 0, 0} // OFF + }) + } + + // _FSL (Fan Set Level) + // + // The optional _FSL object is a control method that OSPM evaluates to set a fan device's speed (performance state) to a specific level. + // + // Arguments: (1) + // Arg0 - Level (Integer): conveys to the platform the fan speed level to be set. + // Return Value: + // None + // + // Argument Information + // Arg0: Level. If the fan supports fine-grained control, Level is a percentage of maximum level (0-100) + // that the platform is to engage the fan. If the fan does not support fine-grained control, + // Level is a Control field value from a package in the _FPS object's package list. + // A Level value of zero causes the platform to turn off the fan. + // + Method(_FSL,1,Serialized) + { + If(\ECON) + { + If(LNot(LEqual(Arg0,\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV))))) + { // EC implementation-sepcific PWM port control + \_SB.PCI0.LPCB.H_EC.ECWT(1, RefOf(\_SB.PCI0.LPCB.H_EC.PPSL)) + \_SB.PCI0.LPCB.H_EC.ECWT(0, RefOf(\_SB.PCI0.LPCB.H_EC.PPSH)) + \_SB.PCI0.LPCB.H_EC.ECWT(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), RefOf(\_SB.PCI0.LPCB.H_EC.PINV)) + \_SB.PCI0.LPCB.H_EC.ECWT(Arg0, RefOf(\_SB.PCI0.LPCB.H_EC.PENV)) + \_SB.PCI0.LPCB.H_EC.ECWT(100, RefOf(\_SB.PCI0.LPCB.H_EC.PSTP)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x1a) // Command to turn the fan on + Notify(\_SB.IETM, 0x83) // Notify DPTF TZ that fan speed has changed + } + } + } + + Name(TFST, Package() + { + 0, // Revision:Integer + 0xFFFFFFFF, // Control:Integer DWORD + 0xFFFFFFFF // Speed:Integer DWORD + }) + + //_FST (Fan Status) + // + // The optional _FST object provides status information for the fan device. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing fan device status information + // + Method(_FST,,,,PkgObj) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PENV)), Index(TFST, 1)) + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.CFSP)), Index(TFST, 2)) + Return(TFST) + } + + } // End TFN1 Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN2Participant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN2Participant.asl new file mode 100644 index 0000000..c585e72 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TFN2Participant.asl @@ -0,0 +1,167 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TFN2Participant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TFN2) + { + Name(_HID, EISAID("INT3404")) // Intel DPPM Fan Device 2 DUMMY DEVICE + Name(_UID, 1) + + Name(FCTL, 100) + Name(FSPD, 200) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(FND2,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _FIF (Fan Information) + // + // The optional _FIF object provides OSPM with fan device capability information. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing the fan device parameters. + // + Name(_FIF, Package() + { + 0, + 1, + 50, + 0 + }) + + // _FPS (Fan Performance States) + // + // Evaluates to a variable-length package containing a list of packages that describe the fan device's performance states. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a Revision ID and a list of Packages that describe the fan device's performance states. + // + Method(_FPS,,,,PkgObj) // Get Fan P-States + { + // Get Fan Device Data default as CRB + Return (Package() + { + 0, // Revision + // + // Control Trip Point Speed NoiseLevel Power + Package(){100, 0xFFFFFFFF, 200, 700, 7000}, + Package(){ 50, 0xFFFFFFFF, 100, 350, 3500}, + Package(){ 0, 0xFFFFFFFF, 0, 0, 0} // OFF + }) + } + + // _FSL (Fan Set Level) + // + // The optional _FSL object is a control method that OSPM evaluates to set a fan device's speed (performance state) to a specific level. + // + // Arguments: (1) + // Arg0 - Level (Integer): conveys to the platform the fan speed level to be set. + // Return Value: + // None + // + // Argument Information + // Arg0: Level. If the fan supports fine-grained control, Level is a percentage of maximum level (0-100) + // that the platform is to engage the fan. If the fan does not support fine-grained control, + // Level is a Control field value from a package in the _FPS object's package list. + // A Level value of zero causes the platform to turn off the fan. + // + Method(_FSL, 1, Serialized) + { + If(\ECON) + { + If(LNot(LEqual(Arg0, FCTL))) + { + Store(Arg0, FCTL) + If (LGreaterEqual(Arg0, 51)) + { + Store(200, FSPD) + } + If (LGreaterEqual(Arg0, 1)) + { + Store(100, FSPD) + } + Else + { + Store(0, FSPD) + } + } + } + } + + Name(TFST, Package() + { + 0, // Revision + 0xFFFFFFFF, // Control + 0xFFFFFFFF // Speed + }) + + //_FST (Fan Status) + // + // The optional _FST object provides status information for the fan device. + // + // Arguments: (0) + // None + // Return Value: + // A Package containing fan device status information + // + Method(_FST,,,,PkgObj) + { + Store(FCTL, Index(TFST, 1)) + Store(FSPD, Index(TFST, 2)) + Return(TFST) + } + } // End TFN2 Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemDppmPolicy.asl new file mode 100644 index 0000000..c01d155 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemDppmPolicy.asl @@ -0,0 +1,173 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TMemDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.TMEM) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT) + { + Return(\_SB.IETM.CTOK(MEMC)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(MEMH)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(ATRA)) // Passive Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(PTRA)) // Active Cooling Policy + } + } + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(TMEM, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTRA),Local1) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATRA),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTRA),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATRA),Local0) // Active Cooling Policy + } + Subtract(Local0, 50, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return(Subtract(Local0,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local0) + } + } +} // End Scope(\_SB.PCI0.TMEM) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemParticipant.asl new file mode 100644 index 0000000..0520b32 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TMemParticipant.asl @@ -0,0 +1,264 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TMemParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0) +{ + + Device(TMEM) + { + Name(_HID, EISAID("INT3402")) // Intel DPTF Memory Device + Name(_UID, 0) + + Name(SAUX, 0x10) + Name(LSTM,0) // Last temperature reported + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(MEMD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // PPCC (Participant Power Control Capabilities) + // + // The PPCC object evaluates to a package of packages that indicates to DPTF processor + // participant the power control capabilities. + // + // Arguments: (0) + // None + // Return Value: + // PPCC package of packages + // + Method(PPCC,0,Serialized,,PkgObj) + { + Return(NPCC) + } + + Name (NPCC, Package() + { // Field Name : Field Type + 2, // Revision : DWordConst + + Package () // Power Limit 1 + { + 0, // PowerLimitIndex : DWordConst = 0 + 1000, // PowerLimitMinimum : DWordConst + 5000, // PowerLimitMaximum : DWordConst + 1, // TimeWindowMinimum : DWordConst + 28, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + }, + Package () // Power Limit 2 + { + 1, // PowerLimitIndex : DWordConst = 1 + 1000, // PowerLimitMinimum : DWordConst + 10000, // PowerLimitMaximum : DWordConst + 0, // TimeWindowMinimum : DWordConst + 0, // TimeWindowMaximum : DWordConst + 1000, // StepSize : DWordConst + } + }) // End of PPCC object + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP) + { + If(\ECON) + { + If(\TSOD) // if TS-on-DIMM sensor present and selected in BIOS SETUP return higher temp + { + If(LGreater(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD0)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD1)))) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD0)),Local1) // TS-on-DIMM0 temperature + } + Else + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.TSD1)),Local1) // TS-on-DIMM1 temperature + } + } + Else // else return higher On-Board DDR Thermal Sensor temp + { + If(LGreater(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.DIM0)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.DIM1)))) + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.DIM0)),Local1) // DIMM0 temperature + } + Else + { + Store(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.DIM1)),Local1) // DIMM1 temperature + } + } + Return(\_SB.IETM.CTOK(Local1)) // EC reports in Celcius, convert to 10ths of degree Kelvin + } + Else + { + Return(3000) + } + } + + Name(PATC, 2) + + Name(AT0, Ones) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1) // send Arg0 to EC as Programmable Auxiliary Trip Point 0 + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(Arg0, AT0) // used for debugging + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x4, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) // Thermal Sensor Hysteresis, 2 degrees + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + Name(AT1, Ones) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1) // send Arg0 to EC as Programmable Auxiliary Trip Point 1 + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(Arg0, AT1) // used for debugging + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x4, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) // Thermal Sensor Hysteresis, 2 degrees + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TMEM, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + // PGMB (Pci GMch Bar) + // + // This object is required to be implemented on platforms supporting Intel code name Sandy Bridge processor. + // This object is not required for platforms supporting Intel code name Ivy Bridge processor. + // + // Arguments: (0) + // None + // Return Value: + // Return MCH Bar value. + // + Method(PGMB, 0) + { + Return(\_SB.PCI0.MHBR) // Return MCH Bar value + } + + } // End TMEM Device + +}// end Scope(\_SB.PCI0) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TPwrParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TPwrParticipant.asl new file mode 100644 index 0000000..07532b8 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TPwrParticipant.asl @@ -0,0 +1,260 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TPwrParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + + +Scope(\_SB.IETM) +{ + // + // Power Policy + // + Name (WPSP, Package () + { + ToUUID("64568CCD-6597-4BFC-B9D6-9D33854013CE") + }) +} + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TPWR) // Power participant + { + Name(_HID, EISAID("INT3407")) //Intel DPTF platform power device + Name(_UID, 0) + Name(_STR, Unicode ("Platform Power")) + Name(PTYP, 0x11) + + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(PWRE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _BST (Battery Status) + // + // Arguments: (0) + // None + // Return Value: + // A Package containing the battery status in the format below: + // Package { + // Battery State + // Battery Present Rate + // Battery Remaining Capacity + // Battery Present Voltage + // } + // + Method(_BST,,,,PkgObj) + { + If(CondRefOf(\_SB.PCI0.LPCB.H_EC.BAT1._BST)) + { + Return(\_SB.PCI0.LPCB.H_EC.BAT1._BST()) + } Else { + Return(Package(){0,0,0,0}) + } + } + + // PSOC (Platform State of Charge) + // + // This object evaluates to the remaining battery state of charge in %. + // + // Arguments: (0) + // None + // Return Value: + // remaining battery charge in % + // + Method(PSOC) + { + If(LEqual(\_SB.PCI0.LPCB.H_EC.ECAV,0)) // check EC opregion available + { + Return (0) // EC not available + } + If(LEqual(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)),0)) // prevent divide by zero + { + Return (0) // Full charge cannot be 0, indicate malfunction in battery + } + If(LGreater(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1RC)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)))) // remaining charge > full charge + { + Return(0) // Remaining Charge cannot be greater than Full Charge, this illegal value indicates the battery is malfunctioning + } + If(LEqual(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1RC)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)))) // remaining charge == full charge + { + Return(100) // indicate battery is fully charged + } + If(LLess(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1RC)),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)))) // (RC*100)/FC=percent + { + Multiply(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1RC)),100,Local0) // RC*100 + Divide(Local0,\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)),Local2,Local1) // divide by FC + Divide(Local2,100,,Local2) // account for the remainder in percent + Divide(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1FC)),200,,Local3) // what number is 0.5%? + If(LGreaterEqual(Local2,Local3)){ // round up if the remainder is equal or above .5 + Add(Local1,1,Local1) + } + Return(Local1) // current charge in percent + } + } + + // PMAX (Platform MAXimum) + // + // The PMAX object provides maximum power that can be supported by the battery in mW. + // + // Arguments: (0) + // None + // Return Value: + // maximum power in mW + // + Method(PMAX,0,Serialized) + { + If(LEqual(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.ECAV)),1)) // Check If EC opregion is available + { + // convert PMAX from signed to unsigned integer + // PMAX Value = (NOT(OR(FFFF0000, ECValue))+1) * 10. + Add(ShiftLeft(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1MH)), 8),\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.B1ML)),Local0) // Get high and low byte from EC. + If(Local0){ // don't convert a zero + Not(Or(0xFFFF0000,Local0,Local0),Local0) // make it a 32 bit value before inverting the bits + Multiply(Add(1,Local0,Local0),10,Local0) // add 1 and multiply by 10 + } + Return(Local0) + } Else { + Return(0) // EC not available + } + } + + + // APWR (Adapter PoWeR) + // + // Arguments: (0) + // None + // Return Value: + // AC Adapter supplied power in mW. + // + Method(APWR) + { + If (LEqual(PSRC(),0)) + { + Return(0) // EC unavailable or AC unavailable + } Else { + Return(Multiply(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.PPWR)),10)) + } + } + + + // PSRC (Power SouRCe) + // + // The PSRC object provides power source type. + // + // Arguments: (0) + // None + // Return Value: + // 0x00 = DC + // 0x01 = AC + // 0x02 = USB + // + Method(PSRC) + { + If(LEqual(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.ECAV)),1)) // Check If EC opregion is available + { + Return(\PWRS) // currently supports DC/AC only + } Else { + Return(0) // EC not available, default to battery + } + } + + // ARTG (Adapter RaTinG) + // + // The ARTG object provides AC adapter rating in mW. + // ARTG should return 0 if PSRC is DC (0). + // + // Arguments: (0) + // None + // Return Value: + // AC adapter rating in mW + // + Method(ARTG) + { + If (LEqual(PSRC(),0)) + { + Return(0) + } Else { +// TODO: setup option to choose adapter rating + Return(45000) // 45 watts + } + } + + + // CTYP (Charger TYPe) + // + // The CTYP object provides charger type. + // + // Arguments: (0) + // None + // Return Value: + // 0x01 = Traditional + // 0x02 = Hybrid + // + Method(CTYP) + { + Return(2) + } + + // PROP (Platform Rest Of worst case Power) + // + // The PROP object provides maximum worst case platform rest of power. + // + // Arguments: (0) + // None + // Return Value: + // power in mW + // + Method(PROP) + { + Return(15000) // 15 watts + } + + } // End TPWR Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknDppmPolicy.asl new file mode 100644 index 0000000..1187bf8 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknDppmPolicy.asl @@ -0,0 +1,172 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TSknDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.TSKN) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP,3,Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.TSKN, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC3) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(SKPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(SKAT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC4) + { + Return(Subtract(_AC3(), 50)) + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC5) + { + Return(Subtract(_AC3(), 100)) + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT) + { + Return(\_SB.IETM.CTOK(SKCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(SKHT) ) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(SKAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(SKPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.TSKN) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknParticipant.asl new file mode 100644 index 0000000..bb6586c --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TSknParticipant.asl @@ -0,0 +1,183 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TSknParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(TSKN) // Skin temperature sensor + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 0) + + Name(HITP, 0x64) + Name(SAUX, 0x10) + Name(_STR, Unicode ("Skin Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(SKDE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP,0,Serialized) + { + If(\ECON) + { // Get the Skin Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.SKNT)))) + } Else { + Return(3000) + } + } + + // Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),SAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(SAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + // Set High Trip to PSV or ACT + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) //Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TSKN, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End TSKN Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRDppmPolicy.asl new file mode 100644 index 0000000..d022df7 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRDppmPolicy.asl @@ -0,0 +1,140 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + T_VRDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC.T_VR) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.LPCB.H_EC.T_VR, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(VRPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(VRAT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT, 0, Serialized) + { + Return(\_SB.IETM.CTOK(VRCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(VRHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV, 0, Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(VRAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(VRPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.LPCB.H_EC.T_VR) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRParticipant.asl new file mode 100644 index 0000000..6ade5f0 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/T_VRParticipant.asl @@ -0,0 +1,184 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + T_VRParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.LPCB.H_EC) +{ + + Device(T_VR) // VR temperature sensor + { + Name(_HID, EISAID("INT3403")) // Intel DPTF Temperature Sensor Device + Name(_UID, 2) + + Name(HITP, 0x64) + Name(VAUX, 0x10) + Name(_STR, Unicode ("VR Temperature Sensor")) + Name(PTYP, 0x03) + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(VRDE,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + Method(_TMP, 0, Serialized) + { + If(\ECON) + { + // Get the CPU VR Temperature. + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.ECRD(RefOf(\_SB.PCI0.LPCB.H_EC.CVRT)))) + } Else { + Return(3000) + } + } + + // Returns Number of Aux Trips available + Name(PATC, 2) + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT0, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),VAUX) + \_SB.PCI0.LPCB.H_EC.ECWT(0x0, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(VAUX, RefOf(\_SB.PCI0.LPCB.H_EC.TSLT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // PATx (Participant Programmable Auxiliary Trip) - Sets Aux Trip Point + // + // The PATx objects shall take a single integer parameter, in tenths of degree Kelvin, which + // represents the temperature at which the device should notify the participant driver of + // an auxiliary trip event. A PATx control method returns no value. + // + // Arguments: (1) + // Arg0 - temperature in tenths of degree Kelvin + // Return Value: + // None + // + Method(PAT1, 1, Serialized) + { + If (\ECON) + { + Store (Acquire(\_SB.PCI0.LPCB.H_EC.PATM, 100),Local0) // save Acquire result so we can check for Mutex acquired + If (LEqual(Local0, Zero)) // check for Mutex acquired + { + Store(\_SB.IETM.KTOC(Arg0),HITP) + \_SB.PCI0.LPCB.H_EC.ECWT(0x0, RefOf(\_SB.PCI0.LPCB.H_EC.TSI)) + \_SB.PCI0.LPCB.H_EC.ECWT(0x2, RefOf(\_SB.PCI0.LPCB.H_EC.HYST)) + \_SB.PCI0.LPCB.H_EC.ECWT(HITP, RefOf(\_SB.PCI0.LPCB.H_EC.TSHT)) + \_SB.PCI0.LPCB.H_EC.ECMD(0x4A) // Set Trip point. + Release(\_SB.PCI0.LPCB.H_EC.PATM) + } + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(T_VR, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End T_VR Device +}// end Scope(\_SB.PCI0.LPCB.H_EC) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuDppmPolicy.asl new file mode 100644 index 0000000..2561099 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuDppmPolicy.asl @@ -0,0 +1,304 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TcpuDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.TCPU) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local1) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,Multiply(2, 10))) + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local0) // Active Cooling Policy + } + Subtract(Local0, 50, Local0) + + If(LGreaterEqual(LSTM,Local0)) + { + Return (Subtract(Local0, Multiply(2, 10))) + } + Else + { + Return(Local0) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC2) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local0) // Active Cooling Policy + } + Subtract(Local0, 100, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return (Subtract(Local0, Multiply(2, 10))) + } + Else + { + Return(Local0) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC3) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local0) // Active Cooling Policy + } + Subtract(Local0, 150, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return (Subtract(Local0, Multiply(2, 10))) + } + Else + { + Return(Local0) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC4) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local0) // Active Cooling Policy + } + Subtract(Local0, 200, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return (Subtract(Local0, Multiply(2, 10))) + } + Else + { + Return(Local0) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC5) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PSVT),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ACTT),Local0) // Active Cooling Policy + } + Subtract(Local0, 250, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return (Subtract(Local0, Multiply(2, 10))) + } + Else + { + Return(Local0) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT,0,Serialized) + { + Return(\_SB.IETM.CTOK(CRTT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(Subtract(CRTT, 3))) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV,0,Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(ACTT)) // Passive Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(PSVT)) // Active Cooling Policy + } + } + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.TCPU, 0x91) + } + } + +} // End Scope(\_SB.TCPU) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuParticipant.asl new file mode 100644 index 0000000..ac6e1cb --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TcpuParticipant.asl @@ -0,0 +1,423 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TcpuParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + + +Scope(\_SB) +{ + Device(TCPU) + { + External (PPCS) + + Name(_HID, EISAID("INT3401")) // Intel Dptf Processor Device, 1 per package + Name(_UID,0) + + Name(CINT,1) + Name(LSTM,0) // Last temperature reported + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(SADE,2)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // PGMB (Pci GMch Bar) + // + // This object is required to be implemented on platforms supporting Intel code name Sandy Bridge processor. + // This object is not required for platforms supporting Intel code name Ivy Bridge processor. + // + // Arguments: (0) + // None + // Return Value: + // Return MCH Bar value. + // + Method(PGMB, 0) + { + Return(\_SB.PCI0.MHBR) // Return MCH Bar value + } + + // _PPC (Performance Present Capabilities) + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the range of states supported + // 0 - States 0 through nth state are available (all states available) + // 1 - States 1 through nth state are available + // 2 - States 2 through nth state are available + // ... + // n - State n is available only + // + Name(_PPC,0) + + // SPPC (Set Participant Performance Capability) + // + // SPPC is a control method object that takes one integer parameter that will indicate the maximum allowable + // P-State for OSPM to use at any given time. + // + // Arguments: (1) + // Arg0 - integer + // Return Value: + // None + // + Method(SPPC,1,Serialized) + { + Store(Arg0, \_PR.CPU0._PPC) // Note: CPU0._PPC is an Integer not a Method + + If(CondRefOf(\_SB.PCCD.PENB)) { // is CPPC enabled in SETUP? + Notify(\_SB.PCCD,0x82) // CPPC notify + } Else { + Switch(ToInteger(TCNT)){ + Case(8){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + Notify(\_PR.CPU2, 0x80) // Tell CPU2 driver to re-eval _PPC + Notify(\_PR.CPU3, 0x80) // Tell CPU3 driver to re-eval _PPC + Notify(\_PR.CPU4, 0x80) // Tell CPU4 driver to re-eval _PPC + Notify(\_PR.CPU5, 0x80) // Tell CPU5 driver to re-eval _PPC + Notify(\_PR.CPU6, 0x80) // Tell CPU6 driver to re-eval _PPC + Notify(\_PR.CPU7, 0x80) // Tell CPU7 driver to re-eval _PPC + } + Case(4){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + Notify(\_PR.CPU2, 0x80) // Tell CPU2 driver to re-eval _PPC + Notify(\_PR.CPU3, 0x80) // Tell CPU3 driver to re-eval _PPC + } + Case(2){ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + Notify(\_PR.CPU1, 0x80) // Tell CPU1 driver to re-eval _PPC + } + Default{ + Notify(\_PR.CPU0, 0x80) // Tell CPU0 driver to re-eval _PPC + } + } + } + } + + // _TMP (Temperature) + // + // This control method returns the thermal zone's current operating temperature. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the current temperature of the thermal zone (in tenths of degrees Kelvin) + // + //AMI override begin + //Method(_TMP) + Method(TMPX) + //AMI override end + { + // Return the temperature to the OS if EC access is enabled. + If(\ECON) + { + Return(\_SB.IETM.CTOK(\_SB.PCI0.LPCB.H_EC.PECH)) + } + Else + { + // Return a static value as EC access is disabled or DPTF is active. + Return(3000) + } + } + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TCPU, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + // _PSS (Performance Supported States) + // + // This optional object indicates to OSPM the number of supported processor performance states that any given system can support. + // + // Arguments: (1) + // None + // Return Value: + // A variable-length Package containing a list of Pstate sub-packages as described below + // + // Return Value Information + // Package { + // PState [0] // Package - Performance state 0 + // .... + // PState [n] // Package - Performance state n + // } + // + // Each Pstate sub-Package contains the elements described below: + // Package { + // CoreFrequency // Integer (DWORD) + // Power // Integer (DWORD) + // Latency // Integer (DWORD) + // BusMasterLatency // Integer (DWORD) + // Control // Integer (DWORD) + // Status // Integer (DWORD) + // } + // + // Stub for the Actual CPU _PSS method. + // + Method(_PSS,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._PSS)) + { // Ensure _PSS is present + Return(\_PR.CPU0._PSS()) + } Else { + Return(Package(){ + Package(){0,0,0,0,0,0}, + Package(){0,0,0,0,0,0}}) + } + } + + // _TSS (Throttling Supported States) + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of Tstate sub-packages as described below + // + // Return Value Information + // Package { + // TState [0] // Package - Throttling state 0 + // .... + // TState [n] // Package - Throttling state n + // } + // + // Each Tstate sub-Package contains the elements described below: + // Package { + // Percent // Integer (DWORD) + // Power // Integer (DWORD) + // Latency // Integer (DWORD) + // Control // Integer (DWORD) + // Status // Integer (DWORD) + // } + // + // Stub for the Actual CPU _TSS method. + // + Method(_TSS,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._TSS)) + { // Ensure _TSS is present + Return(\_PR.CPU0._TSS()) + } Else { + Return(Package(){ + Package(){0,0,0,0,0}, + Package(){0,0,0,0,0}}) + } + } + + // _TPC (Throttling Present Capabilities) + // + // This optional object is a method that dynamically indicates to OSPM the number of throttling states currently supported by the platform. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the number of states supported: + // 0 - states 0 .. nth state available (all states available) + // 1 - state 1 .. nth state available + // 2 - state 2 .. nth state available + // ... + // n - state n available only + // + Method(_TPC) + { + If(CondRefOf(\_PR.CPU0._TPC)) + { // Ensure _TPC is present + Return(\_PR.CPU0._TPC) + } Else { + Return(0) + } + } + + // _PTC (Processor Throttling Control) + // + // _PTC is an optional object that defines a processor throttling control interface alternative to the I/O address spaced-based P_BLK throttling control register (P_CNT) + // + // PDC0[2] = ACPI object indicating if OSPM is capable of direct access to On Demand throttling MSR + // + // Arguments: (0) + // None + // Return Value: + // A Package as described below + // + // Return Value Information + // Package { + // ControlRegister // Buffer (Resource Descriptor) + // StatusRegister // Buffer (Resource Descriptor) + // } + // + Method(_PTC,,,,PkgObj) + { + If(LAnd(CondRefOf(\PDC0),LNotEqual(\PDC0,0x80000000))) // is object present and initialized? + { + If(And(\PDC0, 0x0004)) { // does OS support MSR interface? + Return(Package() { + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)}, + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)} }) // if OS supports MSR interface + } Else { + Return(Package() { + ResourceTemplate(){Register(SystemIO, 5, 0, PCH_ACPI_PBLK)}, + ResourceTemplate(){Register(SystemIO, 5, 0, PCH_ACPI_PBLK)} }) // if OS support IO based interface + } + } Else { + Return(Package() { + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)}, + ResourceTemplate(){Register(FFixedHW, 0, 0, 0)} }) // if object is not present or not initialized then return MSR interface + } + } + + // _TSD (T-State Dependency) + // + // This optional object provides T-state control cross logical processor dependency information to OSPM. + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of T-state dependency Packages as described below. + // + // Return Value Information + // Package { + // NumEntries // Integer + // Revision // Integer (BYTE) + // Domain // Integer (DWORD) + // CoordType // Integer (DWORD) + // NumProcessors // Integer (DWORD) + // } + // + Method(_TSD,,,,PkgObj) + { + If(CondRefOf(\_PR.CPU0._TSD)) + { // Ensure _TSD is present + Return(\_PR.CPU0._TSD()) + } Else { + Return(Package(){ + Package(){5,0,0,0,0}, + Package(){5,0,0,0,0}}) + } + } + + // _TDL (T-state Depth Limit) + // + // This optional object evaluates to the _TSS entry number of the lowest power throttling state that OSPM may use. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the Throttling Depth Limit _TSS entry number: + // 0 - throttling disabled. + // 1 - state 1 is the lowest power T-state available. + // 2 - state 2 is the lowest power T-state available. + // ... + // n - state n is the lowest power T-state available. + // + Method(_TDL) + { + If(LAnd(CondRefOf(\_PR.CPU0._TSS),CondRefOf(\_PR.CFGD))) + { // Ensure _TSS is present + If(And(\_PR.CFGD, PPM_TSTATE_FINE_GRAINED)) + { + Return(Subtract(SizeOf(\_PR.CPU0.TSMF),1)) + } Else { + Return(Subtract(SizeOf(\_PR.CPU0.TSMC),1)) + } + } Else { + Return(0) + } + } + + // _PDL (P-state Depth Limit) + // + // This optional object evaluates to the _PSS entry number of the lowest performance P-state that OSPM may use when performing passive thermal control. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the P-state Depth Limit _PSS entry number: + // Integer containing the P-state Depth Limit _PSS entry number: + // 0 - P0 is the only P-state available for OSPM use + // 1 - state 1 is the lowest power P-state available + // 2 - state 2 is the lowest power P-state available + // ... + // n - state n is the lowest power P-state available + // + Method(_PDL) + { + If(CondRefOf(\_PR.CPU0._PSS)) + { // Ensure _PSS is present + Return(Subtract(SizeOf(\_PR.CPU0._PSS),1)) + } Else { + Return(0) + } + } + + } // End Device(TCPU) +} // End Scope(\_SB) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchDppmPolicy.asl new file mode 100644 index 0000000..affa078 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchDppmPolicy.asl @@ -0,0 +1,175 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TpchDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.TPCH) +{ + Name (CTYP, 0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP,3,Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.TPCH, 0x91) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT,0,Serialized) + { + Return(\_SB.IETM.CTOK(PCHC)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(PCHH)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV,0,Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(ATPC)) // Passive Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(PTPC)) // Active Cooling Policy + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTPC),Local1) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATPC),Local1) // Active Cooling Policy + } + If(LGreaterEqual(LSTM,Local1)) + { + Return(Subtract(Local1,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC1) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(PTPC),Local0) // Passive Cooling Policy + } + Else + { + Store(\_SB.IETM.CTOK(ATPC),Local0) // Active Cooling Policy + } + Subtract(Local0, 50, Local0) + If(LGreaterEqual(LSTM,Local0)) + { + Return(Subtract(Local0,20)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local0) + } + } + +} // End Scope(\_SB.PCI0.TPCH) + diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchParticipant.asl new file mode 100644 index 0000000..c8b816b --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/TpchParticipant.asl @@ -0,0 +1,113 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + TpchParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + + +Scope(\_SB.PCI0) +{ + // + // This device is currently used by DPPM policies only. + // Refer to the specific technology BIOS specification. + // + Device (TPCH) + { + Name (_ADR,0x001F0006) // Device 31, Function 6 + Name (LSTM,0) // Last temperature reported + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(PCHD,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + OperationRegion(PCHT,PCI_Config,0x10,0x08) // PCH Thermal BAR + Field(PCHT,DWordAcc,NoLock,Preserve) + { + Offset(0x0), // EPBAR (Offset 10h) + STYP, 1, // Space type + ADRG, 2, // Address Range + PREF, 1, // Prefetchable + , 8, // hardwired to 0 + TBAR, 52 // Thermal BAR + } + + // Thermal Sensor Hysteresis, 3 degree Centigrade + Name(GTSH, 30) + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(TPCH, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // End Device(TPCH) +} // End Scope(\_SB.PCI0) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/Trt.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Trt.asl new file mode 100644 index 0000000..b3f6e37 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/Trt.asl @@ -0,0 +1,757 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + Trt.asl + +Abstract: + + Intel ACPI Reference Code for Intel Dynamic Power Performance Management + +--*/ + +Scope(\_SB.IETM) +{ + + Name(TRTI, Package() // TRT package when TFN1 is at 0% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 28, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 28, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 03, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTH, Package() // TRT package when TFN1 is at 15% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTG, Package() // TRT package when TFN1 is at 20% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTF, Package() // TRT package when TFN1 is at 25% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTE, Package() // TRT package when TFN1 is at 30% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTD, Package() // TRT package when TFN1 is at 35% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTC, Package() // TRT package when TFN1 is at 40% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTB, Package() // TRT package when TFN1 is at 45% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRTA, Package() // TRT package when TFN1 is at 50% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 36, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT9, Package() // TRT package when TFN1 is at 55% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 34, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 34, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT8, Package() // TRT package when TFN1 is at 60% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 32, 50, 8, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 32, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT7, Package() // TRT package when TFN1 is at 65% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 30, 50, 7, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 30, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT6, Package() // TRT package when TFN1 is at 70% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 28, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 28, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT5, Package() // TRT package when TFN1 is at 75% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 26, 50, 5, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 26, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT4, Package() // TRT package when TFN1 is at 80% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 24, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 24, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT3, Package() // TRT package when TFN1 is at 85% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 22, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 22, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT2, Package() // TRT package when TFN1 is at 90% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 21, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT1, Package() // TRT package when TFN1 is at 95% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 18, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + Name(TRT0, Package() // TRT package when TFN1 is at 100% speed + { + // Source Target Influence Period Reserved + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TPCH, 30, 20, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.TCPU, 16, 50, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.TMEM, 10, 100, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.TCPU, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.B0D4, 18, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.TMEM, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TAMB, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.T_VR, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.LPCB.H_EC.TEFN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.TCPU, 3, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.B0D4, 30, 100, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.TMEM, 44, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TSKN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TAMB, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.T_VR, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.LPCB.H_EC.TEFN, 1, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.TMEM, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.TCPU, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.LPCB.H_EC.TSKN, 20, 50, 0, 0, 0, 0}, + Package(){\_SB.PCI0.B0D4, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.TMEM, \_SB.PCI0.WWAN, 20, 200, 0, 0, 0, 0}, + Package(){\_SB.PCI0.DPLY, \_SB.PCI0.WWAN, 20, 50, 0, 0, 0, 0} + }) + + // TRTR (Thermal Relationship Table Revision) + // + // This object evaluates to an integer value that defines the revision of the _TRT object. + // + // Arguments: (0) + // None + // Return Value: + // 0: Traditional TRT as defined by the ACPI Specification. + // 1: Priority based TRT + // + Method(TRTR) + { + Return(TRTV) + } + + // _TRT (Thermal Relationship Table) + // + // Arguments: (0) + // None + // Return Value: + // A variable-length Package containing a list of Thermal Relationship Packages as described below. + // + // Return Value Information + // Package { + // ThermalRelationship[0] // Package + // ... + // ThermalRelationship[n] // Package + // } + // + Method(_TRT,,,,PkgObj) + { + If(\ECON) + { + If(\_SB.PCI0.LPCB.H_EC.CFAN) // CFAN Holds On/Off information + { + If(LEqual(\_SB.PCI0.LPCB.H_EC.PENV, 0)) // PENV holds duty cycle in percent + { + Return(TRTI) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 15)) // PENV holds duty cycle in percent + { + Return(TRTH) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 20)) + { + Return(TRTG) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 25)) + { + Return(TRTF) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 30)) + { + Return(TRTE) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 35)) + { + Return(TRTD) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 40)) + { + Return(TRTC) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 45)) + { + Return(TRTB) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 50)) + { + Return(TRTA) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 55)) + { + Return(TRT9) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 60)) + { + Return(TRT8) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 65)) + { + Return(TRT7) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 70)) + { + Return(TRT6) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 75)) + { + Return(TRT5) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 80)) + { + Return(TRT4) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 85)) + { + Return(TRT3) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 90)) + { + Return(TRT2) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 95)) + { + Return(TRT1) + } + + If(LLessEqual(\_SB.PCI0.LPCB.H_EC.PENV, 100)) + { + Return(TRT0) + } + } + } + + Return(TRTI) // Return 0% State TRT by default + } // End _TRT +} diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANDppmPolicy.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANDppmPolicy.asl new file mode 100644 index 0000000..d827eed --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANDppmPolicy.asl @@ -0,0 +1,140 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + WWANDppmPolicy.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0.WWAN) +{ + Name(CTYP,0) // Device-specific cooling policy preference + + // _SCP (Set Cooling Policy) + // + // Arguments: (3) + // Arg0 - Mode An Integer containing the cooling mode policy code + // Arg1 - AcousticLimit An Integer containing the acoustic limit + // Arg2 - PowerLimit An Integer containing the power limit + // Return Value: + // None + // + // Argument Information: + // Mode - 0 = Active, 1 = Passive + // Acoustic Limit - Specifies the maximum acceptable acoustic level that active cooling devices may generate. + // Values are 1 to 5 where 1 means no acoustic tolerance and 5 means maximum acoustic tolerance. + // Power Limit - Specifies the maximum acceptable power level that active cooling devices may consume. + // Values are from 1 to 5 where 1 means no power may be used to cool and 5 means maximum power may be used to cool. + // + Method(_SCP, 3, Serialized) + { + If(LOr(LEqual(Arg0,0),LEqual(Arg0,1))) + { + Store(Arg0, CTYP) + P8XH(0, Arg1) + P8XH(1, Arg2) + Notify(\_SB.PCI0.WWAN, 0x91) + } + } + + // _ACx (Active Cooling) + // + // This optional object, if present under a thermal zone, returns the + // temperature trip point at which OSPM must start or stop Active cooling, + // where x is a value between 0 and 9 that designates multiple active cooling levels of the thermal zone. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the active cooling temperature threshold in tenths of degrees Kelvin + // + Method(_AC0) + { + If(CTYP) + { + Store(\_SB.IETM.CTOK(WWPT),Local1) // Passive Cooling Policy + } Else { + Store(\_SB.IETM.CTOK(WWAT),Local1) // Active Cooling Policy + } + If(LGreater(LSTM,Local1)) + { + Return(Subtract(Local1,GTSH)) // subtract 2 degrees which is the Hysteresis + } + Else + { + Return(Local1) + } + } + + // _CRT (Critical Temperature) + // + // This object, when defined under a thermal zone, returns the critical temperature at which OSPM must shutdown the system. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the critical temperature threshold in tenths of degrees Kelvin + // + Method(_CRT, 0, Serialized) + { + Return(\_SB.IETM.CTOK(WWCT)) + } + + // _HOT (Hot Temperature) + // + // This optional object, when defined under a thermal zone, returns the critical temperature + // at which OSPM may choose to transition the system into the S4 sleeping state. + // + // Arguments: (0) + // None + // Return Value: + // The return value is an integer that represents the critical sleep threshold tenths of degrees Kelvin. + // + Method(_HOT,0,Serialized) + { + Return(\_SB.IETM.CTOK(WWHT)) + } + + // _PSV (Passive) + // + // This optional object, if present under a thermal zone, evaluates to the temperature + // at which OSPM must activate passive cooling policy. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the passive cooling temperature threshold in tenths of degrees Kelvin + // + Method(_PSV, 0, Serialized) + { + If(CTYP) + { + Return(\_SB.IETM.CTOK(WWAT)) // Active Cooling Policy + } Else { + Return(\_SB.IETM.CTOK(WWPT)) // Passive Cooling Policy + } + } + +} // End Scope(\_SB.PCI0.WWAN) diff --git a/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANParticipant.asl b/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANParticipant.asl new file mode 100644 index 0000000..600939a --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/AcpiTables/WWANParticipant.asl @@ -0,0 +1,104 @@ +/*++ + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +--*/ + +/*++ + +Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved +This software and associated documentation (if any) is furnished +under a license and may only be used or copied in accordance +with the terms of the license. Except as permitted by such +license, no part of this software or documentation may be +reproduced, stored in a retrieval system, or transmitted in any +form or by any means without the express written consent of +Intel Corporation. + +Module Name: + + WWANParticipant.asl + +Abstract: + + Intel ACPI Reference Code for Dynamic Platform & Thermal Framework + +--*/ + +Scope(\_SB.PCI0) +{ + + Device(WWAN) // WWAN temperature sensor + { + Name(_HID, EISAID("INT3408")) + Name(_UID, 1) + Name(_STR, Unicode("Intel DPTF WWAN Participant")) + Name(PTYP, 0x0F) + + + // _STA (Status) + // + // This object returns the current status of a device. + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing a device status bitmap: + // Bit 0 - Set if the device is present. + // Bit 1 - Set if the device is enabled and decoding its resources. + // Bit 2 - Set if the device should be shown in the UI. + // Bit 3 - Set if the device is functioning properly (cleared if device failed its diagnostics). + // Bit 4 - Set if the battery is present. + // Bits 5-31 - Reserved (must be cleared). + // + Method(_STA) + { + If (LEqual(WAND,1)){ + Return(0x0F) + } Else { + Return(0x00) + } + } + + // Thermal Sensor Hysteresis, 2 degrees + Name(GTSH, 20) + + Name(LSTM,0) // Last temperature reported + + // _DTI (Device Temperature Indication) + // + // Conveys the temperature of a device's internal temperature sensor to the platform when a temperature trip point + // is crossed or when a meaningful temperature change occurs. + // + // Arguments: (1) + // Arg0 - An Integer containing the current value of the temperature sensor (in tenths Kelvin) + // Return Value: + // None + // + Method(_DTI, 1) + { + Store(Arg0,LSTM) + Notify(WWAN, 0x91) // notify the participant of a trip point change event + } + + // _NTT (Notification Temperature Threshold) + // + // Returns the temperature change threshold for devices containing native temperature sensors to cause + // evaluation of the _DTI object + // + // Arguments: (0) + // None + // Return Value: + // An Integer containing the temperature threshold in tenths of degrees Kelvin. + // + Method(_NTT, 0) + { + Return(2782) // 5 degree Celcius, this could be a platform policy with setup item + } + + } // end of Device(WWAN) +} // end of Scope(\_SB.PCI0) + diff --git a/ReferenceCode/AcpiTables/Dptf/Dptf.cif b/ReferenceCode/AcpiTables/Dptf/Dptf.cif new file mode 100644 index 0000000..6bdc49c --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dptf.cif @@ -0,0 +1,13 @@ +<component> + name = "Intel DPTF" + category = eModule + LocalRoot = "ReferenceCode\AcpiTables\Dptf\" + RefName = "Dptf" +[files] +"Dptf.sdl" +"ReleaseNotes.chm" +[parts] +"DptfDxe" +"DptfAcpiTables" +"DptfGuidLib" +<endComponent> diff --git a/ReferenceCode/AcpiTables/Dptf/Dptf.sdl b/ReferenceCode/AcpiTables/Dptf/Dptf.sdl new file mode 100644 index 0000000..9786c10 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dptf.sdl @@ -0,0 +1,26 @@ +TOKEN + Name = Dptf_SUPPORT + Value = 1 + TokenType = Boolean + TargetEQU = Yes + TargetMAK = Yes + TargetH = Yes + Master = Yes + Help = "Main switch to enable Dptf support in Project" +End + +PATH + Name = "INTEL_DPTF_DIR" + Help = "Intel DPTF source directory" +End + +ELINK + Name = "DPTF_INCLUDES" + InvokeOrder = ReplaceParent +End + +ELINK + Name = "/I$(INTEL_DPTF_DIR)" + Parent = "DPTF_INCLUDES" + InvokeOrder = AfterParent +End
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.c b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.c new file mode 100644 index 0000000..caee0a7 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.c @@ -0,0 +1,440 @@ +/** @file + This DXE driver configures and supports Dptf. + +@copyright + Copyright (c) 2013 Intel Corporation. All rights reserved + This software and associated documentation (if any) is furnished + under a license and may only be used or copied in accordance + with the terms of the license. Except as permitted by such + license, no part of this software or documentation may be + reproduced, stored in a retrieval system, or transmitted in any + form or by any means without the express written consent of + Intel Corporation. + + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement + +**/ +#include "Dptf.h" + +ACPI_PLATFORM_POLICY_PROTOCOL *mAcpiPlatformPolicyProtocol; + +EFI_RUNTIME_SERVICES *gRT; + +/// +/// Driver entry point +/// +EFI_DRIVER_ENTRY_POINT (InitializeDptf) + +EFI_STATUS +InitializeDptf ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/** +@brief + This procedure does all the DPTF initialization and loads the ACPI tables. + + @param[in] ImageHandle - The firmware allocated handle to the Driver Image + @param[in] SystemTable - Pointer to the EFI System Table + + @retval EFI_SUCCESS - The driver installed/initialized correctly. +**/ +{ + EFI_STATUS Status; + + gRT = SystemTable->RuntimeServices; + + /// + /// Initialize the EFI Runtime Library + /// + DxeInitializeDriverLib (ImageHandle, SystemTable); + + /// + /// S3 boot script + /// + INITIALIZE_SCRIPT (ImageHandle, SystemTable); + + /// + /// Locate platform configuration information and copy it to a global variable. + /// + Status = gBS->LocateProtocol ( + &gAcpiPlatformPolicyProtocolGuid, + NULL, + (VOID**) &mAcpiPlatformPolicyProtocol + ); + if (EFI_ERROR(Status)) { + DEBUG ((EFI_D_ERROR, "No ACPI Platform Policy Protocol available.")); + } else { + DEBUG ((EFI_D_INFO, "ACPI Platform Policy Protocol is loaded.")); + } + ASSERT_EFI_ERROR(Status); + + /// + /// Check if Dptf is enabled and load the ACPI SSDT. + /// + if (mAcpiPlatformPolicyProtocol->EnableDptf == 1) { + /// + /// Load the SSDT ACPI Tables. + /// + switch (mAcpiPlatformPolicyProtocol->BoardId) { + case 0x30: // BoardId for Ffrd + LoadAcpiTablesFfrd (); + break; + default: + LoadAcpiTables (); + } + } + + return EFI_SUCCESS; +} + +VOID +LoadAcpiTables( + VOID + ) +/** +@brief + This procedure loads the ACPI SSDT tables. + + @param[in] None + + @retval None + +**/ +{ + EFI_STATUS Status; + EFI_HANDLE *HandleBuffer; + UINTN NumberOfHandles; + UINTN Index; + EFI_FIRMWARE_VOLUME_PROTOCOL *FwVol; + EFI_ACPI_TABLE_PROTOCOL *AcpiTable; + INTN Instance; + EFI_ACPI_COMMON_HEADER *Table; + UINTN Size; + EFI_FV_FILETYPE FileType; + EFI_FV_FILE_ATTRIBUTES Attributes; + UINT32 FvStatus; + EFI_ACPI_DESCRIPTION_HEADER *TableHeader; + UINTN TableHandle; + EFI_ACPI_TABLE_VERSION Version; + BOOLEAN LoadTable; + + FwVol = NULL; + Table = NULL; + + /// + /// Locate FV protocol. + /// + Status = gBS->LocateHandleBuffer ( + ByProtocol, + &gEfiFirmwareVolumeProtocolGuid, + NULL, + &NumberOfHandles, + &HandleBuffer + ); + ASSERT_EFI_ERROR (Status); + + /// + /// Look for FV with ACPI storage file + /// + for (Index = 0; Index < NumberOfHandles; Index++) { + + /// + /// Get the protocol on this handle + /// This should not fail because of LocateHandleBuffer + /// + Status = gBS->HandleProtocol ( + HandleBuffer[Index], + &gEfiFirmwareVolumeProtocolGuid, + (VOID **) &FwVol + ); + ASSERT_EFI_ERROR (Status); + + if ((Status == EFI_SUCCESS) && (FwVol != NULL)) { + /// + /// See if it has the ACPI storage file + /// + Size = 0; + FvStatus = 0; + Status = FwVol->ReadFile ( + FwVol, + &gDptfAcpiTableStorageGuid, + NULL, + &Size, + &FileType, + &Attributes, + &FvStatus + ); + + /// + /// If we found it, then we are done + /// + if (Status == EFI_SUCCESS) { + break; + } + } + } + + /// + /// Our exit status is determined by the success of the previous operations + /// If the protocol was found, Instance already points to it. + /// + /// Free any allocated buffers + /// + FreePool (HandleBuffer); + + /// + /// Sanity check that we found our data file + /// + ASSERT (FwVol); + if (FwVol == NULL) { + return; + } + + /// + /// By default, a table belongs in all ACPI table versions published. + /// + Version = EFI_ACPI_TABLE_VERSION_1_0B | EFI_ACPI_TABLE_VERSION_2_0 | EFI_ACPI_TABLE_VERSION_3_0; + + /// + /// Find the Table protocol + /// + Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &AcpiTable); + + /// + /// Read tables from the storage file. + /// + Instance = 0; + + while (Status == EFI_SUCCESS) { + /// + /// Read the ACPI tables + /// + Status = FwVol->ReadSection ( + FwVol, + &gDptfAcpiTableStorageGuid, + EFI_SECTION_RAW, + Instance, + (VOID **) &Table, + &Size, + &FvStatus + ); + + if (!EFI_ERROR (Status)) { + + LoadTable = FALSE; + TableHeader = (EFI_ACPI_DESCRIPTION_HEADER *) Table; + + switch (((EFI_ACPI_DESCRIPTION_HEADER*) TableHeader)->OemTableId) { + + case EFI_SIGNATURE_64 ('D', 'p', 't', 'f', 'T', 'a', 'b', 'l'): + /// + /// This is Dptf SSDT. Dptf should be enabled if we reach here so load the table. + /// + LoadTable = TRUE; + DEBUG ((EFI_D_INFO, "Found Dptf SSDT signature.")); + break; + + default: + break; + } + + /// + /// Add the table + /// + if (LoadTable) { + TableHandle = 0; + Status = AcpiTable->InstallAcpiTable ( + AcpiTable, + Table, + Table->Length, + &TableHandle + ); + } + + /// + /// Increment the instance + /// + Instance++; + Table = NULL; + } + } +} + +VOID +LoadAcpiTablesFfrd( + VOID + ) +/** +@brief + This procedure loads the ACPI SSDT tables. + + @param[in] None + + @retval None + +**/ +{ + EFI_STATUS Status; + EFI_HANDLE *HandleBuffer; + UINTN NumberOfHandles; + UINTN Index; + EFI_FIRMWARE_VOLUME_PROTOCOL *FwVol; + EFI_ACPI_TABLE_PROTOCOL *AcpiTable; + INTN Instance; + EFI_ACPI_COMMON_HEADER *Table; + UINTN Size; + EFI_FV_FILETYPE FileType; + EFI_FV_FILE_ATTRIBUTES Attributes; + UINT32 FvStatus; + EFI_ACPI_DESCRIPTION_HEADER *TableHeader; + UINTN TableHandle; + EFI_ACPI_TABLE_VERSION Version; + BOOLEAN LoadTable; + + FwVol = NULL; + Table = NULL; + + /// + /// Locate FV protocol. + /// + Status = gBS->LocateHandleBuffer ( + ByProtocol, + &gEfiFirmwareVolumeProtocolGuid, + NULL, + &NumberOfHandles, + &HandleBuffer + ); + ASSERT_EFI_ERROR (Status); + + /// + /// Look for FV with ACPI storage file + /// + for (Index = 0; Index < NumberOfHandles; Index++) { + + /// + /// Get the protocol on this handle + /// This should not fail because of LocateHandleBuffer + /// + Status = gBS->HandleProtocol ( + HandleBuffer[Index], + &gEfiFirmwareVolumeProtocolGuid, + (VOID **) &FwVol + ); + ASSERT_EFI_ERROR (Status); + + if ((Status == EFI_SUCCESS) && (FwVol != NULL)) { + /// + /// See if it has the ACPI storage file + /// + Size = 0; + FvStatus = 0; + Status = FwVol->ReadFile ( + FwVol, + &gDptfAcpiTableStorageGuidFfrd, + NULL, + &Size, + &FileType, + &Attributes, + &FvStatus + ); + + /// + /// If we found it, then we are done + /// + if (Status == EFI_SUCCESS) { + break; + } + } + } + + /// + /// Our exit status is determined by the success of the previous operations + /// If the protocol was found, Instance already points to it. + /// + /// Free any allocated buffers + /// + FreePool (HandleBuffer); + + /// + /// Sanity check that we found our data file + /// + ASSERT (FwVol); + if (FwVol == NULL) { + return; + } + + /// + /// By default, a table belongs in all ACPI table versions published. + /// + Version = EFI_ACPI_TABLE_VERSION_1_0B | EFI_ACPI_TABLE_VERSION_2_0 | EFI_ACPI_TABLE_VERSION_3_0; + + /// + /// Find the Table protocol + /// + Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &AcpiTable); + + /// + /// Read tables from the storage file. + /// + Instance = 0; + + while (Status == EFI_SUCCESS) { + /// + /// Read the ACPI tables + /// + Status = FwVol->ReadSection ( + FwVol, + &gDptfAcpiTableStorageGuidFfrd, + EFI_SECTION_RAW, + Instance, + (VOID **) &Table, + &Size, + &FvStatus + ); + + if (!EFI_ERROR (Status)) { + + LoadTable = FALSE; + TableHeader = (EFI_ACPI_DESCRIPTION_HEADER *) Table; + + switch (((EFI_ACPI_DESCRIPTION_HEADER*) TableHeader)->OemTableId) { + + case EFI_SIGNATURE_64 ('D', 'p', 't', 'f', 'F', 'f', 'r', 'd'): + /// + /// This is Dptf SSDT. Dptf should be enabled if we reach here so load the table. + /// + LoadTable = TRUE; + DEBUG ((EFI_D_INFO, "Found Dptf SSDT signature.")); + break; + + default: + break; + } + + /// + /// Add the table + /// + if (LoadTable) { + TableHandle = 0; + Status = AcpiTable->InstallAcpiTable ( + AcpiTable, + Table, + Table->Length, + &TableHandle + ); + } + + /// + /// Increment the instance + /// + Instance++; + Table = NULL; + } + } +} diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.dxs b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.dxs new file mode 100644 index 0000000..3804c02 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.dxs @@ -0,0 +1,33 @@ +/** @file + Dependency expression source file. + +@copyright + Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved + This software and associated documentation (if any) is furnished + under a license and may only be used or copied in accordance + with the terms of the license. Except as permitted by such + license, no part of this software or documentation may be + reproduced, stored in a retrieval system, or transmitted in any + form or by any means without the express written consent of + Intel Corporation. + + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement + +**/ + + +#include "EfiDepex.h" +#include EFI_PROTOCOL_DEPENDENCY (CpuIo) +#include EFI_PROTOCOL_DEPENDENCY (AcpiSupport) +#include EFI_PROTOCOL_DEPENDENCY (AcpiPlatformPolicy) + +DEPENDENCY_START + EFI_CPU_IO_PROTOCOL_GUID AND + EFI_ACPI_SUPPORT_GUID AND + ACPI_PLATFORM_POLICY_PROTOCOL_GUID +DEPENDENCY_END diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.h b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.h new file mode 100644 index 0000000..8f66020 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.h @@ -0,0 +1,196 @@ +/** @file + Header file for the Dptf driver. + +@copyright + Copyright (c) 2013 Intel Corporation. All rights reserved + This software and associated documentation (if any) is furnished + under a license and may only be used or copied in accordance + with the terms of the license. Except as permitted by such + license, no part of this software or documentation may be + reproduced, stored in a retrieval system, or transmitted in any + form or by any means without the express written consent of + Intel Corporation. + + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +**/ + +#ifndef _DPTF_H_ +#define _DPTF_H_ + +#include "EdkIIGlueBase.h" +#include "EdkIIGlueDxe.h" +#include "EdkIIGluePcd.h" +#include "Acpi.h" +#include "CpuIA32.h" +#include "EfiScriptLib.h" +#include "SaAccess.h" + +/// +/// Consumed protocols +/// +#include EFI_PROTOCOL_DEPENDENCY (AcpiTable) +#include EFI_PROTOCOL_DEPENDENCY (FirmwareVolume) +#include EFI_PROTOCOL_CONSUMER (PciRootBridgeIo) +#include EFI_PROTOCOL_DEFINITION (AcpiPlatformPolicy) + +#ifndef DPTF_BASE_ADDRESS +#define DPTF_BASE_ADDRESS 0xFED98000 +#endif +#ifndef DPTF_LENGTH +#define DPTF_LENGTH 0x8000 +#endif + +/// +/// SSDT data storage file +/// +#include "DptfAcpiTableStorage.h" + +/// +/// AML parsing definitions +/// +#define AML_METHOD_OP 0x14 + +/// +/// MSR definitions +/// +#define MSR_PLATFORM_INFO 0xCE + #define CONFIG_TDP_NUM_LEVELS_OFFSET 33 + #define CONFIG_TDP_NUM_LEVELS_MASK (0x3 << 1) // Bits 34:33 + #define LOW_POWER_MODE_OFFSET 32 + #define LOW_POWER_MODE_MASK 0x1 + +/// +/// UINT64 workaround +/// +/// The MS compiler doesn't handle QWORDs very well. I'm breaking +/// them into DWORDs to circumvent the problems. Converting back +/// shouldn't be a big deal. +/// +#pragma pack(1) +typedef union _MSR_REGISTER { + UINT64 Qword; + + struct _DWORDS { + UINT32 Low; + UINT32 High; + } Dwords; + + struct _BYTES { + UINT8 FirstByte; + UINT8 SecondByte; + UINT8 ThirdByte; + UINT8 FouthByte; + UINT8 FifthByte; + UINT8 SixthByte; + UINT8 SeventhByte; + UINT8 EighthByte; + } Bytes; + +} MSR_REGISTER; +#pragma pack() + +/// +/// register definitions +/// +#define MCHBAR (0x48) +#define MCHBAR_MCHBAR_MASK 0x7fffff8000 + +#define TMBAR (0x10) + +#ifndef BIT63 +#define BIT0 0x0001 +#define BIT1 0x0002 +#define BIT2 0x0004 +#define BIT3 0x0008 +#define BIT4 0x0010 +#define BIT5 0x0020 +#define BIT6 0x0040 +#define BIT7 0x0080 +#define BIT8 0x0100 +#define BIT9 0x0200 +#define BIT10 0x0400 +#define BIT11 0x0800 +#define BIT12 0x1000 +#define BIT13 0x2000 +#define BIT14 0x4000 +#define BIT15 0x8000 +#define BIT16 0x00010000 +#define BIT17 0x00020000 +#define BIT18 0x00040000 +#define BIT19 0x00080000 +#define BIT20 0x00100000 +#define BIT21 0x00200000 +#define BIT22 0x00400000 +#define BIT23 0x00800000 +#define BIT24 0x01000000 +#define BIT25 0x02000000 +#define BIT26 0x04000000 +#define BIT27 0x08000000 +#define BIT28 0x10000000 +#define BIT29 0x20000000 +#define BIT30 0x40000000 +#define BIT31 0x80000000 +#define BIT32 0x100000000 +#define BIT33 0x200000000 +#define BIT34 0x400000000 +#define BIT35 0x800000000 +#define BIT36 0x1000000000 +#define BIT37 0x2000000000 +#define BIT38 0x4000000000 +#define BIT39 0x8000000000 +#define BIT40 0x10000000000 +#define BIT41 0x20000000000 +#define BIT42 0x40000000000 +#define BIT43 0x80000000000 +#define BIT44 0x100000000000 +#define BIT45 0x200000000000 +#define BIT46 0x400000000000 +#define BIT47 0x800000000000 +#define BIT48 0x1000000000000 +#define BIT49 0x2000000000000 +#define BIT50 0x4000000000000 +#define BIT51 0x8000000000000 +#define BIT52 0x10000000000000 +#define BIT53 0x20000000000000 +#define BIT54 0x40000000000000 +#define BIT55 0x80000000000000 +#define BIT56 0x100000000000000 +#define BIT57 0x200000000000000 +#define BIT58 0x400000000000000 +#define BIT59 0x800000000000000 +#define BIT60 0x1000000000000000 +#define BIT61 0x2000000000000000 +#define BIT62 0x4000000000000000 +#define BIT63 0x8000000000000000 +#endif + +#define MmPciExpressAddress(Segment, Bus, Device, Function, Register) \ + ( (UINTN) (PciRead32 (PCI_LIB_ADDRESS (0,0,0,0x60)) & 0xFC000000) + \ + (UINTN) (Bus << 20) + \ + (UINTN) (Device << 15) + \ + (UINTN) (Function << 12) + \ + (UINTN) (Register) \ + ) + +EFI_STATUS +InitializeDptf ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +VOID +LoadAcpiTables( + VOID + ); + +VOID +LoadAcpiTablesFfrd( + VOID + ); + +#endif diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.inf b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.inf new file mode 100644 index 0000000..1de1ee6 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/Dptf.inf @@ -0,0 +1,83 @@ +## @file +# Component description file for Dptf module +# +#@copyright +# Copyright (c) 2012 Intel Corporation. All rights reserved +# This software and associated documentation (if any) is furnished +# under a license and may only be used or copied in accordance +# with the terms of the license. Except as permitted by such +# license, no part of this software or documentation may be +# reproduced, stored in a retrieval system, or transmitted in any +# form or by any means without the express written consent of +# Intel Corporation. +# +# This file contains an 'Intel Peripheral Driver' and uniquely +# identified as "Intel Reference Module" and is +# licensed for Intel CPUs and chipsets under the terms of your +# license agreement with Intel or your vendor. This file may +# be modified by the user, subject to additional terms of the +# license agreement +# + + +[defines] +BASE_NAME = Dptf +FILE_GUID = 918ABA30-3D8D-4bb5-B849-45CC4FC7DE7C +COMPONENT_TYPE = RT_DRIVER + +[sources.common] + Dptf.h + Dptf.c + +[includes.common] + $(EFI_SOURCE)/$(PROJECT_ACPI_ROOT) + $(EFI_SOURCE)/$(PROJECT_ACPI_ROOT)/Dptf + $(EFI_SOURCE)/$(PROJECT_ACPI_ROOT)/Dptf/Guid/AcpiTableStorage + . + $(EDK_SOURCE)/Sample/Chipset/PcCompatible + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Include + $(EDK_SOURCE)/Foundation/Efi + $(EDK_SOURCE)/Foundation/Efi/Include + $(EDK_SOURCE)/Foundation/Framework + $(EDK_SOURCE)/Foundation/Framework/Include + $(EDK_SOURCE)/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Core/Dxe + $(EDK_SOURCE)/Foundation/Core/Dxe/ArchProtocol/Cpu + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EFI_SOURCE) + $(EFI_SOURCE)/Framework + $(EFI_SOURCE)/Include + $(EFI_SOURCE)/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include/Pcd + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include/Library + $(EDK_SOURCE)/Foundation/Cpu/Pentium/Include + $(EFI_SOURCE)/$(PROJECT_SA_ROOT)/Include + +[libraries.common] + EdkIIGlueDxeReportStatusCodeLib + EdkIIGlueDxeDebugLibReportStatusCode + EdkProtocolLib + EfiProtocolLib + EfiDriverLib + ArchProtocolLib + EdkFrameworkProtocolLib + EdkIIGlueBasePciExpressLib + EdkIIGlueUefiBootServicesTableLib + EdkIIGlueUefiLib + EdkIIGlueBaseLib + EfiScriptLib + AcpiProtocolLib + DptfGuidLib + +[nmake.common] + IMAGE_ENTRY_POINT = InitializeDptf + DPX_SOURCE = Dptf.dxs +# +# Module Entry Point +# + C_FLAGS = $(C_FLAGS) -D"__EDKII_GLUE_MODULE_ENTRY_POINT__=InitializeDptf" \ + -D __EDKII_GLUE_DXE_REPORT_STATUS_CODE_LIB__ \ + -D __EDKII_GLUE_DXE_DEBUG_LIB_REPORT_STATUS_CODE__ diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.cif b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.cif new file mode 100644 index 0000000..78cbeda --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.cif @@ -0,0 +1,13 @@ +<component> + name = "DptfDxe" + category = ModulePart + LocalRoot = "ReferenceCode\AcpiTables\Dptf\Dxe\" + RefName = "DptfDxe" +[files] +"DptfDxe.sdl" +"DptfDxe.mak" +"Dptf.c" +"Dptf.dxs" +"Dptf.h" +"Dptf.inf" +<endComponent> diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.mak b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.mak new file mode 100644 index 0000000..1a0ac0a --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.mak @@ -0,0 +1,106 @@ +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* + +#************************************************************************* +# $Header: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfDxe/DptfDxe.mak 2 9/26/12 2:00a Victortu $ +# +# $Revision: 2 $ +# +# $Date: 9/26/12 2:00a $ +#************************************************************************* +# Revision History +# ---------------- +# $Log: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfDxe/DptfDxe.mak $ +# +# 2 9/26/12 2:00a Victortu +# +# 1 4/24/12 9:25a Victortu +# Intel DPTF initialization. +# +#************************************************************************* +#<AMI_FHDR_START> +# +# Name: DptfDxe.mak +# +# Description: MAke file to build Intel DPTF components +# +#<AMI_FHDR_END> +#************************************************************************* +EDK : DptfDxe + +DptfDxe : $(BUILD_DIR)\DptfDxe.mak DptfDxeBin + +DptfDxe_OBJECTS = \ +$(BUILD_DIR)\$(INTEL_DPTF_DXE_DIR)\Dptf.obj + +$(BUILD_DIR)\DptfDxe.mak : $(INTEL_DPTF_DXE_DIR)\$(@B).cif $(INTEL_DPTF_DXE_DIR)\$(@B).mak $(BUILD_RULES) + $(CIF2MAK) $(INTEL_DPTF_DXE_DIR)\$(@B).cif $(CIF2MAK_DEFAULTS) + +DptfDxe_LIBS =\ + $(EDKPROTOCOLLIB)\ + $(EFIPROTOCOLLIB)\ + $(ARCHPROTOCOLLIB)\ + $(EDKFRAMEWORKPROTOCOLLIB)\ + $(EFISCRIPTLIB)\ + $(EdkIIGlueBaseLib_LIB)\ + $(EdkIIGlueBasePciExpressLib_LIB)\ + $(EdkIIGlueUefiBootServicesTableLib_LIB)\ + $(EdkIIGlueUefiLib_LIB)\ +!IF "$(x64_BUILD)"=="1" + $(EdkIIGlueBaseLibX64_LIB)\ +!ELSE + $(EdkIIGlueBaseLibIA32_LIB)\ +!ENDIF + $(EdkIIGlueDxeReportStatusCodeLib_LIB)\ + $(EdkIIGlueDxeServicesTableLib_LIB)\ + $(EdkIIGlueDxeDebugLibReportStatusCode_LIB)\ + $(EdkIIGlueDxeHobLib_LIB)\ + $(EFIDRIVERLIB)\ + $(AcpiProtocolLib_LIB)\ + $(DptfGuidLib_LIB)\ + +DptfDxe_INCLUDES= $(EDK_INCLUDES)\ + $(IndustryStandard_INCLUDES)\ + $(EdkIIGlueLib_INCLUDES)\ + $(DPTF_INCLUDES)\ + /I ReferenceCode\AcpiTables\ + /I$(ArchProtocolLib_DIR)\Cpu\ + /I$(INTEL_SYSTEM_AGENT_DIR)\Include\ + +DptfDxeBin: $(DptfDxe_LIBS) + $(MAKE) /$(MAKEFLAGS) $(EDKIIGLUE_DEFAULTS)\ + /f $(BUILD_DIR)\DptfDxe.mak all \ + NAME=DptfDxe\ + MAKEFILE=$(BUILD_DIR)\DptfDxe.mak \ + "MY_INCLUDES=$(DptfDxe_INCLUDES)"\ + GUID=918ABA30-3D8D-4bb5-B849-45CC4FC7DE7C\ + ENTRY_POINT=InitializeDptf \ + TYPE=RT_DRIVER\ + "OBJECTS=$(DptfDxe_OBJECTS)"\ + DEPEX1=$(INTEL_DPTF_DXE_DIR)\Dptf.dxs\ + DEPEX1_TYPE=EFI_SECTION_DXE_DEPEX\ + COMPRESS=1 +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#*************************************************************************
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.sdl b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.sdl new file mode 100644 index 0000000..03960e9 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Dxe/DptfDxe.sdl @@ -0,0 +1,30 @@ +TOKEN + Name = DptfDxe_SUPPORT + Value = 1 + TokenType = Boolean + TargetEQU = Yes + TargetMAK = Yes + Master = Yes + Help = "Main switch to enable DptfDxe support in Project" +End + +MODULE + Help = "Includes DptfDxe.mak to Project" + File = "DptfDxe.mak" +End + +PATH + Name = "INTEL_DPTF_DXE_DIR" +End + +ELINK + Name = "/I$(INTEL_DPTF_DXE_DIR)" + Parent = "DPTF_INCLUDES" + InvokeOrder = AfterParent +End + +ELINK + Name = "$(BUILD_DIR)\DptfDxe.ffs" + Parent = "FV_MAIN" + InvokeOrder = AfterParent +End diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.c b/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.c new file mode 100644 index 0000000..35552e2 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.c @@ -0,0 +1,34 @@ +/** @file + The GUID definition for Dptf ACPI table storage file name + +@copyright + Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved + This software and associated documentation (if any) is furnished + under a license and may only be used or copied in accordance + with the terms of the license. Except as permitted by such + license, no part of this software or documentation may be + reproduced, stored in a retrieval system, or transmitted in any + form or by any means without the express written consent of + Intel Corporation. + + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +**/ + +#include "EdkIIGlueDxe.h" +#include "DptfAcpiTableStorage.h" + +/// +/// Protocol GUID definition +/// +EFI_GUID gDptfAcpiTableStorageGuid = DPTF_ACPI_TABLE_STORAGE_GUID; +EFI_GUID gDptfAcpiTableStorageGuidFfrd = DPTF_ACPI_TABLE_STORAGE_GUID_FFRD; + +/// +/// Protocol description string +/// +EFI_GUID_STRING (&gDptfAcpiTableStorageGuid, "Dynamic Platform Thermal Framework ACPI Table Storage File Name", "Dynamic Platform Thermal Framework ACPI Table Storage file name GUID"); diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.h b/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.h new file mode 100644 index 0000000..a5330a0 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/AcpiTableStorage/DptfAcpiTableStorage.h @@ -0,0 +1,35 @@ +/** @file + GUID definition for the Dptf ACPI table storage file name + +@copyright + Copyright (c) 1999 - 2013 Intel Corporation. All rights reserved + This software and associated documentation (if any) is furnished + under a license and may only be used or copied in accordance + with the terms of the license. Except as permitted by such + license, no part of this software or documentation may be + reproduced, stored in a retrieval system, or transmitted in any + form or by any means without the express written consent of + Intel Corporation. + + This file contains an 'Intel Peripheral Driver' and uniquely + identified as "Intel Reference Module" and is + licensed for Intel CPUs and chipsets under the terms of your + license agreement with Intel or your vendor. This file may + be modified by the user, subject to additional terms of the + license agreement +**/ + +#ifndef _DPTF_ACPI_TABLE_STORAGE_H_ +#define _DPTF_ACPI_TABLE_STORAGE_H_ + +#define DPTF_ACPI_TABLE_STORAGE_GUID \ + { 0xea139578, 0xfea0, 0x4dd2, 0x91, 0xb5, 0x69, 0x53, 0x81, 0x9e, 0xf1, 0xe4 } + +extern EFI_GUID gDptfAcpiTableStorageGuid; + +#define DPTF_ACPI_TABLE_STORAGE_GUID_FFRD \ + { 0x2820908b, 0x87f6, 0x446b, 0xa1, 0x0, 0x74, 0xee, 0xe3, 0x6e, 0x29, 0x18 } + +extern EFI_GUID gDptfAcpiTableStorageGuidFfrd; + +#endif diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.cif b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.cif new file mode 100644 index 0000000..f888fb6 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.cif @@ -0,0 +1,12 @@ +<component> + name = "DptfGuidLib" + category = ModulePart + LocalRoot = "ReferenceCode\AcpiTables\Dptf\Guid\" + RefName = "DptfGuidLib" +[files] +"DptfGuidLib.sdl" +"DptfGuidLib.mak" +"DptfGuidLib.inf" +"AcpiTableStorage\DptfAcpiTableStorage.c" +"AcpiTableStorage\DptfAcpiTableStorage.h" +<endComponent> diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.inf b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.inf new file mode 100644 index 0000000..7d800c8 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.inf @@ -0,0 +1,55 @@ +## @file +# Component description file. +# +#@copyright +# Copyright (c) 1999 - 2012 Intel Corporation. All rights reserved +# This software and associated documentation (if any) is furnished +# under a license and may only be used or copied in accordance +# with the terms of the license. Except as permitted by such +# license, no part of this software or documentation may be +# reproduced, stored in a retrieval system, or transmitted in any +# form or by any means without the express written consent of +# Intel Corporation. +# +# This file contains an 'Intel Peripheral Driver' and uniquely +# identified as "Intel Reference Module" and is +# licensed for Intel CPUs and chipsets under the terms of your +# license agreement with Intel or your vendor. This file may +# be modified by the user, subject to additional terms of the +# license agreement +# + +[defines] +BASE_NAME = DptfGuidLib +COMPONENT_TYPE = LIBRARY + +[sources.common] + AcpiTableStorage/DptfAcpiTableStorage.c + AcpiTableStorage/DptfAcpiTableStorage.h + +[includes.common] + . + $(EFI_SOURCE) + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Efi + $(EDK_SOURCE)/Foundation/Efi/Include + $(EDK_SOURCE)/Foundation/Framework + $(EDK_SOURCE)/Foundation/Framework/Include + $(EDK_SOURCE)/Foundation/Include + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EFI_SOURCE)/$(PROJECT_ACPI_ROOT)-Dptf +# +# Edk II Glue Library, some hearder are included by R9 header so have to include +# + + $(EFI_SOURCE) + $(EFI_SOURCE)/Framework + $(EDK_SOURCE)/Foundation + $(EDK_SOURCE)/Foundation/Framework + $(EDK_SOURCE)/Foundation/Include/IndustryStandard + $(EDK_SOURCE)/Foundation/Core/Dxe + $(EDK_SOURCE)/Foundation/Include/Pei + $(EDK_SOURCE)/Foundation/Library/Dxe/Include + $(EDK_SOURCE)/Foundation/Library/EdkIIGlueLib/Include + +[nmake.common] diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.mak b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.mak new file mode 100644 index 0000000..f1a7a22 --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.mak @@ -0,0 +1,69 @@ +#************************************************************************* +#************************************************************************* +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#************************************************************************* +#************************************************************************* + +#************************************************************************* + +# $Header: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfGuidLib/DptfGuidLib.mak 1 4/24/12 9:27a Victortu $ +# +# $Revision: 1 $ +# +# $Date: 4/24/12 9:27a $ +#************************************************************************* +# Revision History +# ---------------- +# $Log: /Alaska/SOURCE/Modules/SharkBayRefCodes/DPTF/DptfGuidLib/DptfGuidLib.mak $ +# +# 1 4/24/12 9:27a Victortu +# +#************************************************************************* +#<AMI_FHDR_START> +# +# Name: DptfGuidLib.mak +# +# Description: MAke file to build Intel DPTF GuidLib components +# +#<AMI_FHDR_END> +#************************************************************************* +all : DptfGuidLib + +$(DptfGuidLib_LIB) : DptfGuidLib + +DptfGuidLib : $(BUILD_DIR)\DptfGuidLib.mak DptfGuidLibBin + +$(BUILD_DIR)\DptfGuidLib.mak : $(INTEL_DPTF_GUIDLIB_DIR)\$(@B).cif $(INTEL_DPTF_GUIDLIB_DIR)\$(@B).mak $(BUILD_RULES) + $(CIF2MAK) $(INTEL_DPTF_GUIDLIB_DIR)\$(@B).cif $(CIF2MAK_DEFAULTS) + +DptfGuidLib_INCLUDES=\ + $(EDK_INCLUDES)\ + $(EdkIIGlueLib_INCLUDES) + +DptfGuidLibBin : + $(MAKE) /$(MAKEFLAGS) $(EDKIIGLUE_DEFAULTS)\ + /f $(BUILD_DIR)\DptfGuidLib.mak all\ + "MY_INCLUDES=$(DptfGuidLib_INCLUDES)" \ + TYPE=LIBRARY + +#********************************************************************** +#********************************************************************** +#** ** +#** (C)Copyright 1985-2012, American Megatrends, Inc. ** +#** ** +#** All Rights Reserved. ** +#** ** +#** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +#** ** +#** Phone: (770)-246-8600 ** +#** ** +#********************************************************************** +#**********************************************************************
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.sdl b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.sdl new file mode 100644 index 0000000..ffd5a8b --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/Guid/DptfGuidLib.sdl @@ -0,0 +1,37 @@ +TOKEN + Name = DptfGuidLib_SUPPORT + Value = 1 + TokenType = Boolean + TargetEQU = Yes + TargetMAK = Yes + Master = Yes + Help = "Main switch to enable DptfGuidLib support in Project" +End + +MODULE + Help = "Includes DptfGuidLib.mak to Project" + File = "DptfGuidLib.mak" +End + +PATH + Name = "INTEL_DPTF_GUIDLIB_DIR" +End + +TOKEN + Name = "DptfGuidLib_LIB" + Value = "$(BUILD_DIR)\DptfGuidLib.lib" + TokenType = Expression + TargetMAK = Yes +End + +ELINK + Name = "/I$(INTEL_DPTF_GUIDLIB_DIR)" + Parent = "DPTF_INCLUDES" + InvokeOrder = AfterParent +End + +ELINK + Name = "/I$(INTEL_DPTF_GUIDLIB_DIR)\AcpiTableStorage" + Parent = "DPTF_INCLUDES" + InvokeOrder = AfterParent +End
\ No newline at end of file diff --git a/ReferenceCode/AcpiTables/Dptf/ReleaseNotes.chm b/ReferenceCode/AcpiTables/Dptf/ReleaseNotes.chm Binary files differnew file mode 100644 index 0000000..20ed9ac --- /dev/null +++ b/ReferenceCode/AcpiTables/Dptf/ReleaseNotes.chm |