780 lines
25 KiB
Plaintext
780 lines
25 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:
|
|
**/
|
|
|
|
#include "PlatformBoardId.h"
|
|
#include <Include/AcpiDebug.h>
|
|
#include <Register/PmcRegs.h>
|
|
|
|
// Definitions for INTB (Interrupt descriptor buffer method)
|
|
#define INT_LEVEL_TRIG 0
|
|
#define INT_EDGE_TRIG 1
|
|
#define INT_ACTIVE_LOW 0
|
|
#define INT_ACTIVE_HIGH 1
|
|
|
|
DefinitionBlock (
|
|
"DSDT.aml",
|
|
"DSDT",
|
|
0x02, // DSDT revision.
|
|
// A Revision field value greater than or equal to 2 signifies that integers
|
|
// declared within the Definition Block are to be evaluated as 64-bit values
|
|
"INTEL", // OEM ID (6 byte string)
|
|
"SKL ",// OEM table ID (8 byte string)
|
|
0x0 // OEM version of DSDT table (4 byte Integer)
|
|
)
|
|
|
|
// BEGIN OF ASL SCOPE
|
|
{
|
|
External(\_SB.PC00.GFX0.ALSI)
|
|
External(\_SB.PC00.GFX0.CLID)
|
|
External(\_SB.PC00.GFX0.CDCK)
|
|
External(\_SB.PC00.GFX0.CBLV)
|
|
External(\_SB.PC00.GFX0.GSSE)
|
|
External(\_SB.PC00.GFX0.DD1F, DeviceObj)
|
|
External(\_SB.PC00.GFX0.DD2F, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT0, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT1, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT2, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT3, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT4, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT5, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT6, DeviceObj)
|
|
External(\_SB.PC00.SAT0.PRT7, DeviceObj)
|
|
External(\_SB.PC00.GFX0.GDCK, MethodObj)
|
|
External(\_SB.PC00.GFX0.GHDS, MethodObj)
|
|
External(\_SB.PC00.GFX0.AINT, MethodObj)
|
|
External(\_SB.PC00.GFX0.GLID, MethodObj)
|
|
External(\_SB.PC00.GFX0.GSCI, MethodObj)
|
|
External(\_SB.PC00.RP01, DeviceObj)
|
|
External(\_SB.PC00.RP02, DeviceObj)
|
|
External(\_SB.PC00.RP03, DeviceObj)
|
|
External(\_SB.PC00.RP04, DeviceObj)
|
|
External(\_SB.PC00.RP05, DeviceObj)
|
|
External(\_SB.PC00.RP06, DeviceObj)
|
|
External(\_SB.PC00.RP07, DeviceObj)
|
|
External(\_SB.PC00.RP08, DeviceObj)
|
|
External(\_SB.PC00.RP09, DeviceObj)
|
|
External(\_SB.PC00.RP10, DeviceObj)
|
|
External(\_SB.PC00.RP11, DeviceObj)
|
|
External(\_SB.PC00.RP12, DeviceObj)
|
|
External(\_SB.PC00.RP13, DeviceObj)
|
|
External(\_SB.PC00.RP14, DeviceObj)
|
|
External(\_SB.PC00.RP15, DeviceObj)
|
|
External(\_SB.PC00.RP16, DeviceObj)
|
|
External(\_SB.PC00.RP17, DeviceObj)
|
|
External(\_SB.PC00.RP18, DeviceObj)
|
|
External(\_SB.PC00.RP19, DeviceObj)
|
|
External(\_SB.PC00.RP20, DeviceObj)
|
|
External(\_SB.PC00.RP21, DeviceObj)
|
|
External(\_SB.PC00.RP22, DeviceObj)
|
|
External(\_SB.PC00.RP23, DeviceObj)
|
|
External(\_SB.PC00.RP24, DeviceObj)
|
|
External(\_SB.PC00.RP25, DeviceObj)
|
|
External(\_SB.PC00.RP26, DeviceObj)
|
|
External(\_SB.PC00.RP27, DeviceObj)
|
|
External(\_SB.PC00.RP28, DeviceObj)
|
|
External(\_SB.PR00._PSS, MethodObj)
|
|
External(\_SB.PR00.LPSS, PkgObj)
|
|
External(\_SB.PR00.TPSS, PkgObj)
|
|
External(\_SB.PR00._PPC, MethodObj)
|
|
External(\_SB.CPPC, IntObj)
|
|
External(\_TZ.TZ00, DeviceObj)
|
|
External(\_TZ.ETMD, IntObj)
|
|
External(\_TZ.FN00._OFF, MethodObj)
|
|
External(\_SB.PC00.TXHC, DeviceObj) // CPU XHCI object of TCSS, it is a must existed object for CPU TCSS
|
|
External (\STD3, FieldUnitObj) // 0: D3 disable. 1: D3Hot support for Storages. 2: D3Cold support for Storages.
|
|
External(DGBA)
|
|
External(\_SB.PC00.PEG1.CLID)
|
|
External(\_SB.PC00.PEG1.CBLV)
|
|
External(\_SB.PC00.PEG1.DLID, MethodObj)
|
|
|
|
// Miscellaneous services enabled in Project
|
|
|
|
Name (SANB, 0xFFFF0000) // SA NVS Base address
|
|
Name (SANL, 0xAA55) // SA NVS Length
|
|
|
|
Include ("PcieRpObjCommonExternalInclude.asl")
|
|
|
|
Include ("SaNvs.asl")
|
|
Include ("AmlUpd.asl")
|
|
Include ("PlatformNvs.asl")
|
|
Include ("PciTree.asl")
|
|
Include ("TimeAndAlarmDevice.asl")
|
|
Include ("AcpiAssert.asl")
|
|
//[-start-190717-IB15410291-add]//
|
|
Include ("OemPlatformNvs.asl")
|
|
//[-start-200831-IB17800087-modify]//
|
|
#ifdef ACPI_DEBUG_FLAG
|
|
Include ("Memdbg.asl")
|
|
#endif
|
|
//[-end-200831-IB17800087-modify]//
|
|
//[-end-190717-IB15410291-add]//
|
|
|
|
if(LEqual(ECR1,1)){
|
|
Scope(\_SB.PC00) {
|
|
//
|
|
// PCI-specific method's GUID
|
|
//
|
|
Name(PCIG, ToUUID("E5C937D0-3553-4d7a-9117-EA4D19C3434D"))
|
|
//
|
|
// PCI's _DSM - an attempt at modular _DSM implementation
|
|
// When writing your own _DSM function that needs to include PCI-specific methods, do this:
|
|
//
|
|
// Method(_YOUR_DSM,4){
|
|
// if(Lequal(Arg0,PCIG)) { return(PCID(Arg0,Arg1,Arg2,Arg3)) }
|
|
// ...continue your _DSM by checking different GUIDs...
|
|
// else { return(0) }
|
|
// }
|
|
//
|
|
Method(PCID, 4, Serialized) {
|
|
If(LEqual(Arg0, PCIG)) { // PCIE capabilities UUID
|
|
If(LGreaterEqual(Arg1,3)) { // revision at least 3
|
|
If(LEqual(Arg2,0)) { Return (Buffer(2){0x01,0x03}) } // function 0: list of supported functions
|
|
If(LEqual(Arg2,8)) { Return (1) } // function 8: Avoiding Power-On Reset Delay Duplication on Sx Resume
|
|
If(LEqual(Arg2,9)) { Return (Package(5){50000,Ones,Ones,50000,Ones}) } // function 9: Specifying Device Readiness Durations
|
|
}
|
|
}
|
|
return (Buffer(1){0})
|
|
}
|
|
}//scope
|
|
}//if
|
|
|
|
Scope(\_SB.PC00) {
|
|
//PciCheck, Arg0=UUID, returns true if support for 'PCI delays optimization ECR' is enabled and the UUID is correct
|
|
Method(PCIC,1,Serialized) {
|
|
If(LEqual(ECR1,1)) {
|
|
If(LEqual(Arg0, PCIG)) {
|
|
return (1)
|
|
}
|
|
}
|
|
return (0)
|
|
}
|
|
|
|
//
|
|
// Create I2C Bus Resource descriptor for _CRS usage
|
|
// Arg0 - I2C bus address of the connection (Peripheral Address)
|
|
// Arg1 - I2C controller number (Resource Source)
|
|
// Returns buffer with 'I2cSerialBus' resource descriptor
|
|
//
|
|
Method (IICB, 2, Serialized) {
|
|
Switch (ToInteger(Arg1)) {
|
|
Case(0) { Name (IIC0, ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C0", 0x00, ResourceConsumer, DEV0,) })
|
|
CreateWordField (IIC0, DEV0._ADR, DAD0)
|
|
Store (Arg0, DAD0)
|
|
Return (IIC0) }
|
|
Case(1) { Name (IIC1 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C1", 0x00, ResourceConsumer, DEV1,) })
|
|
CreateWordField (IIC1, DEV1._ADR, DAD1)
|
|
Store (Arg0, DAD1)
|
|
Return (IIC1) }
|
|
Case(2) { Name (IIC2 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C2", 0x00, ResourceConsumer, DEV2,) })
|
|
CreateWordField (IIC2, DEV2._ADR, DAD2)
|
|
Store (Arg0, DAD2)
|
|
Return (IIC2) }
|
|
Case(3) { Name (IIC3 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C3", 0x00, ResourceConsumer, DEV3,) })
|
|
CreateWordField (IIC3, DEV3._ADR, DAD3)
|
|
Store (Arg0, DAD3)
|
|
Return (IIC3) }
|
|
Case(4) { Name (IIC4 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C4", 0x00, ResourceConsumer, DEV4,) })
|
|
CreateWordField (IIC4, DEV4._ADR, DAD4)
|
|
Store (Arg0, DAD4)
|
|
Return (IIC4) }
|
|
Case(5) { Name (IIC5 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C5", 0x00, ResourceConsumer, DEV5,) })
|
|
CreateWordField (IIC5, DEV5._ADR, DAD5)
|
|
Store (Arg0, DAD5)
|
|
Return (IIC5) }
|
|
Case(6) { Name (IIC6 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C6", 0x00, ResourceConsumer, DEV6,) })
|
|
CreateWordField (IIC6, DEV6._ADR, DAD6)
|
|
Store (Arg0, DAD6)
|
|
Return (IIC6) }
|
|
Case(7) { Name (IIC7 , ResourceTemplate () { I2cSerialBus (0, ControllerInitiated, 400000, AddressingMode7Bit,
|
|
"\\_SB.PC00.I2C7", 0x00, ResourceConsumer, DEV7,) })
|
|
CreateWordField (IIC7, DEV7._ADR, DAD7)
|
|
Store (Arg0, DAD7)
|
|
Return (IIC7) }
|
|
Default {Return (0)}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Create I2C Bus Resource descriptor for _CRS usage
|
|
// Arg0 - I2C bus address of the connection (Peripheral Address)
|
|
// Arg1 - I2C Device number
|
|
// Returns buffer with 'I2cSerialBus' resource descriptor
|
|
//
|
|
Method (VIIC, 2, Serialized) {
|
|
Switch (ToInteger (Arg1))
|
|
{
|
|
Case (Zero) // When virtual I2C device VIC0 is selected
|
|
{
|
|
Name (VI00, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS07.VIC0",
|
|
0x00, ResourceConsumer, VI0P,)
|
|
})
|
|
Name (VI01, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS06.VIC0",
|
|
0x00, ResourceConsumer, VI0M,)
|
|
})
|
|
Name (VI02, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS08.VIC0",
|
|
0x00, ResourceConsumer, VI0N,)
|
|
})
|
|
Name (VI03, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS03.VIC0",
|
|
0x00, ResourceConsumer, VI0O,)
|
|
})
|
|
// USB Port Mapping:
|
|
// 3 : ADL M AEP
|
|
// 6 : ADL M
|
|
// 7 : ADL P
|
|
// 8 : ADL P AEP
|
|
//
|
|
If(LEqual (CUPN,0x06)) {
|
|
CreateWordField (VI01, VI0M._ADR, DAQ0)
|
|
Store (Arg0, DAQ0)
|
|
Return (VI01) /* \_SB_.PC00.VIIC.VI01 */
|
|
} ElseIf(LEqual (CUPN,0x07)) {
|
|
CreateWordField (VI00, VI0P._ADR, DAR0)
|
|
Store (Arg0, DAR0)
|
|
Return (VI00) /* \_SB_.PC00.VIIC.VI00 */
|
|
} ElseIf(LEqual (CUPN,0x08)) {
|
|
CreateWordField (VI02, VI0N._ADR, DAS0)
|
|
Store (Arg0, DAS0)
|
|
Return (VI02) /* \_SB_.PC00.VIIC.VI02 */
|
|
} ElseIf(LEqual (CUPN,0x03)) {
|
|
CreateWordField (VI03, VI0O._ADR, DAT0)
|
|
Store (Arg0, DAT0)
|
|
Return (VI03) /* \_SB_.PC00.VIIC.VI03 */
|
|
}
|
|
Return (ResourceTemplate () {I2cSerialBus (0, ControllerInitiated, 400000,AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VIC0",0x00, ResourceConsumer, ,)}) // Dummy
|
|
}
|
|
Case (One) // When virtual I2C device VIC1 is selected
|
|
{
|
|
Name (VI10, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS07.VIC1",
|
|
0x00, ResourceConsumer, VI1P,)
|
|
})
|
|
Name (VI11, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS06.VIC1",
|
|
0x00, ResourceConsumer, VI1M,)
|
|
})
|
|
Name (VI12, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS08.VIC1",
|
|
0x00, ResourceConsumer, VI1N,)
|
|
})
|
|
Name (VI13, ResourceTemplate () {
|
|
I2cSerialBus (0, ControllerInitiated, 400000,
|
|
AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HS03.VIC1",
|
|
0x00, ResourceConsumer, VI1O,)
|
|
})
|
|
// USB Port Mapping:
|
|
// 3 : ADL M AEP
|
|
// 6 : ADL M
|
|
// 7 : ADL P
|
|
// 8 : ADL P AEP
|
|
//
|
|
If(LEqual (CUPN,0x06)) {
|
|
CreateWordField (VI11, VI1M._ADR, DAQ1)
|
|
Store (Arg0, DAQ1)
|
|
Return (VI11) /* \_SB_.PC00.VIIC.VI11 */
|
|
} ElseIf(LEqual (CUPN,0x07)) {
|
|
CreateWordField (VI10, VI1P._ADR, DAR1)
|
|
Store (Arg0, DAR1)
|
|
Return (VI10) /* \_SB_.PC00.VIIC.VI10 */
|
|
} ElseIf(LEqual (CUPN,0x08)) {
|
|
CreateWordField (VI12, VI1N._ADR, DAS1)
|
|
Store (Arg0, DAS1)
|
|
Return (VI12) /* \_SB_.PC00.VIIC.VI12 */
|
|
} ElseIf(LEqual (CUPN,0x03)) {
|
|
CreateWordField (VI13, VI1O._ADR, DAT1)
|
|
Store (Arg0, DAT1)
|
|
Return (VI13) /* \_SB_.PC00.VIIC.VI13 */
|
|
}
|
|
Return (ResourceTemplate () {I2cSerialBus (0, ControllerInitiated, 400000,AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VIC1",0x00, ResourceConsumer, ,)}) // Dummy
|
|
}
|
|
Default
|
|
{
|
|
Return (ResourceTemplate () {I2cSerialBus (0, ControllerInitiated, 400000,AddressingMode7Bit, "\\_SB.PC00.XHCI.RHUB.HSXX.VICX",0x00, ResourceConsumer, ,)}) // Dummy
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Create Interrupt Resource descriptor for _CRS usage
|
|
// Arg0 - GPIO Pad used as Interrupt source
|
|
// Arg1 - Edge (1) or Level (0) interrupt triggering
|
|
// Arg2 - Active Level: High (1) or Low (0)
|
|
// Returns buffer with 'Interrupt' resource descriptor
|
|
//
|
|
Method (INTB, 3, Serialized) {
|
|
Name (INTR, ResourceTemplate () { Interrupt (ResourceConsumer, Level, ActiveLow, ExclusiveAndWake,,,INTI) {0} })
|
|
// Update APIC Interrupt descriptor
|
|
CreateDWordField (INTR, INTI._INT, NUMI) // Interrupt Number
|
|
Store (INUM(Arg0), NUMI)
|
|
CreateBitField (INTR, INTI._HE, LEVI) // Level or Edge
|
|
Store (Arg1, LEVI)
|
|
CreateBitField (INTR, INTI._LL, ACTI) // Active High or Low
|
|
Store (Arg2, ACTI)
|
|
|
|
Return (INTR)
|
|
}
|
|
|
|
} // END Scope(\_SB.PC00)
|
|
|
|
Include ("Pch.asl") // Not in this package. Refer to the PCH Reference Code accordingly
|
|
Include ("LpcB.asl")
|
|
Include ("Platform.asl")
|
|
Include ("Cpu.asl")
|
|
Include ("PciDrc.asl")
|
|
Include ("Video.asl")
|
|
Include ("PlatformGnvsTestMenu.asl")
|
|
Include ("Gpe.asl")
|
|
Include ("PcieDock.asl")
|
|
Include ("PchRpPxsxWrapper.asl")
|
|
Include ("WifiDynamicSar.asl")
|
|
Include ("Pep.asl")
|
|
Include ("Psm.asl")
|
|
Include ("Connectivity.asl")
|
|
Include ("MipiCamSensors.asl")
|
|
Include ("SerialIoDevices.asl")
|
|
Include ("HdaSoundWireDev.asl")
|
|
Include ("HdaSlaveDevices.asl")
|
|
Include ("HdaDspModules.asl")
|
|
Include ("HidPlatformEventDev.asl")
|
|
Include ("HidDynamicSarDsm.asl")
|
|
Include ("DiscreteDPMuxSwitch.asl")
|
|
#if FixedPcdGetBool(PcdEcEnable) == 1
|
|
Include ("HIDWakeDSM.asl")
|
|
#endif
|
|
Include ("PinDriverLib.asl")
|
|
Include ("Pld.asl")
|
|
Include ("WirelessConfigDevice.asl")
|
|
If(LAnd(LNotEqual(CVFS,0),LLessEqual(CVFS,2))) {
|
|
Include("Cvf.asl")
|
|
}
|
|
|
|
#if FixedPcdGetBool(PcdAdlLpSupport) == 1
|
|
If(LEqual(LP5E,1)) {
|
|
Include("ClosedLidWoVLed.asl")
|
|
}
|
|
#endif
|
|
|
|
If(LEqual(VMDE,1)) {
|
|
Name(VDSD, 1) // VMD _DSD Method - 1: Expose 0: Hide
|
|
|
|
If (LEqual (\STD3, 0)) {
|
|
Store (0, VDSD)
|
|
}
|
|
Include("Vmd.asl")
|
|
}
|
|
|
|
Scope(\_SB.PC00.RP01) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSW3, 0), LEqual(RPN3, 0x01))) {
|
|
Return (GPRW (GGPE (PSW3), 4))
|
|
} ElseIf (LAnd(LNotEqual(PSW2, 0), LEqual(RPN2, 0x01))) {
|
|
Return (GPRW (GGPE (PSW2), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP02) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WWKP, 0), LEqual(WWRP, 0x02))) {
|
|
Return (GPRW (GGPE (WWKP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP03) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WWKP, 0), LEqual(WWRP, 0x03))) {
|
|
Return (GPRW (GGPE (WWKP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP04) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WLWK, 0), LEqual(WLRP, 0x04))) {
|
|
Return (GPRW (GGPE (WLWK), 4))
|
|
} ElseIf (LAnd(LNotEqual(WWKP, 0), LEqual(WWRP, 0x04))) {
|
|
Return (GPRW (GGPE (WWKP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP05) {
|
|
Method(_PRW, 0) {
|
|
If (LOr((LAnd(LNotEqual(PSW3, 0), LEqual(RPN3, 0x05))) ,(LAnd(LNotEqual(WLWK, 0), LEqual(WLRP, 0x05))))) {
|
|
If (LAnd(LNotEqual(PSW3, 0), LEqual(RPN3, 0x05))) {
|
|
Return (GPRW (GGPE (PSW3), 4))
|
|
} ElseIf (LAnd(LNotEqual(WLWK, 0), LEqual(WLRP, 0x05))) {
|
|
Return (GPRW (GGPE (WLWK), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
} ElseIf (LAnd(LNotEqual(PSW2, 0), LEqual(RPN2, 0x05))) {
|
|
Return (GPRW (GGPE (PSW2), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP06) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WWKP, 0), LEqual(WWRP, 0x06))) {
|
|
Return (GPRW (GGPE (WWKP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP07) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSWP, 0), LEqual(RPNB, 0x07))) {
|
|
Return (GPRW (GGPE (PSWP), 4))
|
|
} ElseIf (LAND(LEqual(FVSP,1), LAnd(LNotEqual(FVWP, 0), LEqual(RPFV, 0x07)))) {
|
|
Return (GPRW (GGPE (FVWP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP08) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WLWK, 0), LEqual(WLRP, 0x08))) {
|
|
Return (GPRW (GGPE (WLWK), 4))
|
|
} ElseIf (LAnd(LNotEqual(PSWP, 0), LEqual(RPNB, 0x08))) {
|
|
Return (GPRW (GGPE (PSWP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP09) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSW2, 0), LEqual(RPN2, 0x09))) {
|
|
Return (GPRW (GGPE (PSW2), 4))
|
|
} ElseIf (LAnd(LNotEqual(PSW3, 0), LEqual(RPN3, 0x09))) {
|
|
Return (GPRW (GGPE (PSW3), 4))
|
|
} ElseIf (LAnd(LNotEqual(PSWP, 0), LEqual(RPNB, 0x09))) {
|
|
Return (GPRW (GGPE (PSWP), 4))
|
|
} ElseIf (LAnd(LNotEqual(OMW1, 0), LEqual(RPO1, 0x09))) {
|
|
Return (GPRW (GGPE (OMW1), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP10) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(WLWK, 0), LEqual(WLRP, 0x0A))) {
|
|
Return (GPRW (GGPE (WLWK), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP11) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP12) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP13) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSWP, 0), LEqual(RPNB, 0x0D))) {
|
|
Return (GPRW (GGPE (PSWP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP14) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP15) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP16) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP17) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP18) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP19) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP20) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP21) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSWP, 0), LEqual(RPNB, 0x15))) {
|
|
Return (GPRW (GGPE (PSWP), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP22) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP23) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP24) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP25) {
|
|
Method(_PRW, 0) {
|
|
If (LAnd(LNotEqual(PSW2, 0), LEqual(RPN2, 0x19))) {
|
|
Return (GPRW (GGPE (PSW2), 4))
|
|
} ElseIf (LAnd(LNotEqual(OMW1, 0), LEqual(RPO1, 0x19))) {
|
|
Return (GPRW (GGPE (OMW1), 4))
|
|
} Else {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP26) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP27) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
Scope(\_SB.PC00.RP28) {
|
|
Method(_PRW, 0) {
|
|
Return (GPRW (GPE_PCI_EXP, 4))
|
|
}
|
|
}
|
|
|
|
#if FixedPcdGetBool(PcdEcEnable) == 1
|
|
//
|
|
// Enable SCI wake for LID SWITCH
|
|
//
|
|
If(LNotEqual(LSWP, 0)) {
|
|
//[-start-210219-IB14630474-add]//
|
|
#if FeaturePcdGet (PcdUseCrbEcFlag)
|
|
//[-end-210219-IB14630474-add]//
|
|
Scope(\_SB.PC00.LPCB.H_EC.LID0) {
|
|
Method (_PRW, 0) {
|
|
Return (GPRW (GGPE (LSWP), 3))
|
|
}
|
|
}
|
|
//[-start-210219-IB14630474-add]//
|
|
#endif
|
|
//[-end-210219-IB14630474-add]//
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Add WWAN Firmware Flash Device Support
|
|
//
|
|
If (LEqual(WFFD, 1)) {
|
|
Include("WwanFlash.asl")
|
|
}
|
|
|
|
Name(\_S0, Package(4){0x0,0x0,0,0}) // mandatory System state
|
|
if(SS1) { Name(\_S1, Package(4){0x1,0x0,0,0})}
|
|
//[-start-190722-IB17700055-modify]//
|
|
#if FixedPcdGetBool (PcdAcpiS3Enable)
|
|
if(SS3) { Name(\_S3, Package(4){0x5,0x0,0,0})}
|
|
#endif
|
|
//[-end-190722-IB17700055-modify]//
|
|
if(SS4) { Name(\_S4, Package(4){0x6,0x0,0,0})}
|
|
Name(\_S5, Package(4){0x7,0x0,0,0}) // mandatory System state
|
|
|
|
Method(PTS, 1) { // METHOD CALLED FROM _PTS PRIOR TO ENTER ANY SLEEP STATE
|
|
If(Arg0) // entering any sleep state
|
|
{
|
|
}
|
|
}
|
|
Method(WAK, 1) { // METHOD CALLED FROM _WAK RIGHT AFTER WAKE UP
|
|
}
|
|
|
|
Scope(\_SB.PC00.SAT0) {
|
|
//
|
|
// Check for platform defined _DSM method support
|
|
//
|
|
// Arg0 - _DSM GUID
|
|
//
|
|
Method(SATC, 1, Serialized) {
|
|
If(LEqual(Arg0, ToUUID("E4DB149B-FCFE-425b-A6D8-92357D78FC7F"))) {
|
|
Return (1)
|
|
} Else {
|
|
Return (0)
|
|
}
|
|
}
|
|
|
|
//
|
|
// Execute platform defined _DSM method
|
|
//
|
|
// Arg0 - _DSM GUID
|
|
// Arg1 - _DSM revision
|
|
// Arg2 - Function index
|
|
// Arg3 - Package with parameters
|
|
//
|
|
Method(SATD, 4, Serialized) {
|
|
Switch (ToInteger(Arg2)) {
|
|
Case (0) {
|
|
///Case 0: Standard query - A bitmask of functions supported
|
|
Return(Buffer() {0x3})
|
|
}
|
|
Default {
|
|
Return (0)
|
|
}
|
|
}
|
|
Return(Buffer() {0x0})
|
|
}
|
|
|
|
//
|
|
// ACPI Method to support PUIS capability for each Sata port
|
|
//
|
|
If (LAnd(LEqual(\S0ID,1), LEqual(\PUIS,1))) {
|
|
Scope(PRT0) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
Scope(PRT1) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
Scope(PRT2) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
Scope(PRT3) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
Scope(PRT4) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
Scope(PRT5) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
|
|
If(CondRefOf(PRT6)) {
|
|
Scope(PRT6) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
}
|
|
|
|
If(CondRefOf(PRT7)) {
|
|
Scope(PRT7) {
|
|
Include ("SataPuis.asl")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// PCH xDCI scope for platform specific functions
|
|
//
|
|
Scope (\_SB.PC00.XDCI) {
|
|
Method(XDAT, 0, Serialized) {
|
|
If (CondRefOf (\_SB.PC00.LPCB.H_EC.XDAT)) {
|
|
//[-start-220112-IB19270008-modify]//
|
|
#if FeaturePcdGet (PcdUseCrbEcFlag)
|
|
Return (\_SB.PC00.LPCB.H_EC.XDAT ())
|
|
#endif
|
|
//[-end-220112-IB19270008-modify]//
|
|
}
|
|
Return (0)
|
|
}
|
|
}
|
|
}// End of ASL File
|