828 lines
28 KiB
Plaintext
828 lines
28 KiB
Plaintext
/** @file
|
|
|
|
;******************************************************************************
|
|
;* Copyright (c) 2019, Insyde Software Corp. All Rights Reserved.
|
|
;*
|
|
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
|
|
;* transmit, broadcast, present, recite, release, license or otherwise exploit
|
|
;* any part of this publication in any form, by any means, without the prior
|
|
;* written permission of Insyde Software Corporation.
|
|
;*
|
|
;******************************************************************************
|
|
*/
|
|
/** @file
|
|
ACPI DSDT table
|
|
|
|
@copyright
|
|
INTEL CONFIDENTIAL
|
|
Copyright 2011 - 2021 Intel Corporation.
|
|
|
|
The source code contained or described herein and all documents related to the
|
|
source code ("Material") are owned by Intel Corporation or its suppliers or
|
|
licensors. Title to the Material remains with Intel Corporation or its suppliers
|
|
and licensors. The Material may contain trade secrets and proprietary and
|
|
confidential information of Intel Corporation and its suppliers and licensors,
|
|
and is protected by worldwide copyright and trade secret laws and treaty
|
|
provisions. No part of the Material may be used, copied, reproduced, modified,
|
|
published, uploaded, posted, transmitted, distributed, or disclosed in any way
|
|
without Intel's prior express written permission.
|
|
|
|
No license under any patent, copyright, trade secret or other intellectual
|
|
property right is granted to or conferred upon you by disclosure or delivery
|
|
of the Materials, either expressly, by implication, inducement, estoppel or
|
|
otherwise. Any license under such intellectual property rights must be
|
|
express and approved by Intel in writing.
|
|
|
|
Unless otherwise agreed by Intel in writing, you may not remove or alter
|
|
this notice or any other notice embedded in Materials by Intel or
|
|
Intel's suppliers or licensors in any way.
|
|
|
|
This file contains a 'Sample Driver' and is licensed as such under the terms
|
|
of your license agreement with Intel or your vendor. This file may be modified
|
|
by the user, subject to the additional terms of the license agreement.
|
|
|
|
@par Specification Reference:
|
|
**/
|
|
|
|
//
|
|
// Defined as an SSDT to be able to dynamically load based on BIOS
|
|
// setup options
|
|
//
|
|
#include <Include/AcpiDebug.h>
|
|
|
|
DefinitionBlock (
|
|
"THERMAL.aml",
|
|
"SSDT",
|
|
0x02,
|
|
"TherRv",
|
|
"Ther_Rvp",
|
|
0x1000
|
|
)
|
|
{
|
|
|
|
External(\_SB.APSV)
|
|
External(\_SB.ACRT)
|
|
External(\_SB.AAC0)
|
|
External(\_SB.PR00)
|
|
External(\_SB.PR01)
|
|
External(\_SB.PR02)
|
|
External(\_SB.PR03)
|
|
External(\_SB.PR04)
|
|
External(\_SB.PR05)
|
|
External(\_SB.PR06)
|
|
External(\_SB.PR07)
|
|
External(\_SB.PR08)
|
|
External(\_SB.PR09)
|
|
External(\_SB.PR10)
|
|
External(\_SB.PR11)
|
|
External(\_SB.PR12)
|
|
External(\_SB.PR13)
|
|
External(\_SB.PR14)
|
|
External(\_SB.PR15)
|
|
External(\_SB.PR16)
|
|
External(\_SB.PR17)
|
|
External(\_SB.PR18)
|
|
External(\_SB.PR19)
|
|
External(\_SB.PR20)
|
|
External(\_SB.PR21)
|
|
External(\_SB.PR22)
|
|
External(\_SB.PR23)
|
|
External(\_SB.PR24)
|
|
External(\_SB.PR25)
|
|
External(\_SB.PR26)
|
|
External(\_SB.PR27)
|
|
External(\_SB.PR28)
|
|
External(\_SB.PR29)
|
|
External(\_SB.PR30)
|
|
External(\_SB.PR31)
|
|
|
|
External(\CTYP, IntObj)
|
|
External(\TCNT, IntObj)
|
|
External(\VFN0, IntObj)
|
|
External(\VFN1, IntObj)
|
|
External(\VFN2, IntObj)
|
|
External(\VFN3, IntObj)
|
|
External(\VFN4, IntObj)
|
|
External(\ECON, IntObj)
|
|
External(\AC0F, IntObj)
|
|
External(\AC1F, IntObj)
|
|
External(\CRTT, IntObj)
|
|
External(\PSVT, IntObj)
|
|
External(\ACTT, IntObj)
|
|
External(\ACT1, IntObj)
|
|
External(\TC1V, IntObj)
|
|
External(\TC2V, IntObj)
|
|
External(\TSPV, IntObj)
|
|
|
|
//[-start-190723-IB15410291-modify]//
|
|
#if FeaturePcdGet (PcdUseCrbEcFlag)
|
|
External(\_SB.PC00.LPCB.H_EC.ECAV, IntObj)
|
|
External(\_SB.PC00.LPCB.H_EC.ECRD, MethodObj)
|
|
External(\_SB.PC00.LPCB.H_EC.ECWT, MethodObj)
|
|
External(\_SB.PC00.LPCB.H_EC.ECMD, MethodObj)
|
|
External(\_SB.PC00.LPCB.H_EC.PENV, FieldUnitObj)
|
|
External(\_SB.PC00.LPCB.H_EC.PECH, FieldUnitObj)
|
|
External(\_SB.PC00.LPCB.H_EC.PECL, FieldUnitObj)
|
|
External(\_SB.PC00.LPCB.H_EC.PLMX, FieldUnitObj)
|
|
#endif
|
|
//[-end-190723-IB15410291-modify]//
|
|
|
|
// THERMAL.ASL represents a Thermal Zone to be used for testing on the
|
|
// Customer Reference Boards.
|
|
Scope(\_TZ)
|
|
{
|
|
|
|
// Notes:
|
|
// 1) WIN2K strictly uses interrupt driven thermal events.
|
|
// 2) Temperature values are stored in tenths of Kelvin to
|
|
// eliminate the decimal place.
|
|
// 3) Kelvin = Celsius + 273.2.
|
|
// 4) All temperature must be >= 289K.
|
|
|
|
Name(ETMD, 1)
|
|
|
|
//Fan Control Event
|
|
Event(FCET)
|
|
|
|
//Fan Control Running
|
|
Name(FCRN, 0)
|
|
Mutex(FCMT, 0)
|
|
|
|
//Cached Virtual Fan Status
|
|
Name(CVF0, 0)
|
|
Name(CVF1, 0)
|
|
Name(CVF2, 0)
|
|
Name(CVF3, 0)
|
|
Name(CVF4, 0)
|
|
|
|
//Cached Virtual Fan Status Mutexes
|
|
Mutex(FMT0, 0)
|
|
Mutex(FMT1, 0)
|
|
Mutex(FMT2, 0)
|
|
Mutex(FMT3, 0)
|
|
Mutex(FMT4, 0)
|
|
|
|
// Fan 0 = Package Processor Fan - Maximum speed
|
|
PowerResource(FN00, 0, 0)
|
|
{
|
|
Method(_STA, 0, Serialized)
|
|
{
|
|
Store(0, Local1)
|
|
Store (Acquire(FMT0, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
//Store Virtual Fan 0 status to local variable
|
|
Store(CVF0, Local1)
|
|
Release(FMT0)
|
|
}
|
|
// Return Virtual Fan 0 status.
|
|
Return(Local1)
|
|
}
|
|
|
|
// This method is called when the temperature goes above _AC0.
|
|
// Regardless of other FAN states, set to ACF0 since this is max cooling state: temp > _AC0
|
|
Method(_ON, 0, Serialized)
|
|
{
|
|
Store (Acquire(FMT0, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 0 On.
|
|
Store(1, CVF0)
|
|
Release(FMT0)
|
|
}
|
|
FNCL()
|
|
}
|
|
|
|
// This method is called when the temperature goes below _AC0.
|
|
// If FAN1 is on, use its value (AC1F): _AC0 > temp > _AC1
|
|
// If FAN1 is off, use FAN2 value (AC2F): _AC0 > _AC1 > temp
|
|
Method(_OFF, 0, Serialized)
|
|
{
|
|
Store (Acquire(FMT0, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 0 Off.
|
|
Store(0, CVF0)
|
|
Release(FMT0)
|
|
}
|
|
FNCL()
|
|
}
|
|
}
|
|
|
|
// Associate Virtual Fan 0 Power Resource with the FAN0 Device.
|
|
Device(FAN0)
|
|
{
|
|
Name(_HID, EISAID("PNP0C0B"))
|
|
Name(_UID,0)
|
|
Name(_PR0, Package(1){FN00})
|
|
}
|
|
|
|
// Fan 1 = Package Processor Fan.
|
|
PowerResource(FN01,0,0)
|
|
{
|
|
Method(_STA,0,Serialized)
|
|
{
|
|
Store(0, Local1)
|
|
Store (Acquire(FMT1, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
//Store Virtual Fan 1 status to local variable
|
|
Store(CVF1, Local1)
|
|
Release(FMT1)
|
|
}
|
|
// Return Virtual Fan 1 status.
|
|
Return(Local1)
|
|
}
|
|
|
|
// This method is called when the temperature goes above _AC1.
|
|
// If FAN0 is on, do nothing since we're already at AC0F: temp > _AC0 > _AC1
|
|
// If FAN0 is off, use FAN1 value (AC1F): _AC0 > temp > _AC1
|
|
Method(_ON,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT1, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 1 On.
|
|
Store(1, CVF1)
|
|
Release(FMT1)
|
|
}
|
|
FNCL()
|
|
}
|
|
|
|
// This method is called when the temperature goes below _AC1.
|
|
// If FAN2 is on, use its value (AC2F): _AC1 > temp > _AC2
|
|
// If FAN2 is off, use FAN3 value (AC3F): _AC1 > _AC2 > temp
|
|
Method(_OFF,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT1, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 1 Off.
|
|
Store(0, CVF1)
|
|
Release(FMT1)
|
|
}
|
|
FNCL()
|
|
}
|
|
}
|
|
|
|
// Associate Virtual Fan 1 Power Resource with the FAN1 Device.
|
|
Device(FAN1)
|
|
{
|
|
Name(_HID, EISAID("PNP0C0B"))
|
|
Name(_UID, 1)
|
|
Name(_PR0, Package(1){FN01})
|
|
}
|
|
|
|
|
|
// Fan 2 = Package Processor Fan.
|
|
PowerResource(FN02,0,0)
|
|
{
|
|
Method(_STA,0,Serialized)
|
|
{
|
|
Store(0, Local1)
|
|
Store (Acquire(FMT2, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
//Store Virtual Fan 2 status to local variable
|
|
Store(CVF2, Local1)
|
|
Release(FMT2)
|
|
}
|
|
// Return Virtual Fan 2 status.
|
|
Return(Local1)
|
|
}
|
|
|
|
// This method is called when the temperature goes above _AC2.
|
|
// If FAN1 is on, do nothing since we're already at AC1F or greater: temp > _AC1 > _AC2
|
|
// If FAN1 is off, use FAN2 value (AC2F): _AC1 > temp > _AC2
|
|
Method(_ON,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT2, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 2 On.
|
|
Store(1, CVF2)
|
|
Release(FMT2)
|
|
}
|
|
FNCL()
|
|
}
|
|
|
|
// This method is called when the temperature goes below _AC2.
|
|
// If FAN3 is on, use its value (AC3F): _AC2 > temp > _AC3
|
|
// If FAN3 is off, use FAN4 value (AC4F): _AC2 > _AC3 > temp
|
|
Method(_OFF,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT2, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 2 Off.
|
|
Store(0, CVF2)
|
|
Release(FMT2)
|
|
}
|
|
FNCL()
|
|
}
|
|
}
|
|
|
|
// Associate Virtual Fan 2 Power Resource with the FAN0 Device.
|
|
Device(FAN2)
|
|
{
|
|
Name(_HID, EISAID("PNP0C0B"))
|
|
Name(_UID, 2)
|
|
Name(_PR0, Package(1){FN02})
|
|
}
|
|
|
|
// Fan 3 = Package Processor Fan.
|
|
PowerResource(FN03,0,0)
|
|
{
|
|
Method(_STA,0,Serialized)
|
|
{
|
|
Store(0, Local1)
|
|
Store (Acquire(FMT3, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
//Store Virtual Fan 3 status to local variable
|
|
Store(CVF3, Local1)
|
|
Release(FMT3)
|
|
}
|
|
// Return Virtual Fan 3 status.
|
|
Return(Local1)
|
|
}
|
|
|
|
// This method is called when the temperature goes above _AC3.
|
|
// If FAN2 is on, do nothing since we're already at AC2F or greater: temp > _AC2 > _AC3
|
|
// If FAN2 is off, use FAN3 value (AC3F): _AC2 > temp > _AC3
|
|
Method(_ON,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT3, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 3 On.
|
|
Store(1, CVF3)
|
|
Release(FMT3)
|
|
}
|
|
FNCL()
|
|
}
|
|
|
|
// This method is called when the temperature goes below _AC3.
|
|
// If FAN4 is on, use its value (AC4F): _AC3 > temp > _AC4
|
|
// If FAN4 is off, use FAN5 value (AC5F): _AC3 > _AC4 > temp
|
|
Method(_OFF,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT3, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 3 Off.
|
|
Store(0, CVF3)
|
|
Release(FMT3)
|
|
}
|
|
FNCL()
|
|
}
|
|
}
|
|
|
|
// Associate Virtual Fan 3 Power Resource with the FAN3 Device.
|
|
Device(FAN3)
|
|
{
|
|
Name(_HID, EISAID("PNP0C0B"))
|
|
Name(_UID, 3)
|
|
Name(_PR0, Package(1){FN03})
|
|
}
|
|
|
|
// Fan 4 = Package Processor Fan - Lowest Fan Speed
|
|
PowerResource(FN04,0,0)
|
|
{
|
|
Method(_STA,0,Serialized)
|
|
{
|
|
Store(0, Local1)
|
|
Store (Acquire(FMT4, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
//Store Virtual Fan 4 status to local variable
|
|
Store(CVF4, Local1)
|
|
Release(FMT4)
|
|
}
|
|
// Return Virtual Fan 4 status.
|
|
Return(Local1)
|
|
}
|
|
|
|
// This method is called when the temperature goes above _AC4.
|
|
// If FAN3 is on, do nothing since we're already at AC3F or greater: temp > _AC3 > _AC4
|
|
// If FAN3 is off, use FAN4 value (AC4F): _AC3 > temp > _AC4
|
|
Method(_ON,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT4, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 4 On.
|
|
Store(1, CVF4)
|
|
Release(FMT4)
|
|
}
|
|
FNCL()
|
|
}
|
|
|
|
// This method is called when the temperature goes below _AC4.
|
|
// FAN4 is the lowest FAN state defined, so we simply go to AC4F
|
|
Method(_OFF,0,Serialized)
|
|
{
|
|
Store (Acquire(FMT4, 1000), Local0) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local0, Zero)) // check for Mutex acquired
|
|
{
|
|
// Set Virtual Fan 4 Off.
|
|
Store(0, CVF4)
|
|
Release(FMT4)
|
|
}
|
|
FNCL()
|
|
}
|
|
}
|
|
|
|
// Associate Virtual Fan 4 Power Resource with the FAN4 Device.
|
|
Device(FAN4)
|
|
{
|
|
Name(_HID, EISAID("PNP0C0B"))
|
|
Name(_UID, 4)
|
|
Name(_PR0, Package(1){FN04})
|
|
}
|
|
|
|
//
|
|
// Fan Control Method
|
|
//
|
|
Method(FNCL, 0, NotSerialized)
|
|
{
|
|
//If we get here, then we need to actually update the Fan Speed
|
|
//First get the state of the Virtual Fans
|
|
Store(0, Local0)
|
|
Store(0, Local1)
|
|
Store(0, Local2)
|
|
Store(0, Local3)
|
|
Store(0, Local4)
|
|
Store (Acquire(FMT0, 1000), Local5) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local5, Zero)) // check for Mutex acquired
|
|
{
|
|
Store(CVF0, Local0)
|
|
Release(FMT0)
|
|
}
|
|
Store (Acquire(FMT1, 1000), Local5) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local5, Zero)) // check for Mutex acquired
|
|
{
|
|
Store(CVF1, Local1)
|
|
Release(FMT1)
|
|
}
|
|
Store (Acquire(FMT2, 1000), Local5) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local5, Zero)) // check for Mutex acquired
|
|
{
|
|
Store(CVF2, Local2)
|
|
Release(FMT2)
|
|
}
|
|
Store (Acquire(FMT3, 1000), Local5) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local5, Zero)) // check for Mutex acquired
|
|
{
|
|
Store(CVF3, Local3)
|
|
Release(FMT3)
|
|
}
|
|
Store (Acquire(FMT4, 1000), Local5) // save Acquire result so we can check for Mutex acquired
|
|
If (LEqual(Local5, Zero)) // check for Mutex acquired
|
|
{
|
|
Store(CVF4, Local4)
|
|
Release(FMT4)
|
|
}
|
|
|
|
//Update the Global NVS Variables
|
|
Store(Local0, \VFN0)
|
|
Store(Local1, \VFN1)
|
|
Store(Local2, \VFN2)
|
|
Store(Local3, \VFN3)
|
|
Store(Local4, \VFN4)
|
|
//[-start-190723-IB15410291-modify]//
|
|
#if FeaturePcdGet (PcdUseCrbEcFlag)
|
|
If (\ECON)
|
|
{
|
|
//Send EC commands to actually update the fan
|
|
If(LAnd(\_SB.PC00.LPCB.H_EC.ECAV, ETMD))
|
|
{
|
|
//Virtual Fan0 and Fan1 are On - Set Real Fan to Full Speed
|
|
If(LAnd(LNotEqual(Local0, 0), LNotEqual(Local1, 0)))
|
|
{
|
|
\_SB.PC00.LPCB.H_EC.ECWT(AC0F, RefOf(\_SB.PC00.LPCB.H_EC.PENV)) // AC0F
|
|
}
|
|
Else
|
|
{
|
|
//Virtual Fan0 is Off, Virtual Fan1 is On - Set Real Fan to 75% Speed
|
|
If(LAnd(LEqual(Local0, 0), LNotEqual(Local1, 0)))
|
|
{
|
|
\_SB.PC00.LPCB.H_EC.ECWT(AC1F, RefOf(\_SB.PC00.LPCB.H_EC.PENV)) // AC1F
|
|
}
|
|
//Otherwise - Turn the Real Fan Off
|
|
Else
|
|
{
|
|
\_SB.PC00.LPCB.H_EC.ECWT(0, RefOf(\_SB.PC00.LPCB.H_EC.PENV))
|
|
}
|
|
}
|
|
\_SB.PC00.LPCB.H_EC.ECMD(0x1a)
|
|
}
|
|
}
|
|
#endif
|
|
//[-end-190723-IB15410291-modify]//
|
|
}
|
|
|
|
// Thermal Zone 0 = Package Thermal Zone.
|
|
// Package Thermal Zone is used for Active and Critical Policy Control
|
|
// Package Thermal Zone returns the maximum temperature
|
|
// of all components within the package
|
|
ThermalZone(TZ00)
|
|
{
|
|
// Temporary variable for holding the current temperature reading
|
|
Name(PTMP,3000)
|
|
|
|
// Notifies ASL Code the current cooling mode.
|
|
// 0 - Active cooling
|
|
// 1 - Passive cooling
|
|
Method(_SCP, 1, Serialized)
|
|
{
|
|
Store(Arg0,\CTYP)
|
|
}
|
|
|
|
// Return the temperature at which the OS performs Critical Shutdown
|
|
Method(_CRT, 0, Serialized)
|
|
{
|
|
// Returns automatic thermal reporting temperature for CPU throttling if available and valid.
|
|
If(CondRefOf(\_SB.ACRT))
|
|
{
|
|
If(LNotEqual(\_SB.ACRT,0))
|
|
{
|
|
Return(Add(2732, Multiply(\_SB.ACRT, 10)))
|
|
}
|
|
}
|
|
|
|
Return(Add(2732, Multiply(\CRTT, 10)))
|
|
}
|
|
|
|
// Return the temperature(s) at which the OS initiates Active Cooling.
|
|
Method(_AC0, 0, Serialized)
|
|
{
|
|
// Returns automatic thermal reporting temperature for CPU throttling if available and valid.
|
|
If(CondRefOf(\_SB.AAC0))
|
|
{
|
|
If(LNotEqual(\_SB.AAC0,0))
|
|
{
|
|
Return(Add(2732, Multiply(\_SB.AAC0, 10)))
|
|
}
|
|
}
|
|
Return(Add(2732, Multiply(\ACTT, 10)))
|
|
}
|
|
|
|
Method(_AC1, 0, Serialized)
|
|
{
|
|
Return(Add(2732, Multiply(\ACT1, 10)))
|
|
}
|
|
|
|
Method(_AC2, 0, Serialized)
|
|
{
|
|
Return(Subtract(Add(2732, Multiply(\ACT1, 10)), 50)) // subtract 5 degrees from _AC1
|
|
}
|
|
|
|
Method(_AC3, 0, Serialized)
|
|
{
|
|
Return(Subtract(Add(2732, Multiply(\ACT1, 10)), 100)) // subtract 10 degrees from _AC1
|
|
}
|
|
|
|
Method(_AC4, 0, Serialized)
|
|
{
|
|
Return(Subtract(Add(2732, Multiply(\ACT1, 10)), 150)) // subtract 15 degrees from _AC1
|
|
}
|
|
|
|
// Return the device(s) to turn on when _ACx is exceeded.
|
|
Name(_AL0, Package(){FAN0})
|
|
Name(_AL1, Package(){FAN1})
|
|
Name(_AL2, Package(){FAN2})
|
|
Name(_AL3, Package(){FAN3})
|
|
Name(_AL4, Package(){FAN4})
|
|
|
|
// Return the Package Temperature.
|
|
// Source : Max Platform temperature returned by EC
|
|
Method(_TMP, 0, Serialized)
|
|
{
|
|
If (LNot(ETMD)) // If Legacy TM is disabled, return static value
|
|
{
|
|
Return (3000)
|
|
}
|
|
|
|
// Source : Max Platform temperature returned by EC
|
|
// If EC enabled/available
|
|
//[-start-190723-IB15410291-modify]//
|
|
#if FeaturePcdGet (PcdUseCrbEcFlag)
|
|
If(\ECON)
|
|
{
|
|
// Store current reading in temporary variable
|
|
Store(\_SB.PC00.LPCB.H_EC.ECRD(RefOf(\_SB.PC00.LPCB.H_EC.PLMX)), Local0) // Max Platform temperature
|
|
Add(2732, Multiply(Local0, 10), Local0)
|
|
Store(Local0, PTMP)
|
|
Return(Local0)
|
|
}
|
|
#endif
|
|
//[-end-190723-IB15410291-modify]//
|
|
// Return a static value if no source is available.
|
|
Return(3010)
|
|
}
|
|
|
|
// Return the Processor(s) used for Passive Cooling.
|
|
Method(_PSL, 0, Serialized)
|
|
{
|
|
If(LEqual(\TCNT, 32))
|
|
{
|
|
// CMP - Throttling controls 32 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26, \_SB.PR27, \_SB.PR28, \_SB.PR29, \_SB.PR30, \_SB.PR31})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 31))
|
|
{
|
|
// CMP - Throttling controls 31 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26, \_SB.PR27, \_SB.PR28, \_SB.PR29, \_SB.PR30})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 30))
|
|
{
|
|
// CMP - Throttling controls 30 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26, \_SB.PR27, \_SB.PR28, \_SB.PR29})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 29))
|
|
{
|
|
// CMP - Throttling controls 29 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26, \_SB.PR27, \_SB.PR28})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 28))
|
|
{
|
|
// CMP - Throttling controls 28 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26, \_SB.PR27})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 27))
|
|
{
|
|
// CMP - Throttling controls 27 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25, \_SB.PR26})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 26))
|
|
{
|
|
// CMP - Throttling controls 26 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24, \_SB.PR25})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 25))
|
|
{
|
|
// CMP - Throttling controls 25 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23, \_SB.PR24})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 24))
|
|
{
|
|
// CMP - Throttling controls 24 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22, \_SB.PR23})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 23))
|
|
{
|
|
// CMP - Throttling controls 23 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21, \_SB.PR22})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 22))
|
|
{
|
|
// CMP - Throttling controls 22 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20, \_SB.PR21})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 21))
|
|
{
|
|
// CMP - Throttling controls 21 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19, \_SB.PR20})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 20))
|
|
{
|
|
// CMP - Throttling controls 20 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18, \_SB.PR19})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 19))
|
|
{
|
|
// CMP - Throttling controls 19 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17, \_SB.PR18})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 18))
|
|
{
|
|
// CMP - Throttling controls 18 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16, \_SB.PR17})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 17))
|
|
{
|
|
// CMP - Throttling controls 17 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15, \_SB.PR16})
|
|
}
|
|
If(LEqual(\TCNT, 16))
|
|
{
|
|
// CMP - Throttling controls 16 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13,\_SB.PR14,\_SB.PR15})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 14))
|
|
{
|
|
// CMP - Throttling controls 14 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11,\_SB.PR12,\_SB.PR13})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 12))
|
|
{
|
|
// CMP - Throttling controls 12 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09,\_SB.PR10,\_SB.PR11})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 10))
|
|
{
|
|
// CMP - Throttling controls 10 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07,\_SB.PR08,\_SB.PR09})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 8))
|
|
{
|
|
// CMP - Throttling controls 8 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06,\_SB.PR07})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 7))
|
|
{
|
|
// CMP - Throttling controls 7 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05,\_SB.PR06})
|
|
}
|
|
|
|
|
|
If(LEqual(\TCNT, 6))
|
|
{
|
|
// CMP - Throttling controls 6 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04,\_SB.PR05})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 5))
|
|
{
|
|
// CMP - Throttling controls 5 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03,\_SB.PR04})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 4))
|
|
{
|
|
// CMP - Throttling controls 4 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02,\_SB.PR03})
|
|
}
|
|
|
|
If(LEqual(\TCNT, 3))
|
|
{
|
|
// CMP - Throttling controls 3 logical CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01,\_SB.PR02})
|
|
}
|
|
|
|
|
|
If(LEqual(\TCNT, 2))
|
|
{
|
|
// CMP - Throttling controls 2 CPUs.
|
|
Return(Package(){\_SB.PR00,\_SB.PR01})
|
|
}
|
|
|
|
Return(Package(){\_SB.PR00})
|
|
}
|
|
|
|
// Returns the temperature at which the OS initiates CPU throttling.
|
|
Method(_PSV, 0, Serialized)
|
|
{
|
|
// Returns automatic thermal reporting temperature for CPU throttling if available and valid.
|
|
If(CondRefOf(\_SB.APSV))
|
|
{
|
|
If(LNotEqual(\_SB.APSV,0))
|
|
{
|
|
Return(Add(2732, Multiply(\_SB.APSV, 10)))
|
|
}
|
|
}
|
|
Return(Add(2732, Multiply(\PSVT, 10)))
|
|
}
|
|
|
|
// Returns TC1 value used in the passive cooling formula.
|
|
Method(_TC1, 0, Serialized)
|
|
{
|
|
Return(\TC1V)
|
|
}
|
|
|
|
// Returns TC2 value used in the passive cooling formula.
|
|
Method(_TC2, 0, Serialized)
|
|
{
|
|
Return(\TC2V)
|
|
}
|
|
|
|
// Returns the sampling period used in the passive cooling formula.
|
|
Method(_TSP, 0, Serialized)
|
|
{
|
|
Return(\TSPV)
|
|
}
|
|
}
|
|
}
|
|
}
|