/** @file Copyright (c) 1999 - 2016, Intel Corporation. All rights reserved.
This program and the accompanying materials are licensed and made available under the terms and conditions of the BSD License which accompanies this distribution. The full text of the license may be found at http://opensource.org/licenses/bsd-license.php. THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. **/ Scope(\_SB.PCI0) { Device(TCPU) { Name(_ADR, 0x00000001) // Intel Dptf Processor Device 0, Function 1 Name(GTSH, 20) // Hystersis, 2 Degree clesius 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(\DPSR,0)) { Return(0x00) } Return(0x0F) } // 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 (PPCC, Package() { 0x2, //Revision Package () { //Power Limit 1 0, //PowerLimitIndex, 0 for Power Limit 1 1000, //PowerLimitMinimum in mW 15000, //PowerLimitMaximum 1000, //TimeWindowMinimum 1000, //TimeWindowMaximum 250 //StepSize } }) // _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 ("cpudptf: SPPC Called", Debug) If (CondRefOf(\_PR.CPU0._PPC)) { Store(Arg0,\_PR.CPU0._PPC) // Note: _PPC must be an Integer not a Method } Notify(\_PR.CPU0, 0x80) // Tell P000 driver to re-eval _PPC Notify(\_PR.CPU1, 0x80) // Tell P000 driver to re-eval _PPC Notify(\_PR.CPU2, 0x80) // Tell P000 driver to re-eval _PPC Notify(\_PR.CPU3, 0x80) // Tell P000 driver to re-eval _PPC } // _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) // } // Method(_PSS,,,,PkgObj) { Store ("cpudptf: _PSS Called", Debug) 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) // } // Method(_TSS,,,,PkgObj) { Store ("cpudptf: _TSS Called", Debug) 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) { Store ("cpudptf: _TPC Called", Debug) If (CondRefOf(\_PR.CPU0._TPC)) { 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) // // Arguments: (0) // None // Return Value: // A Package as described below // // Return Value Information // Package { // ControlRegister // Buffer (Resource Descriptor) // StatusRegister // Buffer (Resource Descriptor) // } // Method(_PTC) { Store ("cpudptf: _PTC Called", Debug) If (CondRefOf(\_PR.CPU0._PTC)) { Return(\_PR.CPU0._PTC()) } Else { Return(Package(){ ResourceTemplate (){Register (FFixedHW,0,0,0)}, ResourceTemplate (){Register (FFixedHW,0,0,0)} }) } } // _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) { Store ("cpudptf: _TSD Called", Debug) 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) { Store ("cpudptf: _TDL Called", Debug) If (CondRefOf(\_PR.CPU0._TDL)) { Return(\_PR.CPU0._TDL()) } 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) { Store ("cpudptf: _PDL Called", Debug) If (CondRefOf(\_PR.CPU0._PSS)) { // Ensure _PSS is present // OSSL means OS Selection, WOS is Zero, AOS is One If (LEqual(\OSSL,1)) { Return(Subtract(SizeOf(\_PR.CPU0.SPSS),1)) // PSS entry for AOS } Else { Return(Subtract(SizeOf(\_PR.CPU0.NPSS),1)) // PSS entry for WOS } } Else { Return(0) } } // _TSP (Thermal Sampling Period) // // Sets the polling interval in 10ths of seconds. A value of 0 tells the driver to use interrupts. // // Arguments: (0) // None // Return Value: // An Integer containing the polling rate in tenths of seconds. // A value of 0 will specify using interrupts through the ACPI notifications. // // The granularity of the sampling period is 0.1 seconds. For example, if the sampling period is 30.0 // seconds, then _TSP needs to report 300; if the sampling period is 0.5 seconds, then it will report 5. // Method(_TSP,0,Serialized) { Return(\CPUS) } // _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,0,Serialized) { If (LEqual(\DPAT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(\_SB.IETM.CTOK(\DPAT)) // 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(_AC1,0,Serialized) { If (LEqual(\DPAT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(Subtract(\_SB.IETM.CTOK(\DPAT),200)) // 20 degrees less than _AC0 } // _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,0,Serialized) { If (LEqual(\DPAT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(Subtract(\_SB.IETM.CTOK(\DPAT),300)) // 30 degrees less than _AC0 } // _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 (LEqual(\DPPT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(\_SB.IETM.CTOK(\DPPT)) // Passive Cooling Policy. Have this in Global NVS } // _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) { If (LEqual(\DPCT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(\_SB.IETM.CTOK(\DPCT)) } // _CR3 (Critical Temperature for S3/CS) // // This object, when defined under a thermal zone, returns the critical temperature at which OSPM // must transition to Standby or Connected Standy. // // Arguments: (0) // None // Return Value: // An Integer containing the critical temperature threshold in tenths of degrees Kelvin // Method(_CR3,0,Serialized) { If (LEqual(\DPC3,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(\_SB.IETM.CTOK(\DPC3)) } // _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) { If (LEqual(\DPHT,0)) {Return(0xFFFFFFFF)} // signal DPTF driver to disable trip point Return(\_SB.IETM.CTOK(\DPHT)) } // _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) Notify(TCPU, 0x91) } } Name(VERS,0) // Version Name(CTYP, 0) // Device specific cooling policy type Name(ALMT,0) // Acoustic Limit Name(PLMT,0) // Power Limit Name(WKLD,0) // Workload Hint Name(DSTA,0) // Device State Hint Name(RES1,0) // Reserved 1 // DSCP (DPTF Set Cooling Policy) // // Arguments: (7) // Arg0 - Version: For DPTF 8.0, this value is always 0. // Arg1 - Mode: Integer containing the cooling mode policy code // Arg2 - Acoustic Limit: Acoustic Limit value as defined in ACPI specification // Arg3 - Power Limit: Power Limit value as defined in ACPI specification // Arg4 - Workload Hint: Arbitrary Platform defined Integer that indicates to the platform the type of workload run in the OS. // Arg5 - Device State Hint: An integer value that indicates the state of the device. // Arg6 - Reserved 1 // Return Value: // None // // Argument Information: // Mode: 0 = Active(Typically AC Power Source), 1 = Passive(Typically Battery Power Source) // 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. // Workload Hint: Refer to Intel DPTF Configuration Guide on how to set this value for various workloads for each Operating System. // Device State Hint: An integer value that indicates the state of the device. // First byte indicates portrait or landscape mode. // Second byte indicates horizontal or vertical orientation. // Third byte indicates proximity sensor status (if available). // Fourth byte is unused. // xxxxxx00h: Portrait // xxxxxx01h: Landscape // xxxx00xxh: Horizontal // xxxx01xxh: Vertical // xx00xxxxh: Proximity sensor Off (Device not in proximity to user) // xx01xxxxh: Proximity sensor On (Device in proximity to user) // Method(DSCP, 7, Serialized) { If (LOr(LEqual(Arg1,0),LEqual(Arg1,1))) { Store(Arg0, VERS) Store(Arg1, CTYP) Store(Arg2, ALMT) Store(Arg3, PLMT) Store(Arg4, WKLD) Store(Arg5, DSTA) Store(Arg6, RES1) Notify(TCPU, 0x91) } } } // End Device(TCPU) } // End Scope(\_SB.PCI0)