/*
RSD PTR: OEM=LENOVO, ACPI_Rev=2.0x (2)
XSDT=0xbf6bd1b7, length=36, cksum=42
*/
/*
XSDT: Length=156, Revision=1, Checksum=222,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID= LTP, Creator Revision=0x0
Entries={ 0xbf6bd300, 0xbf6bd4b4, 0xbf6cba38, 0xbf6cba8a, 0xbf6cbabc, 0xbf6cbb24, 0xbf6cbb60, 0xbf6cbb98, 0xbf6cbdf0, 0xbf6cbf66, 0xbf6cbf8e, 0xbf6e2697, 0xbf6e28f6, 0xbf6e299c, 0xbf6e2e93 }
*/
/*
FACP: Length=244, Revision=3, Checksum=5,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
FACS=0xbf6e4000, DSDT=0xbf6bd6db
INT_MODEL=PIC
Preferred_PM_Profile=Mobile (2)
SCI_INT=9
SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
PSTATE_CNT=0xf3
PM1a_EVT_BLK=0x1000-0x1003
PM1a_CNT_BLK=0x1004-0x1005
PM2_CNT_BLK=0x1020-0x1020
PM_TMR_BLK=0x1008-0x100b
GPE0_BLK=0x1028-0x102f
CST_CNT=0x85
P_LVL2_LAT=1 us, P_LVL3_LAT=35 us
FLUSH_SIZE=0, FLUSH_STRIDE=0
DUTY_OFFSET=1, DUTY_WIDTH=3
DAY_ALRM=13, MON_ALRM=0, CENTURY=50
IAPC_BOOT_ARCH={8042,NO_ASPM}
Flags={WBINVD,C1_SUPPORTED,C2_MP_SUPPORTED,SLEEP_BUTTON,S4_RTC_WAKE,DOCKING_SUPPORTED,PCI_EXPRESS_WAKE,PLATFORM_CLOCK}
X_FACS=0xbf6e4000, X_DSDT=0xbf6bd6db
X_PM1a_EVT_BLK=0x1000:0[32] (IO)
X_PM1a_CNT_BLK=0x1004:0[16] (IO)
X_PM2_CNT_BLK=0x1020:0[8] (IO)
X_PM_TMR_BLK=0x1008:0[32] (IO)
X_GPE0_BLK=0x1028:0[32] (IO)
X_GPE1_BLK=0x102c:0[32] (IO)
*/
/*
FACS: Length=64, HwSig=0x0000150a, Firm_Wake_Vec=0x00000000
Global_Lock=
Flags=
Version=1
*/
/*
DSDT: Length=58205, Revision=1, Checksum=187,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=MSFT, Creator Revision=0x3000000
*/
/*
SSDT: Length=551, Revision=1, Checksum=215,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=MSFT, Creator Revision=0x3000000
*/
/*
ECDT: Length=82, Revision=1, Checksum=65,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
EC_CONTROL=0x66:0[8] (IO)
EC_DATA=0x62:0[8] (IO)
UID=0, GPE_BIT=0x12
EC_ID=\_SB.PCI0.LPC.EC
*/
/*
TCPA: Length=50, Revision=2, Checksum=224,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
Class 0 Base Address 0xbf6d1a6a Length 65536
*/
/*
APIC: Length=104, Revision=1, Checksum=78,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
Local APIC ADDR=0xfee00000
Flags={PC-AT}
Type=Local APIC
ACPI CPU=0
Flags={ENABLED}
APIC ID=0
Type=Local APIC
ACPI CPU=1
Flags={ENABLED}
APIC ID=1
Type=IO APIC
APIC ID=1
INT BASE=0
ADDR=0x00000000fec00000
Type=INT Override
BUS=0
IRQ=0
INTR=2
Flags={Polarity=conforming, Trigger=conforming}
Type=INT Override
BUS=0
IRQ=9
INTR=9
Flags={Polarity=active-hi, Trigger=level}
Type=Local APIC NMI
ACPI CPU=0
LINT Pin=1
Flags={Polarity=active-hi, Trigger=edge}
Type=Local APIC NMI
ACPI CPU=1
LINT Pin=1
Flags={Polarity=active-hi, Trigger=edge}
*/
/*
MCFG: Length=60, Revision=1, Checksum=100,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
Base Address=0x00000000f0000000
Segment Group=0x0000
Start Bus=0
End Bus=63
*/
/*
HPET: Length=56, Revision=1, Checksum=140,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=LNVO, Creator Revision=0x1
HPET Number=0
ADDR=0xfed00000:0[0] (Memory) HW Rev=0x1
Comparators=2
Counter Size=1
Legacy IRQ routing capable={TRUE}
PCI Vendor ID=0x8086
Minimal Tick=128
Flags=0x00
*/
/*
SLIC: Length=374, Revision=1, Checksum=21,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=SLIC, Creator Revision=0x0
*/
/*
SLAC: Length=374, Revision=1, Checksum=177,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID= LTP, Creator Revision=0x0
*/
/*
BOOT: Length=40, Revision=1, Checksum=138,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID= LTP, Creator Revision=0x1
*/
/*
ASF!: Length=114, Revision=16, Checksum=132,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=PTL, Creator Revision=0x1
*/
/*
SSDT: Length=607, Revision=1, Checksum=164,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=INTL, Creator Revision=0x20050513
*/
/*
SSDT: Length=166, Revision=1, Checksum=74,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=INTL, Creator Revision=0x20050513
*/
/*
SSDT: Length=1271, Revision=1, Checksum=90,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=INTL, Creator Revision=0x20050513
*/
/*
SSDT: Length=472, Revision=1, Checksum=235,
OEMID=LENOVO, OEM Table ID=TP-7V, OEM Revision=0x2220,
Creator ID=INTL, Creator Revision=0x20050513
*/
/*
* Intel ACPI Component Architecture
* AML Disassembler version 20130823-64
* Copyright (c) 2000 - 2013 Intel Corporation
*
* Disassembly of /tmp/acpidump.ZJtjg3, Sat Oct 4 16:08:02 2014
*
* Original Table Header:
* Signature "DSDT"
* Length 0x0000EEA4 (61092)
* Revision 0x01 **** 32-bit table (V1), no 64-bit math support
* Checksum 0xDE
* OEM ID "LENOVO"
* OEM Table ID "TP-7V "
* OEM Revision 0x00002220 (8736)
* Compiler ID "MSFT"
* Compiler Version 0x03000000 (50331648)
*/
DefinitionBlock ("/tmp/acpidump.aml", "DSDT", 1, "LENOVO", "TP-7V ", 0x00002220)
{
/*
* iASL Warning: There were 1 external control methods found during
* disassembly, but additional ACPI tables to resolve these externals
* were not specified. This resulting disassembler output file may not
* compile because the disassembler did not know how many arguments
* to assign to these methods. To specify the tables needed to resolve
* external control method references, use the one of the following
* example iASL invocations:
* iasl -e <ssdt1.aml,ssdt2.aml...> -d <dsdt.aml>
* iasl -e <dsdt.aml,ssdt2.aml...> -d <ssdt1.aml>
*/
External (_SB_.PCI0.SATA.SCND._STM, MethodObj) // Warning: Unresolved Method, guessing 3 arguments (may be incorrect, see warning above)
External (_PSS, IntObj)
External (_SB_.PCI0.SATA.SCND._ADR, IntObj)
External (_SB_.PCI0.SATA.SCND.MSTR)
External (_SB_.PCI0.SATA.SCND.MSTR._ADR, IntObj)
External (_SB_.PCI0.SATA.SCND.MSTR._GTF, IntObj)
OperationRegion (PORT, SystemIO, 0x80, 0x01)
Field (PORT, ByteAcc, NoLock, Preserve)
{
P80H, 8
}
Scope (\_PR)
{
Processor (CPU0, 0x00, 0x00001010, 0x06) {}
Processor (CPU1, 0x01, 0x00001010, 0x06) {}
}
OperationRegion (MNVS, SystemMemory, 0xBF6E4000, 0x1000)
Field (MNVS, DWordAcc, NoLock, Preserve)
{
Offset (0xF00),
GAPA, 32,
GAPL, 32,
DCKI, 32,
DCKS, 32,
VCDL, 1,
VCDC, 1,
VCDT, 1,
VCDD, 1,
VIGD, 1,
VCSS, 1,
VCDB, 1,
VCIN, 1,
VPDF, 1,
Offset (0xF12),
VLID, 4,
VVPO, 4,
BRLV, 4,
BRFQ, 2,
BRHB, 1,
BREV, 1,
CDFL, 8,
CDAH, 8,
PMOD, 2,
PDIR, 1,
PDMA, 1,
Offset (0xF17),
LFDC, 1,
Offset (0xF18),
C2NA, 1,
C3NA, 1,
C4NA, 1,
C6NA, 1,
Offset (0xF19),
SPEN, 1,
, 1,
, 1,
, 1,
MPEN, 1,
Offset (0xF1A),
OSPX, 1,
OSC4, 1,
OSSS, 1,
NHPS, 1,
NPME, 1,
Offset (0xF1B),
UOPT, 8,
BTID, 32,
LWST, 8,
LPST, 8,
TCRT, 16,
TPSV, 16,
TTC1, 16,
TTC2, 16,
TTSP, 16,
SRAH, 8,
SRHE, 8,
SRE0, 8,
SRE1, 8,
SRE2, 8,
SRE3, 8,
SRE4, 8,
SRE5, 8,
SRU0, 8,
SRU1, 8,
SRU2, 8,
SRU7, 8,
SRU3, 8,
SRU4, 8,
SRU8, 8,
SRPB, 8,
SRLP, 8,
SRSA, 8,
SRSM, 8,
CWAC, 1,
CWAS, 1,
CWUE, 1,
CWUS, 1,
Offset (0xF40),
CWAP, 16,
CWAT, 16,
DBGC, 1,
Offset (0xF45),
FS1L, 16,
FS1M, 16,
FS1H, 16,
FS2L, 16,
FS2M, 16,
FS2H, 16,
FS3L, 16,
FS3M, 16,
FS3H, 16,
TATC, 1,
, 6,
TATL, 1,
TATW, 8,
TNFT, 4,
TNTT, 4,
TDFA, 4,
TDTA, 4,
TDFD, 4,
TDTD, 4,
TCFA, 4,
TCTA, 4,
TCFD, 4,
TCTD, 4,
TSFT, 4,
TSTT, 4,
TIT0, 8,
TCR0, 16,
TPS0, 16,
TIT1, 8,
TCR1, 16,
TPS1, 16,
TIT2, 8,
TCR2, 16,
TPS2, 16,
TIF0, 8,
TIF1, 8,
TIF2, 8,
Offset (0xF75),
TCZ1, 8,
TCZ2, 8,
TCZ3, 8,
BTHI, 1,
Offset (0xF79),
HDIR, 1,
HDEH, 1,
HDSP, 1,
HDPP, 1,
HDUB, 1,
Offset (0xF7A),
TPMP, 1,
TPMS, 1,
Offset (0xF7B),
BIDE, 8,
, 1,
DTSE, 1,
Offset (0xF7D),
DTS0, 8,
DTS1, 8,
DT00, 1,
DT01, 1,
DT02, 1,
DT03, 1,
Offset (0xF80),
LIDB, 1,
C4WR, 1,
C4AC, 1,
Offset (0xF81),
PH01, 8,
PH02, 8,
PH03, 8,
PH04, 8,
PH05, 8,
PH06, 8,
PH07, 8,
PH08, 8,
PH09, 8,
PH0A, 8,
PH0B, 8,
IPAT, 4,
IPSC, 1,
IDMM, 1,
IDMS, 2,
HVCO, 3,
IF1E, 1,
ISSC, 1,
LIDS, 1,
IBIA, 2,
IBTT, 8,
ITVF, 4,
ITVM, 4,
TCG0, 1,
TCG1, 1,
Offset (0xF91),
SWGP, 8,
IPMS, 8,
IPMB, 120,
IPMR, 24,
IPMO, 24,
IPMA, 8,
ASLB, 32,
ASFT, 8,
Offset (0xFB0),
CHKC, 32,
CHKE, 32,
THRI, 8
}
Field (MNVS, ByteAcc, NoLock, Preserve)
{
Offset (0xE00),
DDC1, 1024,
Offset (0xF00)
}
Field (MNVS, ByteAcc, NoLock, Preserve)
{
Offset (0xE00),
DDC2, 2048
}
Scope (\_SB)
{
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
If (LEqual (\SCMP (\_OS, "Microsoft Windows"), Zero))
{
Store (0x01, \W98F)
}
Else
{
If (CondRefOf (\_OSI, Local0))
{
If (\_OSI ("Windows 2001"))
{
Store (0x01, \WNTF)
Store (0x01, \WXPF)
Store (0x00, \WSPV)
}
If (\_OSI ("Windows 2001 SP1"))
{
Store (0x01, \WSPV)
}
If (\_OSI ("Windows 2001 SP2"))
{
Store (0x02, \WSPV)
}
If (\_OSI ("Windows 2006"))
{
Store (0x01, \WVIS)
}
If (\_OSI ("Linux"))
{
Store (0x01, \LNUX)
}
If (\_OSI ("FreeBSD"))
{
Store (0x01, \LNUX)
}
}
Else
{
If (LEqual (\SCMP (\_OS, "Microsoft Windows NT"), Zero))
{
Store (0x01, \WNTF)
}
Else
{
If (LEqual (\SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero))
{
Store (0x01, \WMEF)
Store (0x01, \W98F)
}
}
}
}
If (LGreaterEqual (\_REV, 0x02))
{
Store (0x01, \H8DR)
}
Store (0x01, \OSIF)
If (LAnd (\WXPF, LGreaterEqual (\WSPV, 0x01)))
{
PPMS (0x02)
}
If (And (\RBEC (0x46), 0x10))
{
Store (0x00, \C4AC)
}
Else
{
Store (0x01, \C4AC)
}
If (\LNUX)
{
\_SB.PCI0.LPC.EC.SAUM (0x02)
\UCMS (0x1C)
}
Store (\SRAH, \_SB.PCI0.RID)
If (VIGD)
{
Store (\SRHE, \_SB.PCI0.VID.RID)
}
Else
{
Store (\SRHE, \_SB.PCI0.AGP.RID)
}
Store (\SRE0, \_SB.PCI0.EXP0.RID)
Store (\SRE1, \_SB.PCI0.EXP1.RID)
Store (\SRE2, \_SB.PCI0.EXP2.RID)
Store (\SRE3, \_SB.PCI0.EXP3.RID)
Store (\SRU0, \_SB.PCI0.USB0.RID)
Store (\SRU1, \_SB.PCI0.USB1.RID)
Store (\SRU3, \_SB.PCI0.USB3.RID)
Store (\SRU7, \_SB.PCI0.EHC0.RID)
Store (\SRU3, \_SB.PCI0.USB3.RID)
Store (\SRU4, \_SB.PCI0.USB4.RID)
Store (\SRU8, \_SB.PCI0.EHC1.RID)
Store (\SRPB, \_SB.PCI0.PCI1.RID)
Store (\SRLP, \_SB.PCI0.LPC.RID)
Store (\SRSA, \_SB.PCI0.IDE0.RID)
Store (\SRSA, \_SB.PCI0.SATA.RID)
Store (\SRSM, \_SB.PCI0.SMBU.RID)
}
Device (LNKA)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x01) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRA)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRA, 0x80, \_SB.PCI0.LPC.PIRA)
}
Name (BUFA, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y00)
{}
})
CreateWordField (BUFA, \_SB.LNKA._Y00._INT, IRA1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRA, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRA1)
}
Else
{
Store (0x00, IRA1)
}
Return (BUFA)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRA2)
FindSetRightBit (IRA2, Local0)
And (\_SB.PCI0.LPC.PIRA, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRA)
}
}
Device (LNKB)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x02) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRB)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRB, 0x80, \_SB.PCI0.LPC.PIRB)
}
Name (BUFB, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y01)
{}
})
CreateWordField (BUFB, \_SB.LNKB._Y01._INT, IRB1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRB, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRB1)
}
Else
{
Store (0x00, IRB1)
}
Return (BUFB)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRB2)
FindSetRightBit (IRB2, Local0)
And (\_SB.PCI0.LPC.PIRB, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRB)
}
}
Device (LNKC)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x03) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRC)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRC, 0x80, \_SB.PCI0.LPC.PIRC)
}
Name (BUFC, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y02)
{}
})
CreateWordField (BUFC, \_SB.LNKC._Y02._INT, IRC1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRC, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRC1)
}
Else
{
Store (0x00, IRC1)
}
Return (BUFC)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRC2)
FindSetRightBit (IRC2, Local0)
And (\_SB.PCI0.LPC.PIRC, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRC)
}
}
Device (LNKD)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x04) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRD)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRD, 0x80, \_SB.PCI0.LPC.PIRD)
}
Name (BUFD, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y03)
{}
})
CreateWordField (BUFD, \_SB.LNKD._Y03._INT, IRD1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRD, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRD1)
}
Else
{
Store (0x00, IRD1)
}
Return (BUFD)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRD2)
FindSetRightBit (IRD2, Local0)
And (\_SB.PCI0.LPC.PIRD, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRD)
}
}
Device (LNKE)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x05) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRE)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRE, 0x80, \_SB.PCI0.LPC.PIRE)
}
Name (BUFE, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y04)
{}
})
CreateWordField (BUFE, \_SB.LNKE._Y04._INT, IRE1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRE, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRE1)
}
Else
{
Store (0x00, IRE1)
}
Return (BUFE)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRE2)
FindSetRightBit (IRE2, Local0)
And (\_SB.PCI0.LPC.PIRE, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRE)
}
}
Device (LNKF)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x06) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRF)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRF, 0x80, \_SB.PCI0.LPC.PIRF)
}
Name (BUFF, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y05)
{}
})
CreateWordField (BUFF, \_SB.LNKF._Y05._INT, IRF1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRF, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRF1)
}
Else
{
Store (0x00, IRF1)
}
Return (BUFF)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRF2)
FindSetRightBit (IRF2, Local0)
And (\_SB.PCI0.LPC.PIRF, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRF)
}
}
Device (LNKG)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x07) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRG)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRG, 0x80, \_SB.PCI0.LPC.PIRG)
}
Name (BUFG, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y06)
{}
})
CreateWordField (BUFG, \_SB.LNKG._Y06._INT, IRG1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRG, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRG1)
}
Else
{
Store (0x00, IRG1)
}
Return (BUFG)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRG2)
FindSetRightBit (IRG2, Local0)
And (\_SB.PCI0.LPC.PIRG, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRG)
}
}
Device (LNKH)
{
Name (_HID, EisaId ("PNP0C0F")) // _HID: Hardware ID
Name (_UID, 0x08) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (VPIR (\_SB.PCI0.LPC.PIRH)))
{
Return (0x09)
}
Else
{
Return (0x0B)
}
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
IRQ (Level, ActiveLow, Shared, )
{3,4,5,6,7,9,10,11}
})
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Or (\_SB.PCI0.LPC.PIRH, 0x80, \_SB.PCI0.LPC.PIRH)
}
Name (BUFH, ResourceTemplate ()
{
IRQ (Level, ActiveLow, Shared, _Y07)
{}
})
CreateWordField (BUFH, \_SB.LNKH._Y07._INT, IRH1) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
And (\_SB.PCI0.LPC.PIRH, 0x8F, Local0)
If (VPIR (Local0))
{
ShiftLeft (0x01, Local0, IRH1)
}
Else
{
Store (0x00, IRH1)
}
Return (BUFH)
}
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateWordField (Arg0, 0x01, IRH2)
FindSetRightBit (IRH2, Local0)
And (\_SB.PCI0.LPC.PIRH, 0x70, Local1)
Or (Local1, Decrement (Local0), Local1)
Store (Local1, \_SB.PCI0.LPC.PIRH)
}
}
Method (VPIR, 1, NotSerialized)
{
Store (0x01, Local0)
If (And (Arg0, 0x80))
{
Store (0x00, Local0)
}
Else
{
And (Arg0, 0x0F, Local1)
If (LLess (Local1, 0x03))
{
Store (0x00, Local0)
}
Else
{
If (LOr (LEqual (Local1, 0x08), LEqual (Local1, 0x0D)))
{
Store (0x00, Local0)
}
}
}
Return (Local0)
}
Device (MEM)
{
Name (_HID, EisaId ("PNP0C01")) // _HID: Hardware ID
Name (ME98, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x000A0000, // Address Length
)
Memory32Fixed (ReadOnly,
0x000E0000, // Address Base
0x00020000, // Address Length
)
Memory32Fixed (ReadWrite,
0x00100000, // Address Base
0x01EE0000, // Address Length
_Y08)
Memory32Fixed (ReadOnly,
0xFEC00000, // Address Base
0x00140000, // Address Length
)
Memory32Fixed (ReadOnly,
0xFED4C000, // Address Base
0x012B4000, // Address Length
)
})
CreateDWordField (ME98, \_SB.MEM._Y08._BAS, MEB0) // _BAS: Base Address
CreateDWordField (ME98, \_SB.MEM._Y08._LEN, MEL0) // _LEN: Length
Name (MGAP, ResourceTemplate ()
{
Memory32Fixed (ReadOnly,
0x00000000, // Address Base
0x00000000, // Address Length
_Y09)
})
CreateDWordField (MGAP, \_SB.MEM._Y09._BAS, MGPB) // _BAS: Base Address
CreateDWordField (MGAP, \_SB.MEM._Y09._LEN, MGPL) // _LEN: Length
Name (MEMS, ResourceTemplate ()
{
Memory32Fixed (ReadWrite,
0x00000000, // Address Base
0x000A0000, // Address Length
)
Memory32Fixed (ReadOnly,
0x000C0000, // Address Base
0x00000000, // Address Length
_Y0A)
Memory32Fixed (ReadOnly,
0x000C4000, // Address Base
0x00000000, // Address Length
_Y0B)
Memory32Fixed (ReadOnly,
0x000C8000, // Address Base
0x00000000, // Address Length
_Y0C)
Memory32Fixed (ReadOnly,
0x000CC000, // Address Base
0x00000000, // Address Length
_Y0D)
Memory32Fixed (ReadOnly,
0x000D0000, // Address Base
0x00000000, // Address Length
_Y0E)
Memory32Fixed (ReadOnly,
0x000D4000, // Address Base
0x00000000, // Address Length
_Y0F)
Memory32Fixed (ReadOnly,
0x000D8000, // Address Base
0x00000000, // Address Length
_Y10)
Memory32Fixed (ReadOnly,
0x000DC000, // Address Base
0x00000000, // Address Length
_Y11)
Memory32Fixed (ReadOnly,
0x000E0000, // Address Base
0x00000000, // Address Length
_Y12)
Memory32Fixed (ReadOnly,
0x000E4000, // Address Base
0x00000000, // Address Length
_Y13)
Memory32Fixed (ReadOnly,
0x000E8000, // Address Base
0x00000000, // Address Length
_Y14)
Memory32Fixed (ReadOnly,
0x000EC000, // Address Base
0x00000000, // Address Length
_Y15)
Memory32Fixed (ReadOnly,
0x000F0000, // Address Base
0x00010000, // Address Length
)
Memory32Fixed (ReadWrite,
0x00100000, // Address Base
0x01EE0000, // Address Length
_Y16)
Memory32Fixed (ReadOnly,
0xFEC00000, // Address Base
0x00140000, // Address Length
_Y17)
Memory32Fixed (ReadOnly,
0xFED4C000, // Address Base
0x012B4000, // Address Length
_Y18)
})
CreateDWordField (MEMS, \_SB.MEM._Y0A._LEN, MC0L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y0B._LEN, MC4L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y0C._LEN, MC8L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y0D._LEN, MCCL) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y0E._LEN, MD0L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y0F._LEN, MD4L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y10._LEN, MD8L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y11._LEN, MDCL) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y12._LEN, ME0L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y13._LEN, ME4L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y14._LEN, ME8L) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y15._LEN, MECL) // _LEN: Length
CreateBitField (MEMS, \_SB.MEM._Y0A._RW, MC0W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y0B._RW, MC4W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y0C._RW, MC8W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y0D._RW, MCCW) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y0E._RW, MD0W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y0F._RW, MD4W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y10._RW, MD8W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y11._RW, MDCW) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y12._RW, ME0W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y13._RW, ME4W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y14._RW, ME8W) // _RW_: Read-Write Status
CreateBitField (MEMS, \_SB.MEM._Y15._RW, MECW) // _RW_: Read-Write Status
CreateDWordField (MEMS, \_SB.MEM._Y16._BAS, MEB1) // _BAS: Base Address
CreateDWordField (MEMS, \_SB.MEM._Y16._LEN, MEL1) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y17._LEN, MEL2) // _LEN: Length
CreateDWordField (MEMS, \_SB.MEM._Y18._LEN, MEL3) // _LEN: Length
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
If (\W98F)
{
Subtract (\MEMX, MEB0, MEL0)
Store (\GAPA, MGPB)
Store (\GAPL, MGPL)
If (LAnd (MGPB, MGPL))
{
Subtract (SizeOf (ME98), 0x02, Local0)
Name (MBF0, Buffer (Local0) {})
Add (Local0, SizeOf (MGAP), Local0)
Name (MBF1, Buffer (Local0) {})
Store (ME98, MBF0)
Concatenate (MBF0, MGAP, MBF1)
If (LNotEqual (\_SB.PCI0.LPC.TPM._STA (), 0x0F))
{
Subtract (SizeOf (MBF1), 0x02, Local0)
Name (MBF2, Buffer (Local0) {})
Add (Local0, SizeOf (\_SB.PCI0.LPC.TPM._CRS), Local0)
Name (MBF3, Buffer (Local0) {})
Store (MBF1, MBF2)
Concatenate (MBF2, \_SB.PCI0.LPC.TPM._CRS, MBF3)
Return (MBF3)
}
Else
{
Return (MBF1)
}
}
Else
{
If (LNotEqual (\_SB.PCI0.LPC.TPM._STA (), 0x0F))
{
Subtract (SizeOf (ME98), 0x02, Local0)
Name (MBF4, Buffer (Local0) {})
Add (Local0, SizeOf (\_SB.PCI0.LPC.TPM._CRS), Local0)
Name (MBF5, Buffer (Local0) {})
Store (ME98, MBF4)
Concatenate (MBF4, \_SB.PCI0.LPC.TPM._CRS, MBF5)
Return (MBF5)
}
Else
{
Return (ME98)
}
}
}
And (\_SB.PCI0.PAM1, 0x03, Local0)
If (Local0)
{
Store (0x4000, MC0L)
If (And (Local0, 0x02))
{
Store (0x01, MC0W)
}
}
And (\_SB.PCI0.PAM1, 0x30, Local0)
If (Local0)
{
Store (0x4000, MC4L)
If (And (Local0, 0x20))
{
Store (0x01, MC4W)
}
}
And (\_SB.PCI0.PAM2, 0x03, Local0)
If (Local0)
{
Store (0x4000, MC8L)
If (And (Local0, 0x02))
{
Store (0x01, MC8W)
}
}
And (\_SB.PCI0.PAM2, 0x30, Local0)
If (Local0)
{
Store (0x4000, MCCL)
If (And (Local0, 0x20))
{
Store (0x01, MCCW)
}
}
And (\_SB.PCI0.PAM3, 0x03, Local0)
If (Local0)
{
Store (0x4000, MD0L)
If (And (Local0, 0x02))
{
Store (0x01, MD0W)
}
}
And (\_SB.PCI0.PAM3, 0x30, Local0)
If (Local0)
{
Store (0x4000, MD4L)
If (And (Local0, 0x20))
{
Store (0x01, MD4W)
}
}
And (\_SB.PCI0.PAM4, 0x03, Local0)
If (Local0)
{
Store (0x4000, MD8L)
If (And (Local0, 0x02))
{
Store (0x01, MD8W)
}
}
And (\_SB.PCI0.PAM4, 0x30, Local0)
If (Local0)
{
Store (0x4000, MDCL)
If (And (Local0, 0x20))
{
Store (0x01, MDCW)
}
}
And (\_SB.PCI0.PAM5, 0x03, Local0)
If (Local0)
{
Store (0x4000, ME0L)
If (And (Local0, 0x02))
{
Store (0x01, ME0W)
}
}
And (\_SB.PCI0.PAM5, 0x30, Local0)
If (Local0)
{
Store (0x4000, ME4L)
If (And (Local0, 0x20))
{
Store (0x01, ME4W)
}
}
And (\_SB.PCI0.PAM6, 0x03, Local0)
If (Local0)
{
Store (0x4000, ME8L)
If (And (Local0, 0x02))
{
Store (0x01, ME8W)
}
}
And (\_SB.PCI0.PAM6, 0x30, Local0)
If (Local0)
{
Store (0x4000, MECL)
If (And (Local0, 0x20))
{
Store (0x01, MECW)
}
}
Subtract (\MEMX, MEB1, MEL1)
If (LNotEqual (\_SB.PCI0.LPC.TPM._STA (), 0x0F))
{
Store (0x01400000, MEL2)
Store (0x00, MEL3)
}
Return (MEMS)
}
}
Device (LID)
{
Name (_HID, EisaId ("PNP0C0D")) // _HID: Hardware ID
Method (_LID, 0, NotSerialized) // _LID: Lid Status
{
If (\H8DR)
{
Return (\_SB.PCI0.LPC.EC.HPLD)
}
Else
{
If (And (\RBEC (0x46), 0x04))
{
Return (0x01)
}
Else
{
Return (0x00)
}
}
}
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
If (LAnd (\W98F, LNot (\WMEF)))
{
Return (Package (0x02)
{
0x18,
0x04
})
}
Else
{
Return (Package (0x02)
{
0x18,
0x03
})
}
}
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (\H8DR)
{
If (Arg0)
{
Store (0x01, \_SB.PCI0.LPC.EC.HWLO)
}
Else
{
Store (0x00, \_SB.PCI0.LPC.EC.HWLO)
}
}
Else
{
If (Arg0)
{
\MBEC (0x32, 0xFF, 0x04)
}
Else
{
\MBEC (0x32, 0xFB, 0x00)
}
}
}
}
Device (SLPB)
{
Name (_HID, EisaId ("PNP0C0E")) // _HID: Hardware ID
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake
{
If (LAnd (\W98F, LNot (\WMEF)))
{
Return (Package (0x02)
{
0x18,
0x04
})
}
Else
{
Return (Package (0x02)
{
0x18,
0x03
})
}
}
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (\H8DR)
{
If (Arg0)
{
Store (0x01, \_SB.PCI0.LPC.EC.HWFN)
}
Else
{
Store (0x00, \_SB.PCI0.LPC.EC.HWFN)
}
}
Else
{
If (Arg0)
{
\MBEC (0x32, 0xFF, 0x10)
}
Else
{
\MBEC (0x32, 0xEF, 0x00)
}
}
}
}
Device (PCI0)
{
Device (LPC)
{
Name (_ADR, 0x001F0000) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
Device (SIO)
{
Name (_HID, EisaId ("PNP0C02")) // _HID: Hardware ID
Name (_UID, 0x00) // _UID: Unique ID
Name (SCRS, ResourceTemplate ()
{
IO (Decode16,
0x0010, // Range Minimum
0x0010, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x0090, // Range Minimum
0x0090, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x0024, // Range Minimum
0x0024, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x0028, // Range Minimum
0x0028, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x002C, // Range Minimum
0x002C, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x0030, // Range Minimum
0x0030, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x0034, // Range Minimum
0x0034, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x0038, // Range Minimum
0x0038, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x003C, // Range Minimum
0x003C, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00A4, // Range Minimum
0x00A4, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00A8, // Range Minimum
0x00A8, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00AC, // Range Minimum
0x00AC, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00B0, // Range Minimum
0x00B0, // Range Maximum
0x01, // Alignment
0x06, // Length
)
IO (Decode16,
0x00B8, // Range Minimum
0x00B8, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00BC, // Range Minimum
0x00BC, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x0050, // Range Minimum
0x0050, // Range Maximum
0x01, // Alignment
0x04, // Length
)
IO (Decode16,
0x0072, // Range Minimum
0x0072, // Range Maximum
0x01, // Alignment
0x06, // Length
)
IO (Decode16,
0x164E, // Range Minimum
0x164E, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x002E, // Range Minimum
0x002E, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x1000, // Range Minimum
0x1000, // Range Maximum
0x01, // Alignment
0x80, // Length
)
IO (Decode16,
0x1180, // Range Minimum
0x1180, // Range Maximum
0x01, // Alignment
0x40, // Length
)
IO (Decode16,
0x0800, // Range Minimum
0x0800, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x15E0, // Range Minimum
0x15E0, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x1600, // Range Minimum
0x1600, // Range Maximum
0x01, // Alignment
0x60, // Length
)
Memory32Fixed (ReadWrite,
0xF0000000, // Address Base
0x04000000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFED1C000, // Address Base
0x00004000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFED14000, // Address Base
0x00004000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFED18000, // Address Base
0x00001000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFED19000, // Address Base
0x00001000, // Address Length
)
Memory32Fixed (ReadWrite,
0xFED45000, // Address Base
0x00007000, // Address Length
)
})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
If (LEqual (\_SB.PCI0.LPC.TPM._STA (), 0x0F))
{
Return (SCRS)
}
Else
{
Subtract (SizeOf (SCRS), 0x02, Local0)
Name (BUF0, Buffer (Local0) {})
Add (Local0, SizeOf (\_SB.PCI0.LPC.TPM._CRS), Local0)
Name (BUF1, Buffer (Local0) {})
Store (SCRS, BUF0)
Concatenate (BUF0, \_SB.PCI0.LPC.TPM._CRS, BUF1)
Return (BUF1)
}
}
}
OperationRegion (LPCS, PCI_Config, 0x00, 0x0100)
Field (LPCS, AnyAcc, NoLock, Preserve)
{
Offset (0x60),
PIRA, 8,
PIRB, 8,
PIRC, 8,
PIRD, 8,
SERQ, 8,
Offset (0x68),
PIRE, 8,
PIRF, 8,
PIRG, 8,
PIRH, 8,
Offset (0x80),
XU1A, 3,
, 1,
XU2A, 3,
Offset (0x81),
XPA, 2,
, 2,
XFA, 1,
Offset (0x82),
XU1E, 1,
XU2E, 1,
XPE, 1,
XFE, 1,
Offset (0x84),
XG1E, 1,
, 6,
XG1A, 9,
Offset (0x88),
XG2E, 1,
, 3,
XG2A, 12,
Offset (0xA0),
, 2,
CLKR, 1,
GYEN, 1,
, 3,
C4C3, 1,
, 2,
EXPE, 1,
Offset (0xA2)
}
OperationRegion (LPIO, SystemIO, 0x1180, 0x40)
Field (LPIO, DWordAcc, NoLock, Preserve)
{
GU00, 8,
GU01, 8,
GU02, 8,
GU03, 8,
GI00, 8,
GI01, 8,
GI02, 8,
GI03, 8,
Offset (0x0C),
GL00, 8,
GL01, 8,
GL02, 8,
GL03, 8,
Offset (0x18),
GB00, 8,
GB01, 8,
GB02, 8,
GB03, 8,
Offset (0x2C),
GV00, 8,
GV01, 8,
GV02, 8,
GV03, 8,
GU04, 8,
GU05, 8,
GU06, 8,
GU07, 8,
GI04, 8,
GI05, 8,
GI06, 8,
GI07, 8,
GL04, 8,
GL05, 8,
GL06, 8,
GL07, 8
}
OperationRegion (PMIO, SystemIO, 0x1000, 0x80)
Field (PMIO, AnyAcc, NoLock, Preserve)
{
Offset (0x42),
, 1,
SWGE, 1,
Offset (0x64),
, 9,
SCIS, 1,
Offset (0x66)
}
Device (PIC)
{
Name (_HID, EisaId ("PNP0000")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0020, // Range Minimum
0x0020, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x00A0, // Range Minimum
0x00A0, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IO (Decode16,
0x04D0, // Range Minimum
0x04D0, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IRQNoFlags ()
{2}
})
}
Device (TIMR)
{
Name (_HID, EisaId ("PNP0100")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0040, // Range Minimum
0x0040, // Range Maximum
0x01, // Alignment
0x04, // Length
)
IRQNoFlags ()
{0}
})
}
Device (HPET)
{
Name (_HID, EisaId ("PNP0103")) // _HID: Hardware ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (W98F)
{
Return (0x00)
}
Else
{
If (LAnd (\WNTF, LNot (\WXPF)))
{
Return (0x00)
}
Else
{
Return (0x0F)
}
}
Return (0x00)
}
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
Memory32Fixed (ReadOnly,
0xFED00000, // Address Base
0x00000400, // Address Length
)
})
}
Device (DMAC)
{
Name (_HID, EisaId ("PNP0200")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x0080, // Range Minimum
0x0080, // Range Maximum
0x01, // Alignment
0x10, // Length
)
IO (Decode16,
0x00C0, // Range Minimum
0x00C0, // Range Maximum
0x01, // Alignment
0x20, // Length
)
DMA (Compatibility, BusMaster, Transfer8_16, )
{4}
})
}
Device (SPKR)
{
Name (_HID, EisaId ("PNP0800")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0061, // Range Minimum
0x0061, // Range Maximum
0x01, // Alignment
0x01, // Length
)
})
}
Device (FPU)
{
Name (_HID, EisaId ("PNP0C04")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x00F0, // Range Minimum
0x00F0, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IRQNoFlags ()
{13}
})
}
Device (RTC)
{
Name (_HID, EisaId ("PNP0B00")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0070, // Range Minimum
0x0070, // Range Maximum
0x01, // Alignment
0x02, // Length
)
IRQNoFlags ()
{8}
})
}
Device (KBD)
{
Name (_HID, EisaId ("PNP0303")) // _HID: Hardware ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0060, // Range Minimum
0x0060, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IO (Decode16,
0x0064, // Range Minimum
0x0064, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IRQNoFlags ()
{1}
})
}
Device (MOU)
{
Name (_HID, EisaId ("IBM3780")) // _HID: Hardware ID
Name (_CID, EisaId ("PNP0F13")) // _CID: Compatible ID
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IRQNoFlags ()
{12}
})
}
OperationRegion (IMGA, SystemIO, 0x15E0, 0x10)
Field (IMGA, ByteAcc, NoLock, Preserve)
{
Offset (0x01),
Offset (0x02),
Offset (0x03),
WAKR, 16,
Offset (0x0C),
GAIX, 8,
Offset (0x0E),
GADT, 8,
Offset (0x10)
}
IndexField (GAIX, GADT, ByteAcc, NoLock, Preserve)
{
Offset (0x41),
VAUX, 2,
, 1,
WOLE, 1,
Offset (0x42),
Offset (0x50),
, 1,
CBPW, 1,
CBSL, 1,
VDPW, 1,
PDNE, 1,
BLPL, 1,
, 1,
LEDS, 1,
TP4R, 1,
PADR, 1,
BPAD, 1,
, 1,
, 1,
PADD, 1,
Offset (0x53),
DLAN, 1,
Offset (0x60),
BUSC, 1,
BUSD, 1,
, 1,
DSCI, 1,
Offset (0x61),
EPWG, 1,
, 2,
DSCS, 1,
Offset (0x62),
CSON, 1,
URST, 1,
Offset (0x70),
GDR0, 1,
GDR1, 1,
GDR2, 1,
Offset (0x71),
GDT0, 1,
GDT1, 1,
GDT2, 1,
Offset (0xC2),
GAID, 8
}
OperationRegion (NCFG, SystemIO, 0x2E, 0x02)
Field (NCFG, ByteAcc, NoLock, Preserve)
{
INDX, 8,
DATA, 8
}
IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
{
Offset (0x07),
LDN, 8,
Offset (0x20),
SIOD, 8,
Offset (0x22),
SCF2, 8,
Offset (0x24),
SCF4, 8,
, 2,
PPSE, 1,
, 4,
PNF, 1,
FDCD, 1,
PPD, 1,
SP2D, 1,
SP1D, 1,
, 1,
GPSR, 2,
Offset (0x27),
SRID, 8,
Offset (0x29),
SCF9, 8,
Offset (0x2B),
Offset (0x30),
LDA, 1,
Offset (0x31),
Offset (0x60),
IOHI, 8,
IOLW, 8,
Offset (0x70),
IRQN, 4,
IRQW, 1,
Offset (0x71),
IRQT, 1,
IRQL, 1,
Offset (0x72),
Offset (0x74),
DMA0, 3,
Offset (0x75),
DMA1, 3,
Offset (0x76)
}
IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
{
Offset (0xF0),
PTRS, 1,
PPMC, 1,
, 2,
PERA, 1,
PMDS, 3
}
IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
{
Offset (0xF0),
STRS, 1,
SPMC, 1,
SBSY, 1,
, 4,
SBSE, 1
}
IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
{
Offset (0xF0),
GPPS, 8,
GPPC, 8,
GPER, 8
}
OperationRegion (CFGS, SystemIO, 0x164E, 0x02)
Field (CFGS, ByteAcc, NoLock, Preserve)
{
NDXS, 8,
ATAS, 8
}
IndexField (NDXS, ATAS, ByteAcc, NoLock, Preserve)
{
Offset (0x07),
LDNS, 8,
Offset (0x20),
Offset (0x21),
Offset (0x22),
Offset (0x23),
Offset (0x24),
Offset (0x25),
, 2,
PSES, 1,
, 4,
PNFS, 1,
DCDS, 1,
PPDS, 1,
SP2S, 1,
SP1S, 1,
, 1,
PSRS, 2,
Offset (0x27),
RIDS, 8,
Offset (0x29),
CCSS, 2,
CCES, 1,
MCSS, 1,
MESS, 1,
Offset (0x2A),
Offset (0x2B),
Offset (0x30),
LDAS, 1,
Offset (0x31),
Offset (0x60),
OHIS, 8,
OLWS, 8,
Offset (0x70),
RQNS, 4,
RQWS, 1,
Offset (0x71),
RQTS, 1,
RQLS, 1,
Offset (0x72),
Offset (0x74),
MA0S, 3,
Offset (0x75),
MA1S, 3,
Offset (0x76)
}
IndexField (NDXS, ATAS, ByteAcc, NoLock, Preserve)
{
Offset (0xF0),
TRSS, 1,
PMCS, 1,
BSYS, 1,
, 4,
SESS, 1
}
OperationRegion (NSDL, SystemIO, 0x164C, 0x01)
Field (NSDL, ByteAcc, NoLock, Preserve)
{
DLPC, 8
}
OperationRegion (NSIO, SystemIO, 0x1680, 0x0C)
Field (NSIO, ByteAcc, NoLock, Preserve)
{
DRST, 1,
DLPD, 1,
ULRT, 1,
ULPD, 1,
Offset (0x01),
, 4,
DKI0, 1,
Offset (0x02),
Offset (0x09),
DKI1, 1,
DKI2, 1
}
OperationRegion (DSIO, SystemIO, 0x1620, 0x0C)
Field (DSIO, ByteAcc, NoLock, Preserve)
{
, 1,
DUSB, 1,
Offset (0x01),
BAHD, 1,
BAAT, 1,
Offset (0x02),
GER0, 8,
ES00, 1,
ES01, 1,
, 5,
ES07, 1,
, 6,
GO16, 1,
Offset (0x05),
Offset (0x07),
ES10, 1,
Offset (0x08),
UBPW, 1,
UHPW, 1,
Offset (0x09),
BPRS, 1,
UPRS, 1
}
Scope (\_SB.PCI0.LPC)
{
Device (DURT)
{
Name (_UID, 0x01) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (HDSP)
{
Return (0x00)
}
If (LEqual (\_SB.GDCK._STA (), 0x00))
{
Return (0x00)
}
Else
{
If (XU1E)
{
Return (0x0F)
}
Else
{
Return (0x0D)
}
}
}
Name (_HID, EisaId ("PNP0501")) // _HID: Hardware ID
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x18,
0x03
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (\H8DR)
{
If (Arg0)
{
Store (0x01, \_SB.PCI0.LPC.EC.HWRI)
}
Else
{
Store (0x00, \_SB.PCI0.LPC.EC.HWRI)
}
}
Else
{
If (Arg0)
{
\MBEC (0x32, 0xFF, 0x40)
}
Else
{
\MBEC (0x32, 0xBF, 0x00)
}
}
}
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Store (0x00, XU1E)
Store (0x03, LDN)
Store (0x00, IRQN)
Store (0x00, LDA)
Store (0x01, SP1D)
}
Name (U1BF, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0x08, // Length
_Y19)
IRQNoFlags (_Y1A)
{}
})
CreateWordField (U1BF, \_SB.PCI0.LPC.DURT._Y19._MIN, U1MN) // _MIN: Minimum Base Address
CreateWordField (U1BF, \_SB.PCI0.LPC.DURT._Y19._MAX, U1MX) // _MAX: Maximum Base Address
CreateWordField (U1BF, \_SB.PCI0.LPC.DURT._Y1A._INT, U1IQ) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Store (0x03, LDN)
Or (ShiftLeft (IOHI, 0x08), IOLW, Local0)
Store (Local0, U1MN)
Store (Local0, U1MX)
Store (IRQN, Local0)
If (Local0)
{
ShiftLeft (0x01, IRQN, U1IQ)
}
Else
{
Store (0x00, U1IQ)
}
Return (U1BF)
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
StartDependentFn (0x00, 0x00)
{
IO (Decode16,
0x03F8, // Range Minimum
0x03F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4}
}
StartDependentFn (0x01, 0x00)
{
IO (Decode16,
0x02F8, // Range Minimum
0x02F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3}
}
StartDependentFn (0x01, 0x00)
{
IO (Decode16,
0x03E8, // Range Minimum
0x03E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4}
}
StartDependentFn (0x01, 0x00)
{
IO (Decode16,
0x02E8, // Range Minimum
0x02E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3}
}
StartDependentFn (0x02, 0x00)
{
IO (Decode16,
0x03F8, // Range Minimum
0x03F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3,5,7}
}
StartDependentFn (0x02, 0x00)
{
IO (Decode16,
0x02F8, // Range Minimum
0x02F8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4,5,7}
}
StartDependentFn (0x02, 0x00)
{
IO (Decode16,
0x03E8, // Range Minimum
0x03E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{3,5,7}
}
StartDependentFn (0x02, 0x00)
{
IO (Decode16,
0x02E8, // Range Minimum
0x02E8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{4,5,7}
}
EndDependentFn ()
})
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateByteField (Arg0, 0x02, RUIL)
CreateByteField (Arg0, 0x03, RUIH)
CreateWordField (Arg0, 0x02, RUIO)
CreateWordField (Arg0, 0x09, RUIQ)
Store (0x03, LDN)
Store (0x00, LDA)
Store (RUIL, IOLW)
Store (RUIH, IOHI)
If (RUIQ)
{
FindSetRightBit (RUIQ, Local0)
Store (Decrement (Local0), IRQN)
}
Else
{
Store (0x00, IRQN)
}
Store (0x00, SP1D)
Store (0x01, LDA)
If (LEqual (RUIO, 0x03F8))
{
Store (0x00, XU1A)
}
Else
{
If (LEqual (RUIO, 0x02F8))
{
Store (0x01, XU1A)
}
Else
{
If (LEqual (RUIO, 0x03E8))
{
Store (0x07, XU1A)
}
Else
{
If (LEqual (RUIO, 0x02E8))
{
Store (0x05, XU1A)
}
Else
{
Fatal (0x02, 0x90020000, 0x01B8)
}
}
}
}
Store (0x01, XU1E)
}
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Store (0x03, LDN)
If (LDA)
{
Return (0x00)
}
Else
{
Return (0x03)
}
}
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
}
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
}
}
Device (DLPT)
{
Name (_UID, 0x01) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (HDPP)
{
Return (0x00)
}
If (LEqual (\_SB.GDCK._STA (), 0x00))
{
Return (0x00)
}
Else
{
If (LNotEqual (\PMOD, 0x03))
{
If (XPE)
{
Return (0x0F)
}
Else
{
Return (0x0D)
}
}
Else
{
Return (0x00)
}
}
}
Name (_HID, EisaId ("PNP0400")) // _HID: Hardware ID
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Store (0x00, XPE)
Store (0x01, LDN)
Store (0x00, IRQN)
Store (0x00, LDA)
Store (0x01, PPD)
}
Name (PPBF, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0x00, // Length
_Y1B)
IRQNoFlags (_Y1C)
{}
})
CreateWordField (PPBF, \_SB.PCI0.LPC.DLPT._Y1B._MIN, LPN0) // _MIN: Minimum Base Address
CreateWordField (PPBF, \_SB.PCI0.LPC.DLPT._Y1B._MAX, LPX0) // _MAX: Maximum Base Address
CreateByteField (PPBF, \_SB.PCI0.LPC.DLPT._Y1B._LEN, LPL0) // _LEN: Length
CreateWordField (PPBF, \_SB.PCI0.LPC.DLPT._Y1C._INT, LPIQ) // _INT: Interrupts
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
If (LEqual (\PMOD, 0x03))
{
Return (PPBF)
}
Store (0x01, LDN)
Or (ShiftLeft (IOHI, 0x08), IOLW, Local0)
Store (Local0, LPN0)
Store (Local0, LPX0)
If (LEqual (Local0, 0x03BC))
{
Store (0x03, LPL0)
}
Else
{
Store (0x08, LPL0)
}
Store (IRQN, Local0)
If (Local0)
{
ShiftLeft (0x01, IRQN, LPIQ)
}
Else
{
Store (0x00, LPIQ)
}
Return (PPBF)
}
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings
{
If (\PMOD)
{
Return (PEPP)
}
Else
{
Return (PLPT)
}
}
Name (PLPT, ResourceTemplate ()
{
StartDependentFnNoPri ()
{
IO (Decode16,
0x03BC, // Range Minimum
0x03BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IRQNoFlags ()
{7}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x03BC, // Range Minimum
0x03BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IRQNoFlags ()
{5}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
}
EndDependentFn ()
})
Name (PEPP, ResourceTemplate ()
{
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
}
EndDependentFn ()
})
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateByteField (Arg0, 0x02, RLIL)
CreateByteField (Arg0, 0x03, RLIH)
CreateWordField (Arg0, 0x02, RLIO)
CreateWordField (Arg0, 0x09, RLIQ)
Store (0x01, LDN)
Store (0x00, LDA)
Store (RLIL, IOLW)
Store (RLIH, IOHI)
If (RLIQ)
{
FindSetRightBit (RLIQ, Local0)
Store (Decrement (Local0), IRQN)
}
Else
{
Store (0x00, IRQN)
}
If (LEqual (\PMOD, 0x00))
{
If (\PDIR)
{
Store (0x01, PMDS)
}
Else
{
Store (0x00, PMDS)
}
}
Else
{
If (LEqual (\PMOD, 0x01))
{
Store (0x02, PMDS)
}
Else
{
Store (0x03, PMDS)
}
}
Store (0x00, PPD)
Store (0x01, LDA)
If (LEqual (RLIO, 0x0378))
{
Store (0x00, XPA)
}
Else
{
If (LEqual (RLIO, 0x0278))
{
Store (0x01, XPA)
}
Else
{
If (LEqual (RLIO, 0x03BC))
{
Store (0x02, XPA)
}
Else
{
Fatal (0x02, 0x90020000, 0x01D1)
}
}
}
Store (0x01, XPE)
}
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Store (0x01, LDN)
If (LDA)
{
Return (0x00)
}
Else
{
Return (0x03)
}
}
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
Store (0x01, LDN)
Store (0x01, LDA)
}
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
Store (0x01, LDN)
Store (0x00, LDA)
}
}
Device (DECP)
{
Name (_UID, 0x01) // _UID: Unique ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LEqual (\_SB.GDCK._STA (), 0x00))
{
Return (0x00)
}
Else
{
If (LEqual (\PMOD, 0x03))
{
If (XPE)
{
Return (0x0F)
}
Else
{
Return (0x0D)
}
}
Else
{
Return (0x00)
}
}
}
Name (_HID, EisaId ("PNP0401")) // _HID: Hardware ID
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device
{
Store (0x00, XPE)
Store (0x01, LDN)
Store (0x00, IRQN)
Store (0x00, LDA)
Store (0x01, PPD)
}
Name (EPBF, ResourceTemplate ()
{
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0x00, // Length
_Y1D)
IO (Decode16,
0x0000, // Range Minimum
0x0000, // Range Maximum
0x01, // Alignment
0x00, // Length
_Y1E)
IRQNoFlags (_Y1F)
{}
DMA (Compatibility, NotBusMaster, Transfer8, _Y20)
{}
})
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y1D._MIN, ECN0) // _MIN: Minimum Base Address
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y1D._MAX, ECX0) // _MAX: Maximum Base Address
CreateByteField (EPBF, \_SB.PCI0.LPC.DECP._Y1D._LEN, ECL0) // _LEN: Length
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y1E._MIN, ECN1) // _MIN: Minimum Base Address
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y1E._MAX, ECX1) // _MAX: Maximum Base Address
CreateByteField (EPBF, \_SB.PCI0.LPC.DECP._Y1E._LEN, ECL1) // _LEN: Length
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y1F._INT, ECIQ) // _INT: Interrupts
CreateWordField (EPBF, \_SB.PCI0.LPC.DECP._Y20._DMA, ECDQ) // _DMA: Direct Memory Access
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
If (LNotEqual (\PMOD, 0x03))
{
Return (EPBF)
}
Store (0x01, LDN)
Or (ShiftLeft (IOHI, 0x08), IOLW, Local0)
Store (Local0, ECN0)
Store (Local0, ECX0)
Add (Local0, 0x0400, ECN1)
Add (Local0, 0x0400, ECX1)
If (LEqual (Local0, 0x03BC))
{
Store (0x03, ECL0)
Store (0x03, ECL1)
}
Else
{
Store (0x08, ECL0)
Store (0x08, ECL1)
}
Store (IRQN, Local0)
If (Local0)
{
ShiftLeft (0x01, IRQN, ECIQ)
}
Else
{
Store (0x00, ECIQ)
}
Store (DMA0, Local0)
If (LLess (Local0, 0x04))
{
ShiftLeft (0x01, Local0, ECDQ)
}
Else
{
Store (0x00, ECDQ)
}
Return (EPBF)
}
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings
{
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IO (Decode16,
0x0778, // Range Minimum
0x0778, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IO (Decode16,
0x0678, // Range Minimum
0x0678, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x03BC, // Range Minimum
0x03BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IO (Decode16,
0x07BC, // Range Minimum
0x07BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IRQNoFlags ()
{7}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0378, // Range Minimum
0x0378, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IO (Decode16,
0x0778, // Range Minimum
0x0778, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{5}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x0278, // Range Minimum
0x0278, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IO (Decode16,
0x0678, // Range Minimum
0x0678, // Range Maximum
0x01, // Alignment
0x08, // Length
)
IRQNoFlags ()
{7}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
StartDependentFnNoPri ()
{
IO (Decode16,
0x03BC, // Range Minimum
0x03BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IO (Decode16,
0x07BC, // Range Minimum
0x07BC, // Range Maximum
0x01, // Alignment
0x03, // Length
)
IRQNoFlags ()
{5}
DMA (Compatibility, NotBusMaster, Transfer8, )
{0,1,3}
}
EndDependentFn ()
})
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings
{
CreateByteField (Arg0, 0x02, RLIL)
CreateByteField (Arg0, 0x03, RLIH)
CreateWordField (Arg0, 0x02, RLIO)
CreateWordField (Arg0, 0x11, RLIQ)
CreateByteField (Arg0, 0x14, RLDQ)
Store (0x01, LDN)
Store (0x00, LDA)
Store (0x07, PMDS)
Store (0x01, PERA)
Store (RLIL, IOLW)
Store (RLIH, IOHI)
If (RLIQ)
{
FindSetRightBit (RLIQ, Local0)
Store (Decrement (Local0), IRQN)
}
Else
{
Store (0x00, IRQN)
}
If (And (RLDQ, 0x0F))
{
FindSetRightBit (RLDQ, Local0)
Store (Decrement (Local0), DMA0)
}
Else
{
Store (0x04, DMA0)
}
Store (0x00, PPD)
Store (0x01, LDA)
If (LEqual (RLIO, 0x0378))
{
Store (0x00, XPA)
}
Else
{
If (LEqual (RLIO, 0x0278))
{
Store (0x01, XPA)
}
Else
{
If (LEqual (RLIO, 0x03BC))
{
Store (0x02, XPA)
}
Else
{
Fatal (0x02, 0x90020000, 0x01A2)
}
}
}
Store (0x01, XPE)
}
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current
{
Store (0x01, LDN)
If (LDA)
{
Return (0x00)
}
Else
{
Return (0x03)
}
}
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
Store (0x01, LDN)
Store (0x01, LDA)
}
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
Store (0x01, LDN)
Store (0x00, LDA)
}
}
}
Scope (\_SB.PCI0.LPC.DURT)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.LPC.DLPT)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.LPC.DECP)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.LPC)
{
Method (LCON, 1, NotSerialized)
{
If (Arg0)
{
If (EPWG)
{
Store (0x01, DLPD)
Store (0x07, DLPC)
While (LNot (And (0x08, DLPC)))
{
Sleep (0x01)
}
Store (0x01, DRST)
If (LNotEqual (SIOD, 0xFF))
{
Or (SCF9, 0xA0, SCF9)
While (LNot (And (0x10, SCF9)))
{
Sleep (0x01)
}
Or (SCF2, 0xEB, SCF2)
Store (0x07, LDN)
And (0x1620, 0xFF, Local0)
Store (Local0, IOLW)
ShiftRight (0x1620, 0x08, Local0)
And (Local0, 0xFF, IOHI)
Store (0x01, LDA)
Store (0x01, GPPS)
Store (0x03, GPPC)
Store (0x02, GPPS)
Store (0x03, GPPC)
Store (0x00, DUSB)
}
}
}
Else
{
Store (0x01, DUSB)
Store (0x00, DRST)
Store (0x00, DLPD)
Store (0x00, DLPC)
}
}
Method (LLCN, 1, NotSerialized)
{
If (Arg0)
{
Store (0x00, ULRT)
Store (0x01, ULPD)
Store (0x07, DLPC)
While (LNot (And (0x08, DLPC)))
{
Sleep (0x01)
}
Store (0x01, ULRT)
If (LNotEqual (SIOD, 0xFF))
{
Or (SCF9, 0xA0, SCF9)
While (LNot (And (0x10, SCF9)))
{
Sleep (0x01)
}
Or (SCF2, 0xEB, SCF2)
}
}
Else
{
Store (0x00, ULRT)
Store (0x00, ULPD)
Store (0x00, DLPC)
}
}
}
Device (TPM)
{
Name (_HID, EisaId ("ATM1200")) // _HID: Hardware ID
Name (_CID, EisaId ("PNP0C31")) // _CID: Compatible ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (And (\TPMP, 0x01))
{
Store (0x0F, Local0)
}
Else
{
Store (0x00, Local0)
}
Return (Local0)
}
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
Memory32Fixed (ReadWrite,
0xFED40000, // Address Base
0x00005000, // Address Length
)
})
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method
{
Name (TMPB, Buffer (0x02)
{
0x00, 0x00
})
CreateByteField (TMPB, 0x00, LPCT)
CreateByteField (TMPB, 0x01, SSUM)
Name (LRSP, 0x00)
Name (PPRC, 0x00)
Name (RQS1, Package (0x02)
{
0x0C,
0x0D
})
Name (PTOP, Package (0x02)
{
0x00,
0x00
})
Name (RTOP, Package (0x03)
{
0x00,
0x00,
0x00
})
CreateDWordField (Arg0, 0x00, IID0)
CreateDWordField (Arg0, 0x04, IID1)
CreateDWordField (Arg0, 0x08, IID2)
CreateDWordField (Arg0, 0x0C, IID3)
Name (UID0, Buffer (0x10)
{
/* 0000 */ 0xA6, 0xFA, 0xDD, 0x3D, 0x1B, 0x36, 0xB4, 0x4E,
/* 0008 */ 0xA4, 0x24, 0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53
})
CreateDWordField (UID0, 0x00, EID0)
CreateDWordField (UID0, 0x04, EID1)
CreateDWordField (UID0, 0x08, EID2)
CreateDWordField (UID0, 0x0C, EID3)
If (LAnd (LAnd (LEqual (IID0, EID0), LEqual (IID1, EID1)), LAnd (
LEqual (IID2, EID2), LEqual (IID3, EID3))))
{
If (LEqual (Arg2, 0x00))
{
Return (Buffer (0x01)
{
0x3F
})
}
If (LEqual (Arg2, 0x01))
{
Return ("1.0")
}
If (LEqual (Arg2, 0x02))
{
Store (0x00, PPRC)
TPHY (0x00)
Store (\PH02, LPCT)
If (LPCT)
{
Store (0x00, SSUM)
Add (SSUM, \PH01, SSUM)
Add (SSUM, \PH02, SSUM)
Add (SSUM, \PH03, SSUM)
Add (SSUM, \PH04, SSUM)
Add (SSUM, \PH05, SSUM)
Add (SSUM, \PH06, SSUM)
Add (SSUM, \PH07, SSUM)
Add (SSUM, \PH08, SSUM)
Add (SSUM, \PH09, SSUM)
Add (SSUM, \PH0A, SSUM)
Add (SSUM, \PH0B, SSUM)
If (SSUM)
{
Store (0x02, PPRC)
}
Else
{
Store (DerefOf (Index (Arg3, 0x00)), \PH04)
Store (Match (RQS1, MEQ, \PH04, MTR, 0x00, 0x00), Local0)
If (LNotEqual (Local0, Ones))
{
Store (0x01, PPRC)
}
Else
{
Store (0x00, \PH03)
Store (0x00, SSUM)
Add (SSUM, \PH01, SSUM)
Add (SSUM, \PH02, SSUM)
Add (SSUM, \PH03, SSUM)
Add (SSUM, \PH04, SSUM)
Add (SSUM, \PH05, SSUM)
Add (SSUM, \PH06, SSUM)
Add (SSUM, \PH07, SSUM)
Add (SSUM, \PH08, SSUM)
Add (SSUM, \PH09, SSUM)
Add (SSUM, \PH0A, SSUM)
Add (SSUM, \PH0B, SSUM)
Subtract (0x00, SSUM, \PH03)
TPHY (0x01)
}
}
}
Else
{
Store (0x02, PPRC)
}
Return (PPRC)
}
If (LEqual (Arg2, 0x03))
{
TPHY (0x00)
Store (\PH04, Index (PTOP, 0x01))
Return (PTOP)
}
If (LEqual (Arg2, 0x04))
{
Return (0x01)
}
If (LEqual (Arg2, 0x05))
{
TPHY (0x00)
Store (\PH07, Local0)
Store (\PH06, LRSP)
Store (Or (ShiftLeft (Local0, 0x08, Local0), LRSP), LRSP)
If (LAnd (LEqual (\PH06, 0xF0), LEqual (\PH07, 0xFF)))
{
Store (0xFFFFFFF0, LRSP)
}
Else
{
If (LAnd (LEqual (\PH06, 0xF1), LEqual (\PH07, 0xFF)))
{
Store (0xFFFFFFF1, LRSP)
}
}
Store (LRSP, Index (RTOP, 0x02))
Store (\PH05, Index (RTOP, 0x01))
Return (RTOP)
}
If (LEqual (Arg2, 0x06))
{
Return (0x02)
}
}
Name (UID1, Buffer (0x10)
{
/* 0000 */ 0xED, 0x54, 0x60, 0x37, 0x13, 0xCC, 0x75, 0x46,
/* 0008 */ 0x90, 0x1C, 0x47, 0x56, 0xD7, 0xF2, 0xD4, 0x5D
})
CreateDWordField (UID1, 0x00, EID4)
CreateDWordField (UID1, 0x04, EID5)
CreateDWordField (UID1, 0x08, EID6)
CreateDWordField (UID1, 0x0C, EID7)
If (LAnd (LAnd (LEqual (IID0, EID4), LEqual (IID1, EID5)), LAnd (
LEqual (IID2, EID6), LEqual (IID3, EID7))))
{
Store (Arg2, Debug)
Store (Arg3, Debug)
If (LEqual (Arg2, 0x00))
{
Return (Buffer (0x01)
{
0x01
})
}
If (LEqual (Arg2, 0x01))
{
If (LEqual (DerefOf (Index (Arg3, 0x00)), 0x00))
{
Store (0x00, \TCG0)
Store (0x01, \TCG1)
}
If (LEqual (DerefOf (Index (Arg3, 0x00)), 0x01))
{
Store (0x01, \TCG0)
Store (0x01, \TCG1)
}
Return (0x00)
}
Return (0x01)
}
Return (Buffer (0x01)
{
0x00
})
}
}
OperationRegion (TSES, SystemMemory, 0xFFE80000, 0x0200)
Field (TSES, ByteAcc, NoLock, Preserve)
{
Offset (0x0C),
TSCM, 8,
Offset (0x5D),
TCT0, 8,
TCT1, 8,
TCT2, 8,
Offset (0x6A),
TMT0, 8,
Offset (0x74),
TMT1, 8,
Offset (0x7E),
TMT2, 8,
Offset (0x174),
TLD0, 8,
TLD1, 8,
TLD2, 8,
TLDL, 24,
TLDB, 24,
TLDS, 16,
TSB0, 8,
TSB1, 8,
TSB2, 8,
TSBL, 8,
TSBB, 72,
TSBF, 16,
TSBC, 16,
Offset (0x1C4),
TSIM, 8
}
Field (TSES, ByteAcc, NoLock, Preserve)
{
Offset (0x5D),
TCTA, 280
}
Field (TSES, ByteAcc, NoLock, Preserve)
{
Offset (0x174),
TCTL, 88
}
Field (TSES, ByteAcc, NoLock, Preserve)
{
Offset (0x17F),
TCTB, 136
}
Method (TCSZ, 2, NotSerialized)
{
If (LNotEqual (TSCM, 0x12))
{
If (LEqual (0x01, Arg0))
{
Store (Arg1, TCZ1)
}
Else
{
If (LEqual (0x02, Arg0))
{
Store (Arg1, TCZ2)
}
Else
{
If (LEqual (0x03, Arg0))
{
Store (Arg1, TCZ3)
}
}
}
}
}
Method (TCST, 2, NotSerialized)
{
If (LNotEqual (TSCM, 0x12))
{
Store (0x00, Local0)
If (LEqual (0x01, Arg0))
{
If (LGreater (Arg1, TMT0))
{
Store (0x04, TSIM)
Store (Arg1, TMT0)
Store (0x01, Local0)
}
}
Else
{
If (LEqual (0x02, Arg0))
{
If (LGreater (Arg1, TMT1))
{
Store (0x04, TSIM)
Store (Arg1, TMT1)
Store (0x01, Local0)
}
}
Else
{
If (LEqual (0x03, Arg0))
{
If (LGreater (Arg1, TMT2))
{
Store (0x04, TSIM)
Store (Arg1, TMT2)
Store (0x01, Local0)
}
}
}
}
If (Local0)
{
Store (0x00, TCT2)
Name (TCTC, Buffer (0x23) {})
Store (TCTA, TCTC)
Store (0x22, Local3)
Store (0x00, Local1)
While (Local3)
{
Store (DerefOf (Index (TCTC, Local3)), Local2)
Add (Local1, Local2, Local1)
Decrement (Local3)
}
Store (Not (Local1), Local2)
Increment (Local2)
And (Local2, 0xFF, Local1)
Store (Local1, TCT2)
Store (0xFE, TSIM)
}
}
}
Method (TCBS, 4, NotSerialized)
{
If (LNotEqual (TSCM, 0x12))
{
If (LEqual (And (Arg0, 0x07), 0x00))
{
Store (0x12, TSIM)
Store (Arg0, TSBL)
Store (Arg1, TSBB)
Store (Arg2, TSBF)
Store (Arg3, TSBC)
Store (0x00, TSB2)
Name (TCTD, Buffer (0x23) {})
Store (TCTB, TCTD)
Store (0x10, Local0)
Store (0x00, Local1)
While (Local0)
{
Store (DerefOf (Index (TCTD, Local0)), Local2)
Add (Local1, Local2, Local1)
Decrement (Local0)
}
Store (Not (Local1), Local2)
Increment (Local2)
And (Local2, 0xFF, Local1)
Store (Local1, TSB2)
Store (0xFE, TSIM)
}
}
}
Method (TSCL, 2, NotSerialized)
{
If (LNotEqual (TSCM, 0x12))
{
Store (0x15, TSIM)
Add (TLDS, Arg1, TLDS)
Store (0x00, TLD2)
Name (TLDD, Buffer (0x0B) {})
Store (TCTL, TLDD)
Store (0x0A, Local0)
Store (0x00, Local1)
While (Local0)
{
Store (DerefOf (Index (TLDD, Local0)), Local2)
Add (Local1, Local2, Local1)
Decrement (Local0)
}
Store (Not (Local1), Local2)
Increment (Local2)
And (Local2, 0xFF, Local1)
Store (Local1, TLD2)
Store (0xFE, TSIM)
}
}
Device (EC)
{
Name (_HID, EisaId ("PNP0C09")) // _HID: Hardware ID
Name (_UID, 0x00) // _UID: Unique ID
Name (_GPE, 0x12) // _GPE: General Purpose Events
Method (_REG, 2, NotSerialized) // _REG: Region Availability
{
If (LEqual (Arg0, 0x03))
{
Store (Arg1, \H8DR)
}
}
OperationRegion (ECOR, EmbeddedControl, 0x00, 0x0100)
Field (ECOR, ByteAcc, NoLock, Preserve)
{
HDBM, 1,
, 1,
, 1,
HFNE, 1,
, 1,
, 1,
HLDM, 1,
Offset (0x01),
, 1,
BTCM, 1,
, 1,
, 1,
, 1,
HBPR, 1,
BTPC, 1,
Offset (0x02),
SLIS, 1,
Offset (0x03),
, 1,
HETE, 1,
, 3,
HAUM, 2,
Offset (0x05),
HSPA, 1,
Offset (0x06),
HSUN, 8,
HSRP, 8,
Offset (0x0C),
HLCL, 8,
Offset (0x0E),
HFNS, 2,
Offset (0x0F),
, 4,
HAAA, 3,
Offset (0x10),
HAM0, 8,
HAM1, 8,
HAM2, 8,
HAM3, 8,
HAM4, 8,
HAM5, 8,
HAM6, 8,
HAM7, 8,
HAM8, 8,
HAM9, 8,
HAMA, 8,
HAMB, 8,
HAMC, 8,
HAMD, 8,
HAME, 8,
HAMF, 8,
HT00, 1,
HT01, 1,
HT02, 1,
HT03, 1,
HT10, 1,
HT11, 1,
HT12, 1,
HT13, 1,
Offset (0x23),
HANT, 8,
Offset (0x26),
, 1,
, 1,
HANA, 2,
, 1,
, 1,
Offset (0x2A),
HATR, 8,
HT0H, 8,
HT0L, 8,
HT1H, 8,
HT1L, 8,
HFSP, 8,
, 6,
HMUT, 1,
Offset (0x31),
HBRV, 8,
HWPM, 1,
HWLB, 1,
HWLO, 1,
HWDK, 1,
HWFN, 1,
HWBT, 1,
HWRI, 1,
HWBU, 1,
HWLU, 1,
Offset (0x34),
, 7,
HPLO, 1,
Offset (0x36),
Offset (0x38),
HB0S, 7,
HB0A, 1,
HB1S, 7,
HB1A, 1,
HCMU, 1,
, 2,
OVRQ, 1,
DCBD, 1,
DCWL, 1,
DCWW, 1,
HB1I, 1,
, 1,
KBLT, 1,
BTPW, 1,
BTDT, 1,
HUBS, 1,
BDPW, 1,
BDDT, 1,
HUBB, 1,
Offset (0x46),
, 1,
BTWK, 1,
HPLD, 1,
, 1,
HPAC, 1,
BTST, 1,
Offset (0x47),
HPBU, 1,
, 1,
HBID, 4,
, 1,
HPNF, 1,
, 1,
GSTS, 1,
, 2,
HLBU, 1,
BDST, 1,
HCBL, 1,
Offset (0x4E),
HWAK, 16,
HMPR, 8,
HMST, 5,
, 2,
HMDN, 1,
HMAD, 8,
HMCM, 8,
Offset (0x74),
HMBC, 8,
Offset (0x78),
TMP0, 8,
TMP1, 8,
TMP2, 8,
TMP3, 8,
TMP4, 8,
TMP5, 8,
TMP6, 8,
TMP7, 8,
Offset (0x81),
HIID, 8,
Offset (0x83),
HFNI, 8,
Offset (0x88),
HDEC, 8,
HDEO, 8,
Offset (0x8D),
HDAA, 3,
HDAB, 3,
HDAC, 2,
Offset (0xB0),
HDEN, 32,
HDEP, 32,
HDEM, 8,
HDES, 8,
Offset (0xC8),
ATMX, 8,
HWAT, 8,
Offset (0xCE),
HBCS, 2,
, 2,
Offset (0xED),
, 4,
HDDD, 1
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
If (\H8DR)
{
Store (0x00, HSPA)
}
Else
{
\MBEC (0x05, 0xFE, 0x00)
}
BINI ()
\_SB.PCI0.LPC.EC.HKEY.WGIN ()
}
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
IO (Decode16,
0x0062, // Range Minimum
0x0062, // Range Maximum
0x01, // Alignment
0x01, // Length
)
IO (Decode16,
0x0066, // Range Minimum
0x0066, // Range Maximum
0x01, // Alignment
0x01, // Length
)
})
Method (LED, 2, NotSerialized)
{
Or (Arg0, Arg1, Local0)
If (\H8DR)
{
Store (Local0, HLCL)
}
Else
{
\WBEC (0x0C, Local0)
}
}
Name (BAON, 0x00)
Name (WBON, 0x00)
Method (BEEP, 1, NotSerialized)
{
If (LEqual (Arg0, 0x05))
{
Store (0x00, WBON)
}
Store (WBON, Local2)
If (BAON)
{
If (LEqual (Arg0, 0x00))
{
Store (0x00, BAON)
If (WBON)
{
Store (0x03, Local0)
Store (0x08, Local1)
}
Else
{
Store (0x00, Local0)
Store (0x00, Local1)
}
}
Else
{
Store (0xFF, Local0)
Store (0xFF, Local1)
If (LEqual (Arg0, 0x11))
{
Store (0x00, WBON)
}
If (LEqual (Arg0, 0x10))
{
Store (0x01, WBON)
}
}
}
Else
{
Store (Arg0, Local0)
Store (0xFF, Local1)
If (LEqual (Arg0, 0x0F))
{
Store (Arg0, Local0)
Store (0x08, Local1)
Store (0x01, BAON)
}
If (LEqual (Arg0, 0x11))
{
Store (0x00, Local0)
Store (0x00, Local1)
Store (0x00, WBON)
}
If (LEqual (Arg0, 0x10))
{
Store (0x03, Local0)
Store (0x08, Local1)
Store (0x01, WBON)
}
}
If (LEqual (Arg0, 0x03))
{
Store (0x00, WBON)
If (Local2)
{
Store (0x07, Local0)
If (LOr (LEqual (\SPS, 0x03), LEqual (\SPS, 0x04)))
{
Store (0x00, Local2)
Store (0xFF, Local0)
Store (0xFF, Local1)
}
}
}
If (LEqual (Arg0, 0x07))
{
If (Local2)
{
Store (0x00, Local2)
Store (0xFF, Local0)
Store (0xFF, Local1)
}
}
If (LAnd (\H8DR, LNot (\W98F)))
{
If (LAnd (Local2, LNot (WBON)))
{
Store (0x00, HSRP)
Store (0x00, HSUN)
Sleep (0x64)
}
If (LNotEqual (Local1, 0xFF))
{
Store (Local1, HSRP)
}
If (LNotEqual (Local0, 0xFF))
{
Store (Local0, HSUN)
}
}
Else
{
If (LAnd (Local2, LNot (WBON)))
{
\WBEC (0x07, 0x00)
\WBEC (0x06, 0x00)
Sleep (0x64)
}
If (LNotEqual (Local1, 0xFF))
{
\WBEC (0x07, Local1)
}
If (LNotEqual (Local0, 0xFF))
{
\WBEC (0x06, Local0)
}
}
If (LEqual (Arg0, 0x03)) {}
If (LEqual (Arg0, 0x07))
{
Sleep (0x01F4)
}
}
Method (EVNT, 1, NotSerialized)
{
If (\H8DR)
{
If (Arg0)
{
Or (HAM7, 0x01, HAM7)
Or (HAM5, 0x04, HAM5)
}
Else
{
And (HAM7, 0xFE, HAM7)
And (HAM5, 0xFB, HAM5)
}
}
Else
{
If (Arg0)
{
\MBEC (0x17, 0xFF, 0x01)
\MBEC (0x15, 0xFF, 0x04)
If (\W98F)
{
\WBEC (0x18, 0xFF)
}
}
Else
{
\MBEC (0x17, 0xFE, 0x00)
\MBEC (0x15, 0xFB, 0x00)
If (\W98F)
{
\WBEC (0x18, 0x00)
}
}
}
}
Method (PNST, 1, NotSerialized)
{
If (LAnd (Arg0, BSTA (0x02)))
{
If (LAnd (\H8DR, LNot (\W98F)))
{
Store (0x01, HBPR)
Store (0x01, HUBB)
}
Else
{
\MBEC (0x01, 0xFF, 0x20)
\MBEC (0x3B, 0xFF, 0x80)
}
}
Else
{
If (LAnd (\H8DR, LNot (\W98F)))
{
Store (0x00, HBPR)
Store (0x00, HUBB)
}
Else
{
\MBEC (0x01, 0xDF, 0x00)
\MBEC (0x3B, 0x7F, 0x00)
}
}
}
PowerResource (PUBS, 0x03, 0x0000)
{
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (\H8DR)
{
Store (HUBS, Local0)
}
Else
{
And (\RBEC (0x3B), 0x10, Local0)
}
If (Local0)
{
Return (0x01)
}
Else
{
Return (0x00)
}
}
Method (_ON, 0, NotSerialized) // _ON_: Power On
{
If (\H8DR)
{
Store (0x01, HUBS)
}
Else
{
\MBEC (0x3B, 0xFF, 0x10)
}
}
Method (_OFF, 0, NotSerialized) // _OFF: Power Off
{
If (\H8DR)
{
Store (0x00, HUBS)
}
Else
{
\MBEC (0x3B, 0xEF, 0x00)
}
}
}
Method (LPMD, 0, NotSerialized)
{
Store (0x00, Local0)
Store (0x00, Local1)
Store (0x00, Local2)
If (\H8DR)
{
If (HPAC)
{
If (HPLO)
{
Store (\LPST, Local0)
}
Else
{
If (LLess (HWAT, 0x5A))
{
If (HB0A)
{
If (LOr (And (HB0S, 0x10), LLess (And (HB0S, 0x0F
), 0x02)))
{
Store (0x01, Local1)
}
}
Else
{
Store (0x01, Local1)
}
If (HB1A)
{
If (LOr (And (HB1S, 0x10), LLess (And (HB1S, 0x0F
), 0x02)))
{
Store (0x01, Local2)
}
}
Else
{
Store (0x01, Local2)
}
If (LAnd (Local1, Local2))
{
Store (\LPST, Local0)
}
}
}
}
}
Else
{
If (And (\RBEC (0x46), 0x10))
{
If (And (\RBEC (0x34), 0x80))
{
Store (\LPST, Local0)
}
Else
{
If (LLess (\RBEC (0xC9), 0x5A))
{
Store (\RBEC (0x38), Local3)
If (And (Local3, 0x80))
{
If (LOr (And (Local3, 0x10), LLess (And (Local3, 0x0F
), 0x02)))
{
Store (0x01, Local1)
}
}
Else
{
Store (0x01, Local2)
}
Store (\RBEC (0x39), Local3)
If (And (Local3, 0x80))
{
If (LOr (And (Local3, 0x10), LLess (And (Local3, 0x0F
), 0x02)))
{
Store (0x01, Local1)
}
}
Else
{
Store (0x01, Local2)
}
If (LAnd (Local1, Local2))
{
Store (\LPST, Local0)
}
}
}
}
}
Return (Local0)
}
Method (CLPM, 0, NotSerialized)
{
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
Store (LPMD (), Local0)
If (Local0)
{
\STEP (0x04)
}
Else
{
\STEP (0x05)
}
}
}
}
Mutex (MCPU, 0x07)
Method (_Q10, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x01))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1001)
}
}
Method (_Q11, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x02))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1002)
}
Else
{
Noop
}
}
Method (_Q12, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1003)
}
Method (_Q13, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.DHKC)
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1004)
}
Else
{
Notify (\_SB.SLPB, 0x80)
}
}
Method (_Q64, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x10))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1005)
}
}
Method (_Q65, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x20))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1006)
}
}
Method (_Q16, 0, NotSerialized) // _Qxx: EC Query
{
If (\VPDF)
{
Store (0x00, \VPDF)
If (VIGD)
{
\_SB.PCI0.VID.VSPD ()
}
}
Else
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x40))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1007)
}
Else
{
If (VIGD)
{
\_SB.PCI0.VID.VSWT ()
}
Else
{
\_SB.PCI0.AGP.VID.VSWT ()
}
}
}
}
Method (_Q17, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x80))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1008)
}
Else
{
If (LNot (\WNTF))
{
VEXP ()
}
}
}
Method (_Q18, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x0100))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1009)
}
Noop
}
Method (_Q66, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x0200))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100A)
}
}
Method (_Q1A, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x0400))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100B)
}
}
Method (_Q1B, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100C)
}
Method (_Q62, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x1000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100D)
}
}
Method (_Q60, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x2000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100E)
}
}
Method (_Q61, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x4000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100F)
}
}
Method (_Q1F, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00020000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1012)
}
\UCMS (0x0E)
}
Method (_Q67, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00040000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1013)
}
}
Method (_Q26, 0, NotSerialized) // _Qxx: EC Query
{
If (VIGD)
{
If (\WVIS)
{
\VBTD ()
}
\_SB.PCI0.LPC.EC.BRNS ()
}
Else
{
\UCMS (0x12)
}
Sleep (0x01F4)
Notify (AC, 0x80)
Notify (\_TZ.THM0, 0x80)
Notify (\_TZ.THM1, 0x80)
If (\WXPF)
{
Acquire (MCPU, 0xFFFF)
}
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHC4))
{
Store (0x00, \C4AC)
}
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
\STEP (0x00)
}
}
If (\WXPF)
{
Sleep (0x64)
}
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
If (\WXPF)
{
Release (MCPU)
}
If (LAnd (LNot (\WXPF), \WNTF))
{
If (LNot (\C4AC))
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
}
}
ATMC ()
}
Method (_Q27, 0, NotSerialized) // _Qxx: EC Query
{
If (VIGD)
{
If (\WVIS)
{
\VBTD ()
}
\_SB.PCI0.LPC.EC.BRNS ()
\_SB.PCI0.VID.VDSP ()
}
Else
{
\UCMS (0x12)
}
Sleep (0x01F4)
Notify (AC, 0x80)
Notify (\_TZ.THM0, 0x80)
Notify (\_TZ.THM1, 0x80)
If (\WXPF)
{
Acquire (MCPU, 0xFFFF)
}
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHC4))
{
Store (0x01, \C4AC)
}
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
\STEP (0x01)
}
}
If (\WXPF)
{
Sleep (0x64)
}
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
If (\WXPF)
{
Release (MCPU)
}
If (LAnd (LNot (\WXPF), \WNTF))
{
If (LNot (\_SB.PCI0.LPC.EC.HKEY.CKC4 (0x00)))
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
ATMC ()
If (LOr (LEqual (\_SB.GDCK.GDID (), 0x4C004D24), LEqual (\_SB.GDCK.GDID (), 0x44004D24)))
{
Notify (\_SB.GDCK, 0x01)
}
}
Method (_Q2A, 0, NotSerialized) // _Qxx: EC Query
{
If (VIGD)
{
\_SB.PCI0.VID.GLIS (0x01)
}
If (VIGD)
{
\_SB.PCI0.VID.VLOC (0x01)
}
Else
{
\_SB.PCI0.AGP.VID.VLOC (0x01)
}
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5002)
Notify (\_SB.LID, 0x80)
}
Method (_Q2B, 0, NotSerialized) // _Qxx: EC Query
{
If (VIGD)
{
\_SB.PCI0.VID.GLIS (0x00)
}
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5001)
\UCMS (0x0D)
Notify (\_SB.LID, 0x80)
}
Method (_Q3D, 0, NotSerialized) // _Qxx: EC Query
{
}
Method (_Q48, 0, NotSerialized) // _Qxx: EC Query
{
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
\STEP (0x04)
}
}
}
Method (_Q49, 0, NotSerialized) // _Qxx: EC Query
{
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
\STEP (0x05)
}
}
}
Method (_Q7F, 0, NotSerialized) // _Qxx: EC Query
{
Fatal (0x01, 0x80010000, 0x035A)
}
Method (_Q4E, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6011)
}
Method (_Q4F, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6012)
}
Method (_Q75, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.TATR ()
}
Method (_Q46, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6012)
}
Method (_Q22, 0, NotSerialized) // _Qxx: EC Query
{
CLPM ()
If (HB0A)
{
Notify (BAT0, 0x80)
}
If (LAnd (^BAT1.B1ST, ^BAT1.XB1S))
{
Notify (BAT1, 0x80)
}
If (LAnd (^BAT2.B2ST, ^BAT2.XB2S))
{
Notify (BAT2, 0x80)
}
}
Method (_Q4A, 0, NotSerialized) // _Qxx: EC Query
{
CLPM ()
Notify (BAT0, 0x81)
}
Method (_Q4B, 0, NotSerialized) // _Qxx: EC Query
{
Notify (BAT0, 0x80)
}
Method (_Q4C, 0, NotSerialized) // _Qxx: EC Query
{
CLPM ()
If (LOr (LEqual (BDEV, 0x10), LEqual (HBCS, 0x02)))
{
_Q38 ()
Store (0x00, HB1I)
}
Else
{
If (^BAT2.XB2S)
{
Notify (BAT2, 0x81)
}
Else
{
If (HB1A)
{
Store (0x01, ^BAT2.XB2S)
Notify (BAT2, 0x01)
}
}
}
}
Method (_Q4D, 0, NotSerialized) // _Qxx: EC Query
{
If (LAnd (^BAT1.B1ST, ^BAT1.XB1S))
{
Notify (BAT1, 0x80)
}
If (LAnd (^BAT2.B2ST, ^BAT2.XB2S))
{
Notify (BAT2, 0x80)
}
}
Method (_Q24, 0, NotSerialized) // _Qxx: EC Query
{
CLPM ()
Notify (BAT0, 0x80)
}
Method (_Q25, 0, NotSerialized) // _Qxx: EC Query
{
If (LAnd (^BAT1.B1ST, ^BAT1.XB1S))
{
CLPM ()
Notify (BAT1, 0x80)
}
If (LAnd (^BAT2.B2ST, ^BAT2.XB2S))
{
Notify (BAT2, 0x80)
}
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
SBRC, 16,
SBFC, 16,
SBAE, 16,
SBRS, 16,
SBAC, 16,
SBVO, 16,
SBAF, 16,
SBBS, 16
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
, 15,
SBCM, 1,
SBMD, 16,
SBCC, 16
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
SBDC, 16,
SBDV, 16,
SBOM, 16,
SBSI, 16,
SBDT, 16,
SBSN, 16
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
SBCH, 32
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
SBMN, 128
}
Field (ECOR, ByteAcc, NoLock, Preserve)
{
Offset (0xA0),
SBDN, 128
}
Mutex (BATM, 0x07)
Method (GBIF, 3, NotSerialized)
{
Acquire (BATM, 0xFFFF)
If (Arg2)
{
Or (Arg0, 0x01, HIID)
Store (SBCM, Local7)
XOr (Local7, 0x01, Index (Arg1, 0x00))
Store (Arg0, HIID)
If (Local7)
{
Multiply (SBFC, 0x0A, Local1)
}
Else
{
Store (SBFC, Local1)
}
Store (Local1, Index (Arg1, 0x02))
Or (Arg0, 0x02, HIID)
If (Local7)
{
Multiply (SBDC, 0x0A, Local0)
}
Else
{
Store (SBDC, Local0)
}
Store (Local0, Index (Arg1, 0x01))
Divide (Local1, 0x14, Local2, Index (Arg1, 0x05))
If (Local7)
{
Store (0xC8, Index (Arg1, 0x06))
}
Else
{
If (SBDV)
{
Divide (0x00030D40, SBDV, Local2, Index (Arg1, 0x06))
}
Else
{
Store (0x00, Index (Arg1, 0x06))
}
}
Store (SBDV, Index (Arg1, 0x04))
Store (SBSN, Local0)
Name (SERN, Buffer (0x06)
{
" "
})
Store (0x04, Local2)
While (Local0)
{
Divide (Local0, 0x0A, Local1, Local0)
Add (Local1, 0x30, Index (SERN, Local2))
Decrement (Local2)
}
Store (SERN, Index (Arg1, 0x0A))
Or (Arg0, 0x06, HIID)
Store (SBDN, Index (Arg1, 0x09))
Or (Arg0, 0x04, HIID)
Name (BTYP, Buffer (0x05)
{
0x00, 0x00, 0x00, 0x00, 0x00
})
Store (SBCH, BTYP)
Store (BTYP, Index (Arg1, 0x0B))
Or (Arg0, 0x05, HIID)
Store (SBMN, Index (Arg1, 0x0C))
}
Else
{
Store (0xFFFFFFFF, Index (Arg1, 0x01))
Store (0x00, Index (Arg1, 0x05))
Store (0x00, Index (Arg1, 0x06))
Store (0xFFFFFFFF, Index (Arg1, 0x02))
}
Release (BATM)
Return (Arg1)
}
Method (GBST, 4, NotSerialized)
{
Acquire (BATM, 0xFFFF)
If (And (Arg1, 0x20))
{
Store (0x02, Local0)
}
Else
{
If (And (Arg1, 0x40))
{
Store (0x01, Local0)
}
Else
{
Store (0x00, Local0)
}
}
If (And (Arg1, 0x0F)) {}
Else
{
Or (Local0, 0x04, Local0)
}
If (LEqual (And (Arg1, 0x0F), 0x0F))
{
Store (0x04, Local0)
Store (0x00, Local1)
Store (0x00, Local2)
Store (0x00, Local3)
}
Else
{
Store (Arg0, HIID)
Store (SBVO, Local3)
If (Arg2)
{
Multiply (SBRC, 0x0A, Local2)
}
Else
{
Store (SBRC, Local2)
}
Store (SBAC, Local1)
If (LGreaterEqual (Local1, 0x8000))
{
If (And (Local0, 0x01))
{
Subtract (0x00010000, Local1, Local1)
}
Else
{
Store (0x00, Local1)
}
}
Else
{
If (LNot (And (Local0, 0x02)))
{
Store (0x00, Local1)
}
}
If (Arg2)
{
Multiply (Local3, Local1, Local1)
Divide (Local1, 0x03E8, Local7, Local1)
}
}
Store (Local0, Index (Arg3, 0x00))
Store (Local1, Index (Arg3, 0x01))
Store (Local2, Index (Arg3, 0x02))
Store (Local3, Index (Arg3, 0x03))
Release (BATM)
Return (Arg3)
}
Device (BAT0)
{
Name (_HID, EisaId ("PNP0C0A")) // _HID: Hardware ID
Name (_UID, 0x00) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Name (B0ST, 0x00)
Name (BT0I, Package (0x0D)
{
0x00,
0xFFFFFFFF,
0xFFFFFFFF,
0x01,
0x2A30,
0x00,
0x00,
0x01,
0x01,
"",
"",
"",
""
})
Name (BT0P, Package (0x04) {})
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (\H8DR)
{
Store (HB0A, B0ST)
}
Else
{
If (And (\RBEC (0x38), 0x80))
{
Store (0x01, B0ST)
}
Else
{
Store (0x00, B0ST)
}
}
If (B0ST)
{
Return (0x1F)
}
Else
{
Return (0x0F)
}
}
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
Store (0x00, Local7)
Store (0x0A, Local6)
While (LAnd (LNot (Local7), Local6))
{
If (HB0A)
{
If (LEqual (And (HB0S, 0x0F), 0x0F))
{
Sleep (0x03E8)
Decrement (Local6)
}
Else
{
Store (0x01, Local7)
}
}
Else
{
Store (0x00, Local6)
}
}
Return (GBIF (0x00, BT0I, Local7))
}
Method (_BST, 0, NotSerialized) // _BST: Battery Status
{
XOr (DerefOf (Index (BT0I, 0x00)), 0x01, Local0)
Return (GBST (0x00, HB0S, Local0, BT0P))
}
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point
{
And (HAM4, 0xEF, HAM4)
If (Arg0)
{
Store (Arg0, Local1)
If (LNot (DerefOf (Index (BT0I, 0x00))))
{
Divide (Local1, 0x0A, Local0, Local1)
}
And (Local1, 0xFF, HT0L)
And (ShiftRight (Local1, 0x08), 0xFF, HT0H)
Or (HAM4, 0x10, HAM4)
}
}
}
Device (BAT1)
{
Name (_HID, EisaId ("PNP0C0A")) // _HID: Hardware ID
Name (_UID, 0x02) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Name (B1ST, 0x00)
Name (XB1S, 0x01)
Name (BT1I, Package (0x0D)
{
0x00,
0xFFFFFFFF,
0xFFFFFFFF,
0x01,
0x2A30,
0x00,
0x00,
0x01,
0x01,
"",
"",
"",
""
})
Name (BT1P, Package (0x04)
{
0x00,
0x00,
0x00,
0x00
})
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (\H8DR)
{
If (LAnd (\WNTF, And (HBCS, 0x02)))
{
Store (HB1A, B1ST)
}
}
Else
{
If (LAnd (\WNTF, And (\RBEC (0xCE), 0x02)))
{
If (And (\RBEC (0x39), 0x80))
{
Store (0x01, B1ST)
}
Else
{
Store (0x00, B1ST)
}
}
}
If (B1ST)
{
If (XB1S)
{
Return (0x1F)
}
Else
{
If (\WNTF)
{
Return (0x00)
}
Else
{
Return (0x1F)
}
}
}
Else
{
If (\WNTF)
{
Return (0x00)
}
Else
{
Return (0x0F)
}
}
}
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
If (LNot (B1ST))
{
Return (BT1I)
}
Store (0x00, Local7)
Store (0x0A, Local6)
While (LAnd (LNot (Local7), Local6))
{
If (HB1A)
{
If (LEqual (And (HB1S, 0x0F), 0x0F))
{
Sleep (0x03E8)
Decrement (Local6)
}
Else
{
Store (0x01, Local7)
}
}
Else
{
Store (0x00, Local6)
}
}
Return (GBIF (0x10, BT1I, Local7))
}
Method (_BST, 0, NotSerialized) // _BST: Battery Status
{
If (LNot (B1ST))
{
Return (BT1P)
}
XOr (DerefOf (Index (BT1I, 0x00)), 0x01, Local0)
Return (GBST (0x10, HB1S, Local0, BT1P))
}
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point
{
If (B1ST)
{
And (HAM4, 0xDF, HAM4)
If (Arg0)
{
Store (Arg0, Local1)
If (LNot (DerefOf (Index (BT1I, 0x00))))
{
Divide (Local1, 0x0A, Local0, Local1)
}
And (Local1, 0xFF, HT1L)
And (ShiftRight (Local1, 0x08), 0xFF, HT1H)
Or (HAM4, 0x20, HAM4)
}
}
}
}
Device (BAT2)
{
Name (_HID, EisaId ("PNP0C0A")) // _HID: Hardware ID
Name (_UID, 0x01) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Name (B2ST, 0x00)
Name (XB2S, 0x01)
Name (IFLG, 0x00)
Name (BT2I, Package (0x0D)
{
0x00,
0xFFFFFFFF,
0xFFFFFFFF,
0x01,
0x2A30,
0x00,
0x00,
0x01,
0x01,
"",
"",
"",
""
})
Name (BT2P, Package (0x04)
{
0x00,
0x00,
0x00,
0x00
})
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
If (LEqual (\_SB.PCI0.LPC.EC.GSID (), 0x03))
{
Store (0x00, XB2S)
}
Else
{
If (\WNTF)
{
If (\H8DR)
{
Store (HB1A, Local0)
}
Else
{
And (\RBEC (0x39), 0x80, Local0)
}
If (LNot (Local0))
{
Store (0x00, XB2S)
}
}
}
Store (0x01, IFLG)
}
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (LNot (IFLG))
{
_INI ()
}
If (\H8DR)
{
If (LAnd (\WNTF, And (HBCS, 0x02)))
{
Store (0x00, B2ST)
}
Else
{
Store (HB1A, B2ST)
}
}
Else
{
If (LAnd (\WNTF, And (\RBEC (0xCE), 0x02)))
{
Store (0x00, B2ST)
}
Else
{
If (And (\RBEC (0xCE), 0x01))
{
Store (0x01, B2ST)
}
Else
{
Store (0x00, B2ST)
}
}
}
If (B2ST)
{
If (XB2S)
{
Return (0x1F)
}
Else
{
Return (0x00)
}
}
Else
{
If (XB2S)
{
Return (0x0F)
}
Else
{
Return (0x00)
}
}
}
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information
{
If (LNot (B2ST))
{
Return (BT2I)
}
Store (0x00, Local7)
Store (0x0A, Local6)
While (LAnd (LNot (Local7), Local6))
{
If (HB1A)
{
If (LEqual (And (HB1S, 0x0F), 0x0F))
{
Sleep (0x03E8)
Decrement (Local6)
}
Else
{
Store (0x01, Local7)
}
}
Else
{
Store (0x00, Local6)
}
}
Return (GBIF (0x10, BT2I, Local7))
}
Method (_BST, 0, NotSerialized) // _BST: Battery Status
{
If (LNot (B2ST))
{
Return (BT2P)
}
XOr (DerefOf (Index (BT2I, 0x00)), 0x01, Local0)
Return (GBST (0x10, HB1S, Local0, BT2P))
}
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point
{
If (B2ST)
{
And (HAM4, 0xDF, HAM4)
If (Arg0)
{
Store (Arg0, Local1)
If (LNot (DerefOf (Index (BT2I, 0x00))))
{
Divide (Local1, 0x0A, Local0, Local1)
}
And (Local1, 0xFF, HT1L)
And (ShiftRight (Local1, 0x08), 0xFF, HT1H)
Or (HAM4, 0x20, HAM4)
}
}
}
}
Device (AC)
{
Name (_HID, "ACPI0003") // _HID: Hardware ID
Name (_UID, 0x00) // _UID: Unique ID
Name (_PCL, Package (0x01) // _PCL: Power Consumer List
{
\_SB
})
Method (_PSR, 0, NotSerialized) // _PSR: Power Source
{
Return (HPAC)
}
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
}
Device (HKEY)
{
Name (_HID, EisaId ("IBM0068")) // _HID: Hardware ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
Return (0x0F)
}
Method (MHKV, 0, NotSerialized)
{
Return (0x0100)
}
Name (DHKC, 0x00)
Name (DHKB, 0x01)
Mutex (XDHK, 0x07)
Name (DHKH, 0x00)
Name (DHKW, 0x00)
Name (DHKS, 0x00)
Name (DHKD, 0x00)
Name (DHKN, 0x080C)
Name (DHKT, 0x00)
Name (DHWW, 0x00)
Name (DHC4, 0x00)
Method (MHKA, 0, NotSerialized)
{
Return (0x00FFFFFF)
}
Method (MHKN, 0, NotSerialized)
{
Return (DHKN)
}
Method (MHKK, 1, NotSerialized)
{
If (DHKC)
{
Return (And (DHKN, Arg0))
}
Else
{
Return (Zero)
}
}
Method (MHKM, 2, NotSerialized)
{
Acquire (XDHK, 0xFFFF)
If (LGreater (Arg0, 0x20))
{
Noop
}
Else
{
ShiftLeft (One, Decrement (Arg0), Local0)
If (And (Local0, 0x00FFFFFF))
{
If (Arg1)
{
Or (Local0, DHKN, DHKN)
}
Else
{
And (DHKN, XOr (Local0, 0xFFFFFFFF), DHKN)
}
}
Else
{
Noop
}
}
Release (XDHK)
}
Method (MHKS, 0, NotSerialized)
{
Notify (\_SB.SLPB, 0x80)
}
Method (MHKC, 1, NotSerialized)
{
Store (Arg0, DHKC)
}
Method (MHKP, 0, NotSerialized)
{
Acquire (XDHK, 0xFFFF)
If (DHWW)
{
Store (DHWW, Local1)
Store (Zero, DHWW)
}
Else
{
If (DHKW)
{
Store (DHKW, Local1)
Store (Zero, DHKW)
}
Else
{
If (DHKD)
{
Store (DHKD, Local1)
Store (Zero, DHKD)
}
Else
{
If (DHKS)
{
Store (DHKS, Local1)
Store (Zero, DHKS)
}
Else
{
If (DHKT)
{
Store (DHKT, Local1)
Store (Zero, DHKT)
}
Else
{
Store (DHKH, Local1)
Store (Zero, DHKH)
}
}
}
}
}
Release (XDHK)
Return (Local1)
}
Method (MHKE, 1, NotSerialized)
{
Store (Arg0, DHKB)
Acquire (XDHK, 0xFFFF)
Store (Zero, DHKH)
Store (Zero, DHKW)
Store (Zero, DHKS)
Store (Zero, DHKD)
Store (Zero, DHKT)
Store (Zero, DHWW)
Release (XDHK)
}
Method (MHKQ, 1, NotSerialized)
{
If (DHKB)
{
If (DHKC)
{
Acquire (XDHK, 0xFFFF)
If (LLess (Arg0, 0x1000)) {}
Else
{
If (LLess (Arg0, 0x2000))
{
Store (Arg0, DHKH)
}
Else
{
If (LLess (Arg0, 0x3000))
{
Store (Arg0, DHKW)
}
Else
{
If (LLess (Arg0, 0x4000))
{
Store (Arg0, DHKS)
}
Else
{
If (LLess (Arg0, 0x5000))
{
Store (Arg0, DHKD)
}
Else
{
If (LLess (Arg0, 0x6000))
{
Store (Arg0, DHKH)
}
Else
{
If (LLess (Arg0, 0x7000))
{
Store (Arg0, DHKT)
}
Else
{
If (LLess (Arg0, 0x8000))
{
Store (Arg0, DHWW)
}
Else
{
}
}
}
}
}
}
}
}
Release (XDHK)
Notify (HKEY, 0x80)
}
Else
{
If (LEqual (Arg0, 0x1004))
{
Notify (\_SB.SLPB, 0x80)
}
}
}
}
Method (MHKB, 1, NotSerialized)
{
If (LEqual (Arg0, 0x00))
{
\_SB.PCI0.LPC.EC.BEEP (0x11)
Store (0x00, \LIDB)
}
Else
{
If (LEqual (Arg0, 0x01))
{
\_SB.PCI0.LPC.EC.BEEP (0x10)
Store (0x01, \LIDB)
}
Else
{
}
}
}
Method (MHKD, 0, NotSerialized)
{
If (VIGD)
{
\_SB.PCI0.VID.VLOC (0x00)
}
Else
{
\_SB.PCI0.AGP.VID.VLOC (0x00)
}
}
Method (MHQC, 1, NotSerialized)
{
If (\WNTF)
{
If (LEqual (Arg0, 0x00))
{
Return (\CWAC)
}
Else
{
If (LEqual (Arg0, 0x01))
{
Return (\CWAP)
}
Else
{
If (LEqual (Arg0, 0x02))
{
Return (\CWAT)
}
Else
{
Noop
}
}
}
}
Else
{
Noop
}
Return (0x00)
}
Method (MHGC, 0, NotSerialized)
{
If (\WNTF)
{
Acquire (XDHK, 0xFFFF)
If (CKC4 (0x00))
{
Store (0x03, Local0)
}
Else
{
Store (0x04, Local0)
}
Release (XDHK)
Return (Local0)
}
Else
{
Noop
}
Return (0x00)
}
Method (MHSC, 1, NotSerialized)
{
If (LAnd (\CWAC, \WNTF))
{
Acquire (XDHK, 0xFFFF)
If (\OSC4)
{
If (LEqual (Arg0, 0x03))
{
If (LNot (\CWAS))
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
Store (0x01, \CWAS)
}
}
Else
{
If (LEqual (Arg0, 0x04))
{
If (\CWAS)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
Store (0x00, \CWAS)
}
}
Else
{
Noop
}
}
}
Else
{
If (LEqual (Arg0, 0x03))
{
If (LNot (\CWAS))
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
Store (0x01, \CWAS)
}
}
Else
{
If (LEqual (Arg0, 0x04))
{
If (\CWAS)
{
Store (0x00, \CWAS)
If (LNot (CKC4 (0x00)))
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
}
Else
{
Noop
}
}
}
Release (XDHK)
}
Else
{
Noop
}
}
Method (CKC4, 1, NotSerialized)
{
Store (0x00, Local0)
If (DHC4)
{
If (\C4WR)
{
If (LNot (\C4AC))
{
Or (Local0, 0x01, Local0)
}
}
}
Else
{
If (\_SB.PCI0.LPC.EC.AC._PSR ())
{
Or (Local0, 0x01, Local0)
}
}
If (\C4NA)
{
Or (Local0, 0x02, Local0)
}
If (LAnd (\CWAC, \CWAS))
{
Or (Local0, 0x04, Local0)
}
If (LAnd (\CWUE, \CWUS))
{
Or (Local0, 0x08, Local0)
}
And (Local0, Not (Arg0), Local0)
Return (Local0)
}
Method (MHQE, 0, NotSerialized)
{
Return (\C4WR)
}
Method (MHGE, 0, NotSerialized)
{
Store (0x01, DHC4)
If (LAnd (\C4WR, \C4AC))
{
Return (0x04)
}
Return (0x03)
}
Method (MHSE, 1, NotSerialized)
{
If (\C4WR)
{
Store (0x01, DHC4)
Store (\C4AC, Local0)
If (LEqual (Arg0, 0x03))
{
Store (0x00, \C4AC)
If (XOr (Local0, \C4AC))
{
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
Else
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
}
}
}
Else
{
If (LEqual (Arg0, 0x04))
{
Store (0x01, \C4AC)
If (XOr (Local0, \C4AC))
{
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
Else
{
If (LNot (CKC4 (0x00)))
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
}
}
}
}
}
}
Scope (\_SB.PCI0.LPC.EC.HKEY)
{
Method (TDSC, 1, NotSerialized)
{
Store (0x01, Local0)
While (Local0)
{
Store (\_SB.PCI0.LPC.EC.HANT, Local0)
}
Store (Arg0, \_SB.PCI0.LPC.EC.HANT)
If (LEqual (Arg0, 0x21))
{
\ATCC (0x00)
}
}
Method (TDSS, 1, NotSerialized)
{
\ATCC (Arg0)
}
Method (TDSG, 1, NotSerialized)
{
And (Arg0, 0xFF, Local0)
Store (Local0, \_SB.PCI0.LPC.EC.HDAA)
ShiftRight (Arg0, 0x08, Local0)
And (Local0, 0xFF, Local1)
Store (Local1, \_SB.PCI0.LPC.EC.HDAB)
ShiftRight (Arg0, 0x10, Local0)
And (Local0, 0xFF, Local1)
Store (Local1, \_SB.PCI0.LPC.EC.HDAC)
ShiftRight (Arg0, 0x18, Local0)
And (Local0, 0xFF, Local1)
Store (Local1, \_SB.PCI0.LPC.EC.HANA)
}
Method (TDGC, 0, NotSerialized)
{
Store (\_SB.PCI0.LPC.EC.HDDD, Local0)
Return (Local0)
}
Method (TDGS, 0, NotSerialized)
{
Store (\_SB.PCI0.LPC.EC.HAAA, Local0)
Return (Local0)
}
}
Field (ECOR, ByteAcc, Lock, Preserve)
{
Offset (0x54),
HSD0, 8,
HSD1, 8,
HSD2, 8
}
Field (ECOR, ByteAcc, Lock, Preserve)
{
Offset (0x56),
HSDL, 16
}
Field (ECOR, ByteAcc, Lock, Preserve)
{
Offset (0x56),
HSDB, 72,
HSDF, 16,
HSDC, 16
}
Mutex (I2CM, 0x07)
Method (CHKS, 0, NotSerialized)
{
Store (0x03E8, Local0)
While (HMPR)
{
Sleep (0x01)
Decrement (Local0)
If (LNot (Local0))
{
Return (0x8080)
}
}
If (HMDN)
{
If (HMST)
{
Return (Or (0x8000, HMST))
}
Else
{
Return (Zero)
}
}
Else
{
Return (0x8081)
}
}
Method (I2RT, 0, NotSerialized)
{
Store (0x02, HMAD)
Store (0x21, HMCM)
Store (0x0B, HMPR)
Return (CHKS ())
}
Method (I2NT, 1, NotSerialized)
{
Store (0x02, HMAD)
Store (0x22, HMCM)
Store (Arg0, HSD0)
Store (0x06, HMPR)
Return (CHKS ())
}
Method (TATR, 0, NotSerialized)
{
If (\H8DR)
{
Acquire (I2CM, 0xFFFF)
I2RT ()
Store (HSD0, Local0)
If (LEqual (Local0, 0x20))
{
\_SB.PCI0.LPC.TCSZ (HSD1, HSD2)
I2NT (Local0)
}
Else
{
If (LEqual (Local0, 0x21))
{
\_SB.PCI0.LPC.TCST (HSD1, HSD2)
I2NT (Local0)
}
Else
{
If (LEqual (Local0, 0x22))
{
Name (TSDC, Buffer (0x09)
{
" "
})
Store (HSDB, TSDC)
\_SB.PCI0.LPC.TCBS (HSD1, TSDC, HSDF, HSDC)
I2NT (Local0)
}
Else
{
If (LEqual (Local0, 0x23))
{
\_SB.PCI0.LPC.TSCL (HSD1, HSDL)
I2NT (Local0)
}
}
}
}
Release (I2CM)
}
}
Method (TATE, 0, NotSerialized)
{
Store (0x01, HETE)
}
Scope (\_SB.PCI0.LPC.EC.HKEY)
{
Name (INDV, 0x00)
Method (MHQI, 0, NotSerialized)
{
If (And (\IPMS, 0x01))
{
Or (INDV, 0x01, INDV)
}
If (And (\IPMS, 0x02))
{
Or (INDV, 0x02, INDV)
}
If (And (\IPMS, 0x04))
{
Or (INDV, 0x0100, INDV)
}
If (And (\IPMS, 0x08))
{
Or (INDV, 0x0200, INDV)
}
Return (INDV)
}
Method (MHGI, 1, NotSerialized)
{
Name (RETB, Buffer (0x10) {})
CreateByteField (RETB, 0x00, MHGS)
ShiftLeft (0x01, Arg0, Local0)
If (And (INDV, Local0))
{
If (LEqual (Arg0, 0x00))
{
CreateField (RETB, 0x08, 0x78, BRBU)
Store (\IPMB, BRBU)
Store (0x10, MHGS)
}
Else
{
If (LEqual (Arg0, 0x01))
{
CreateField (RETB, 0x08, 0x18, RRBU)
Store (\IPMR, RRBU)
Store (0x04, MHGS)
}
Else
{
If (LEqual (Arg0, 0x08))
{
CreateField (RETB, 0x10, 0x18, ODBU)
CreateByteField (RETB, 0x01, MHGZ)
Store (\IPMO, ODBU)
If (LAnd (LEqual (^^BSTS, 0x00), LEqual (^^BDEV, 0x0B)))
{
Or (0x01, MHGZ, MHGZ)
Or (0x02, MHGZ, MHGZ)
}
Store (0x05, MHGS)
}
Else
{
If (LEqual (Arg0, 0x09))
{
CreateField (RETB, 0x10, 0x08, AUBU)
Store (\IPMA, AUBU)
Store (0x01, Index (RETB, 0x01))
Store (0x03, MHGS)
}
}
}
}
}
Return (RETB)
}
Method (MHSI, 2, NotSerialized)
{
ShiftLeft (0x01, Arg0, Local0)
If (And (INDV, Local0))
{
If (LEqual (Arg0, 0x08))
{
If (Arg1)
{
If (And (\_SB.PCI0.LPC.EC.SFLG, 0x0400))
{
If (\H8DR)
{
Store (^^HPBU, Local1)
}
Else
{
And (\RBEC (0x47), 0x01, Local1)
}
If (LNot (Local1))
{
Store (^^BGID (0x00), ^^BDEV)
^^NBIN (Local1)
}
}
}
}
}
}
}
}
}
Name (_ADR, 0x00) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
Name (LRRT, Package (0x16)
{
Package (0x04)
{
0x0001FFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x0002FFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x0003FFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x0003FFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0x0003FFFF,
0x02,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0x0003FFFF,
0x03,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0x0019FFFF,
0x00,
\_SB.LNKE,
0x00
},
Package (0x04)
{
0x001AFFFF,
0x00,
\_SB.LNKE,
0x00
},
Package (0x04)
{
0x001AFFFF,
0x01,
\_SB.LNKF,
0x00
},
Package (0x04)
{
0x001AFFFF,
0x02,
\_SB.LNKG,
0x00
},
Package (0x04)
{
0x001BFFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0x001CFFFF,
0x00,
\_SB.LNKE,
0x00
},
Package (0x04)
{
0x001CFFFF,
0x01,
\_SB.LNKF,
0x00
},
Package (0x04)
{
0x001CFFFF,
0x02,
\_SB.LNKG,
0x00
},
Package (0x04)
{
0x001CFFFF,
0x03,
\_SB.LNKH,
0x00
},
Package (0x04)
{
0x001DFFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x001DFFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0x001DFFFF,
0x02,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0x001DFFFF,
0x03,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0x001FFFFF,
0x00,
\_SB.LNKH,
0x00
},
Package (0x04)
{
0x001FFFFF,
0x02,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x001FFFFF,
0x01,
\_SB.LNKA,
0x00
}
})
Name (ARRT, Package (0x16)
{
Package (0x04)
{
0x0001FFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0x0002FFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0x0003FFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0x0003FFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0x0003FFFF,
0x02,
0x00,
0x12
},
Package (0x04)
{
0x0003FFFF,
0x03,
0x00,
0x13
},
Package (0x04)
{
0x0019FFFF,
0x00,
0x00,
0x14
},
Package (0x04)
{
0x001AFFFF,
0x00,
0x00,
0x14
},
Package (0x04)
{
0x001AFFFF,
0x01,
0x00,
0x15
},
Package (0x04)
{
0x001AFFFF,
0x02,
0x00,
0x16
},
Package (0x04)
{
0x001BFFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0x001CFFFF,
0x00,
0x00,
0x14
},
Package (0x04)
{
0x001CFFFF,
0x01,
0x00,
0x15
},
Package (0x04)
{
0x001CFFFF,
0x02,
0x00,
0x16
},
Package (0x04)
{
0x001CFFFF,
0x03,
0x00,
0x17
},
Package (0x04)
{
0x001DFFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0x001DFFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0x001DFFFF,
0x02,
0x00,
0x12
},
Package (0x04)
{
0x001DFFFF,
0x03,
0x00,
0x13
},
Package (0x04)
{
0x001FFFFF,
0x00,
0x00,
0x17
},
Package (0x04)
{
0x001FFFFF,
0x02,
0x00,
0x10
},
Package (0x04)
{
0x001FFFFF,
0x01,
0x00,
0x10
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (ARRT)
}
Else
{
Return (LRRT)
}
}
Name (_HID, EisaId ("PNP0A08")) // _HID: Hardware ID
Name (_CID, EisaId ("PNP0A03")) // _CID: Compatible ID
Name (_BBN, 0x00) // _BBN: BIOS Bus Number
OperationRegion (MHCS, PCI_Config, 0x00, 0x0100)
Field (MHCS, DWordAcc, NoLock, Preserve)
{
Offset (0x90),
PAM0, 8,
PAM1, 8,
PAM2, 8,
PAM3, 8,
PAM4, 8,
PAM5, 8,
PAM6, 8,
Offset (0xB0),
, 4,
TOUD, 12
}
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings
{
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000, // Granularity
0x0000, // Range Minimum
0x00FF, // Range Maximum
0x0000, // Translation Offset
0x0100, // Length
,, )
IO (Decode16,
0x0CF8, // Range Minimum
0x0CF8, // Range Maximum
0x01, // Alignment
0x08, // Length
)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0000, // Range Minimum
0x0CF7, // Range Maximum
0x0000, // Translation Offset
0x0CF8, // Length
,, , TypeStatic)
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000, // Granularity
0x0D00, // Range Minimum
0xFFFF, // Range Maximum
0x0000, // Translation Offset
0xF300, // Length
,, , TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000A0000, // Range Minimum
0x000BFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00020000, // Length
,, , AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C0000, // Range Minimum
0x000C3FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y21, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C4000, // Range Minimum
0x000C7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y22, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000C8000, // Range Minimum
0x000CBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y23, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000CC000, // Range Minimum
0x000CFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y24, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D0000, // Range Minimum
0x000D3FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y25, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D4000, // Range Minimum
0x000D7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y26, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000D8000, // Range Minimum
0x000DBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y27, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000DC000, // Range Minimum
0x000DFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y28, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E0000, // Range Minimum
0x000E3FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y29, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E4000, // Range Minimum
0x000E7FFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y2A, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000E8000, // Range Minimum
0x000EBFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y2B, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x000EC000, // Range Minimum
0x000EFFFF, // Range Maximum
0x00000000, // Translation Offset
0x00004000, // Length
,, _Y2C, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0x00100000, // Range Minimum
0xFEBFFFFF, // Range Maximum
0x00000000, // Translation Offset
0xFEB00000, // Length
,, _Y2D, AddressRangeMemory, TypeStatic)
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000, // Granularity
0xFED40000, // Range Minimum
0xFED4BFFF, // Range Maximum
0x00000000, // Translation Offset
0x0000C000, // Length
,, _Y2E, AddressRangeMemory, TypeStatic)
})
CreateDWordField (_CRS, \_SB.PCI0._Y21._LEN, C0LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y22._LEN, C4LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y23._LEN, C8LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y24._LEN, CCLN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y25._LEN, D0LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y26._LEN, D4LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y27._LEN, D8LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y28._LEN, DCLN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y29._LEN, E0LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y2A._LEN, E4LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y2B._LEN, E8LN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y2C._LEN, ECLN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y2D._MIN, XXMN) // _MIN: Minimum Base Address
CreateDWordField (_CRS, \_SB.PCI0._Y2D._MAX, XXMX) // _MAX: Maximum Base Address
CreateDWordField (_CRS, \_SB.PCI0._Y2D._LEN, XXLN) // _LEN: Length
CreateDWordField (_CRS, \_SB.PCI0._Y2E._MIN, F4MN) // _MIN: Minimum Base Address
CreateDWordField (_CRS, \_SB.PCI0._Y2E._MAX, F4MX) // _MAX: Maximum Base Address
CreateDWordField (_CRS, \_SB.PCI0._Y2E._LEN, F4LN) // _LEN: Length
Method (_INI, 0, Serialized) // _INI: Initialize
{
If (LNot (\OSIF))
{
\_SB._INI ()
}
ShiftLeft (TOUD, 0x14, Local0)
Store (Local0, \MEMX)
Store (Local0, XXMN)
Add (Subtract (XXMX, XXMN), 0x01, XXLN)
If (LNotEqual (And (\TPMP, 0x01), 0x01))
{
Store (0x00, F4LN)
}
If (And (PAM1, 0x03))
{
Store (0x00, C0LN)
}
If (And (PAM1, 0x30))
{
Store (0x00, C4LN)
}
If (And (PAM2, 0x03))
{
Store (0x00, C8LN)
}
If (And (PAM2, 0x30))
{
Store (0x00, CCLN)
}
If (And (PAM3, 0x03))
{
Store (0x00, D0LN)
}
If (And (PAM3, 0x30))
{
Store (0x00, D4LN)
}
If (And (PAM4, 0x03))
{
Store (0x00, D8LN)
}
If (And (PAM4, 0x30))
{
Store (0x00, DCLN)
}
If (And (PAM5, 0x03))
{
Store (0x00, E0LN)
}
If (And (PAM5, 0x30))
{
Store (0x00, E4LN)
}
If (And (PAM6, 0x03))
{
Store (0x00, E8LN)
}
If (And (PAM6, 0x30))
{
Store (0x00, ECLN)
}
}
Name (SUPP, 0x00)
Name (CTRL, 0x00)
Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities
{
CreateDWordField (Arg3, 0x00, CDW1)
CreateDWordField (Arg3, 0x04, CDW2)
CreateDWordField (Arg3, 0x08, CDW3)
CreateDWordField (Arg0, 0x00, IID0)
CreateDWordField (Arg0, 0x04, IID1)
CreateDWordField (Arg0, 0x08, IID2)
CreateDWordField (Arg0, 0x0C, IID3)
Name (UID0, Buffer (0x10)
{
/* 0000 */ 0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
/* 0008 */ 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66
})
CreateDWordField (UID0, 0x00, EID0)
CreateDWordField (UID0, 0x04, EID1)
CreateDWordField (UID0, 0x08, EID2)
CreateDWordField (UID0, 0x0C, EID3)
If (LAnd (LAnd (LEqual (IID0, EID0), LEqual (IID1, EID1)), LAnd (
LEqual (IID2, EID2), LEqual (IID3, EID3))))
{
Store (CDW2, SUPP)
Store (CDW3, CTRL)
And (CTRL, 0x1D, CTRL)
If (Not (And (CDW1, 0x01)))
{
If (And (CTRL, 0x01))
{
If (LNot (\VIGD))
{
Store (0x00, \_SB.PCI0.AGP.HPGP)
Store (0x00, \_SB.PCI0.AGP.GMGP)
}
Store (0x00, \_SB.PCI0.EXP3.HPCE)
Store (0x01, \_SB.PCI0.EXP3.HPCS)
Store (0x01, \_SB.PCI0.EXP3.ABP)
Store (0x01, \_SB.PCI0.EXP3.PDS)
Store (0x01, \NHPS)
}
If (And (CTRL, 0x04))
{
If (LNot (\VIGD))
{
Store (0x00, \_SB.PCI0.AGP.PMGP)
Store (0x00, \_SB.PCI0.AGP.GMGP)
}
Store (0x00, \_SB.PCI0.EXP3.PMCE)
Store (0x01, \_SB.PCI0.EXP3.PMCS)
Store (0x00, \_SB.PCI0.LPC.EXPE)
Store (0x01, \NPME)
}
}
If (LNotEqual (Arg1, 0x01))
{
Or (CDW1, 0x0A, CDW1)
}
If (LNotEqual (CDW3, CTRL))
{
Or (CDW1, 0x10, CDW1)
}
Store (CTRL, CDW3)
}
Else
{
Or (CDW1, 0x06, CDW1)
}
Return (Arg3)
}
Mutex (MDGS, 0x07)
Name (VDEE, 0x01)
Name (VDDA, Buffer (0x02) {})
CreateBitField (VDDA, 0x00, VUPC)
CreateBitField (VDDA, 0x01, VQDL)
CreateBitField (VDDA, 0x02, VQDC)
CreateBitField (VDDA, 0x03, VQDT)
CreateBitField (VDDA, 0x04, VQDD)
CreateBitField (VDDA, 0x05, VSDL)
CreateBitField (VDDA, 0x06, VSDC)
CreateBitField (VDDA, 0x07, VSDT)
CreateBitField (VDDA, 0x08, VSDD)
CreateBitField (VDDA, 0x0A, MSWT)
CreateBitField (VDDA, 0x0B, VWST)
Name (VDPU, 0x00)
Device (VID)
{
Name (_ADR, 0x00020000) // _ADR: Address
Name (RID, 0x00)
OperationRegion (VPCG, PCI_Config, 0x00, 0x0100)
Field (VPCG, DWordAcc, NoLock, Preserve)
{
Offset (0xD4),
VPWR, 8
}
Name (_S3D, 0x03) // _S3D: S3 Device State
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
\VUPS (0x02)
Store (\VCDL, VQDL)
Store (\VCDC, VQDC)
Store (\VCDT, VQDT)
Store (\VCDD, VQDD)
}
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
Noop
}
Method (_PS1, 0, NotSerialized) // _PS1: Power State 1
{
Noop
}
Method (_PS2, 0, NotSerialized) // _PS2: Power State 2
{
Noop
}
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
Noop
}
Method (VSWT, 0, NotSerialized)
{
If (\WVIS)
{
Store (\VEVT (0x07), Local0)
}
Else
{
Store (\VEVT (0x05), Local0)
}
And (0x0F, Local0, Local1)
If (DSFS)
{
If (LEqual (Local1, 0x03))
{
Store (0x01, Local1)
}
}
If (Local1)
{
ASWT (Local1, 0x01)
GHDS (0x00)
}
}
Method (VLOC, 1, NotSerialized)
{
If (LEqual (Arg0, \_SB.LID._LID ()))
{
\VSLD (Arg0)
If (LEqual (VPWR, 0x00))
{
If (Arg0)
{
Store (\VEVT (0x01), Local0)
}
Else
{
Store (\VEVT (0x02), Local0)
If (EXTD)
{
Store (0x00, Local0)
}
}
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x00)
Store (Arg0, CLID)
GNOT (0x02, 0x00)
}
}
}
}
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching
{
And (Arg0, 0x03, Arg0)
If (LEqual (Arg0, 0x02))
{
Store (0x14, Local0)
While (Local0)
{
Decrement (Local0)
Acquire (MDGS, 0xFFFF)
If (LEqual (0x00, MSWT))
{
Store (0x01, MSWT)
Store (0x00, Local0)
Store (Arg0, VDEE)
}
Release (MDGS)
Sleep (0xC8)
}
}
Else
{
Acquire (MDGS, 0xFFFF)
If (LEqual (VDEE, 0x02))
{
Store (0x00, MSWT)
}
If (LGreater (Arg0, 0x02))
{
Store (0x01, VDEE)
}
Else
{
Store (Arg0, VDEE)
}
Release (MDGS)
}
}
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices
{
Return (Package (0x03)
{
0x0100,
0x0300,
0x0400
})
}
Method (ASWT, 2, NotSerialized)
{
If (LEqual (0x01, VDEE))
{
And (0x01, Arg1, Local1)
\VSDS (Arg0, Local1)
}
Else
{
Store (0x14, Local0)
While (Local0)
{
Decrement (Local0)
Acquire (MDGS, 0xFFFF)
If (LEqual (0x00, MSWT))
{
Store (0x00, Local0)
If (And (0x01, Arg1))
{
Store (0x01, VUPC)
}
Else
{
Store (0x00, VUPC)
}
If (And (0x01, Arg0))
{
Store (0x01, VQDL)
}
Else
{
Store (0x00, VQDL)
}
If (And (0x02, Arg0))
{
Store (0x01, VQDC)
}
Else
{
Store (0x00, VQDC)
}
If (And (0x08, Arg0))
{
Store (0x01, VQDD)
}
Else
{
Store (0x00, VQDD)
}
}
Release (MDGS)
Sleep (0xC8)
}
}
}
Method (VDSW, 1, NotSerialized)
{
If (LEqual (VPWR, 0x00))
{
If (Arg0)
{
Store (0x00, VDPU)
Store (\VEVT (0x03), Local0)
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x00)
GDCK (Arg0)
}
}
Else
{
Store (0x01, VDPU)
Store (\VEVT (0x04), Local0)
ASWT (0x01, 0x00)
GDCK (Arg0)
}
}
}
Method (VDSP, 0, NotSerialized)
{
If (LEqual (VPWR, 0x00))
{
If (LEqual (VDPU, 0x01))
{
Store (0x00, VDPU)
If (\_SB.LID._LID ())
{
ASWT (0x01, 0x00)
GLID (0x01)
}
}
}
}
Method (VSPD, 0, NotSerialized)
{
Store (\VEVT (0x06), Local0)
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x01)
GHDS (0x00)
}
}
Device (LCD0)
{
Name (_ADR, 0x0400) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x00)
If (\VCDL)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDL)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDL)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Device (CRT0)
{
Name (_ADR, 0x0100) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x01)
If (\VCSS)
{
If (\VCDC)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Else
{
If (\VCDC)
{
Return (0x0F)
}
Else
{
Return (0x0D)
}
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDC)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDC)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Device (DVI0)
{
Name (_ADR, 0x0300) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x00)
If (\VCDD)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDD)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDD)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Method (DSWT, 1, NotSerialized)
{
If (VSDL)
{
Store (0x01, Local0)
}
Else
{
Store (0x00, Local0)
}
If (VSDC)
{
Or (0x02, Local0, Local0)
}
If (VSDD)
{
Or (0x08, Local0, Local0)
}
If (Local0)
{
If (VUPC)
{
\VSDS (Local0, Arg0)
}
}
Else
{
Noop
}
}
OperationRegion (IGDP, PCI_Config, 0x40, 0xC0)
Field (IGDP, AnyAcc, NoLock, Preserve)
{
Offset (0x12),
, 1,
GIVD, 1,
, 2,
GUMA, 3,
Offset (0x14),
, 4,
GMFN, 1,
Offset (0x18),
Offset (0xA4),
ASLE, 8,
Offset (0xA8),
GSSE, 1,
GSSB, 14,
GSES, 1,
Offset (0xB0),
Offset (0xB1),
CDVL, 5,
Offset (0xB2),
Offset (0xB5),
LBPC, 8,
Offset (0xBC),
ASLS, 32
}
OperationRegion (IGDM, SystemMemory, \ASLB, 0x2000)
Field (IGDM, AnyAcc, NoLock, Preserve)
{
SIGN, 128,
SIZE, 32,
OVER, 32,
SVER, 256,
VVER, 128,
GVER, 128,
MBOX, 32,
Offset (0x100),
DRDY, 32,
CSTS, 32,
CEVT, 32,
Offset (0x120),
DIDL, 32,
DDL2, 32,
DDL3, 32,
DDL4, 32,
DDL5, 32,
DDL6, 32,
DDL7, 32,
DDL8, 32,
CPDL, 32,
CPL2, 32,
CPL3, 32,
CPL4, 32,
CPL5, 32,
CPL6, 32,
CPL7, 32,
CPL8, 32,
CADL, 32,
CAL2, 32,
CAL3, 32,
CAL4, 32,
CAL5, 32,
CAL6, 32,
CAL7, 32,
CAL8, 32,
NADL, 32,
NDL2, 32,
NDL3, 32,
NDL4, 32,
NDL5, 32,
NDL6, 32,
NDL7, 32,
NDL8, 32,
ASLP, 32,
TIDX, 32,
CHPD, 32,
CLID, 32,
CDCK, 32,
SXSW, 32,
EVTS, 32,
CNOT, 32,
NRDY, 32,
Offset (0x200),
SCIE, 1,
GEFC, 4,
GXFC, 3,
GESF, 8,
Offset (0x204),
PARM, 32,
DSLP, 32,
Offset (0x300),
ARDY, 32,
ASLC, 32,
TCHE, 32,
ALSI, 32,
BCLP, 32,
PFIT, 32,
CBLV, 32,
BCLM, 320,
CPFM, 32,
EPFM, 32,
Offset (0x400),
GVD1, 57344
}
Name (DBTB, Package (0x15)
{
0x00,
0x07,
0x38,
0x01C0,
0x0E00,
0x3F,
0x01C7,
0x0E07,
0x01F8,
0x0E38,
0x0FC0,
0x00,
0x00,
0x00,
0x00,
0x00,
0x7000,
0x7007,
0x7038,
0x71C0,
0x7E00
})
Name (DBTC, Package (0x15)
{
0x00,
0x02,
0x01,
0x08,
0x00,
0x03,
0x0A,
0x00,
0x09,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x04,
0x06,
0x05,
0x0C,
0x00
})
Name (CDCT, Package (0x03)
{
Package (0x03)
{
0xC8,
0x0140,
0x0190
},
Package (0x03)
{
0xC8,
0x014D,
0x0190
},
Package (0x03)
{
0xDE,
0x014D,
0x017D
}
})
Name (SUCC, 0x01)
Name (NVLD, 0x02)
Name (CRIT, 0x04)
Name (NCRT, 0x06)
Method (OPRN, 0, Serialized)
{
If (LEqual (GEFC, 0x04))
{
Store (GBDA (), GXFC)
}
If (LEqual (GEFC, 0x06))
{
Store (SBCB (), GXFC)
}
Store (0x00, GEFC)
Store (0x01, \_SB.PCI0.LPC.SCIS)
Store (0x00, GSSE)
Store (0x00, SCIE)
Return (Zero)
}
Method (GBDA, 0, Serialized)
{
If (LEqual (GESF, 0x00))
{
Store (0x0279, PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x01))
{
Store (0x00010672, PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x04))
{
And (PARM, 0xEFFF0000, PARM)
And (PARM, ShiftLeft (DerefOf (Index (DBTB, IBTT)), 0x10),
PARM)
Or (IBTT, PARM, PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x05))
{
If (\_SB.LID._LID ())
{
Store (0x01, LIDS)
}
Else
{
Store (0x00, LIDS)
}
Store (IPSC, PARM)
Add (PARM, 0x01, PARM)
Add (PARM, 0x0300, PARM)
Add (PARM, 0x00010000, PARM)
Or (PARM, ShiftLeft (LIDS, 0x10), PARM)
Or (PARM, ShiftLeft (IBIA, 0x14), PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x06))
{
Store (ITVF, PARM)
Or (PARM, ShiftLeft (ITVM, 0x04), PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x07))
{
Store (GIVD, PARM)
XOr (PARM, 0x01, PARM)
Or (PARM, ShiftLeft (GMFN, 0x01), PARM)
Or (PARM, ShiftLeft (0x02, 0x0B), PARM)
If (IDMM)
{
Or (PARM, ShiftLeft (IDMS, 0x11), PARM)
}
Else
{
Or (PARM, ShiftLeft (IDMS, 0x0D), PARM)
}
Or (ShiftLeft (DerefOf (Index (DerefOf (Index (CDCT, HVCO)), Subtract (
CDVL, 0x01))), 0x15), PARM, PARM)
Store (0x01, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x0A))
{
Store (0x00, PARM)
If (ISSC)
{
Or (PARM, ISSC, PARM)
Or (PARM, 0x00640000, PARM)
}
Store (0x00, GESF)
Return (SUCC)
}
Store (Zero, GESF)
Return (CRIT)
}
Name (DSFS, 0x00)
Name (EXTD, 0x00)
Method (SBCB, 0, Serialized)
{
If (LEqual (GESF, 0x00))
{
Store (0x8339, PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x01))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x03))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x04))
{
And (PARM, 0xFFFF, PARM)
If (LGreater (PARM, 0x13))
{
Store (0x00, DSFS)
}
Else
{
Store (0x01, DSFS)
}
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x05))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x06))
{
Store (And (PARM, 0x0F), ITVF)
Store (ShiftRight (And (PARM, 0xF0), 0x04), ITVM)
\UCMS (0x19)
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x07))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x08))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x09))
{
And (PARM, 0x80000000, EXTD)
And (PARM, 0xFF, Local0)
If (LLessEqual (Local0, 0x14))
{
Store (DerefOf (Index (DBTC, Local0)), IBTT)
}
Else
{
Store (0x00, IBTT)
}
If (IBTT)
{
\UCMS (0x17)
}
And (PARM, 0xFF, IBTT)
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x0A))
{
Store (Subtract (And (PARM, 0x03), 0x01), IPSC)
\UCMS (0x1A)
If (And (ShiftRight (PARM, 0x08), 0xFF))
{
And (ShiftRight (PARM, 0x08), 0xFF, IPAT)
Decrement (IPAT)
}
And (ShiftRight (PARM, 0x14), 0x07, IBIA)
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x0B))
{
And (ShiftRight (PARM, 0x01), 0x01, IF1E)
If (And (PARM, ShiftLeft (0x0F, 0x0D)))
{
And (ShiftRight (PARM, 0x0D), 0x0F, IDMS)
Store (0x00, IDMM)
}
Else
{
And (ShiftRight (PARM, 0x11), 0x0F, IDMS)
Store (0x01, IDMM)
}
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x10))
{
And (PARM, 0x01, PARM)
XOr (PARM, 0x01, PARM)
Store (PARM, DSFS)
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x11))
{
Store (ShiftLeft (LIDS, 0x08), PARM)
Add (PARM, 0x0100, PARM)
Store (Zero, GESF)
Return (SUCC)
}
If (LEqual (GESF, 0x12))
{
If (And (PARM, 0x01))
{
If (LEqual (ShiftRight (PARM, 0x01), 0x01))
{
Store (0x01, ISSC)
}
Else
{
Store (Zero, GESF)
Return (CRIT)
}
}
Else
{
Store (0x00, ISSC)
}
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
If (LEqual (GESF, 0x13))
{
Store (Zero, GESF)
Store (Zero, PARM)
Return (SUCC)
}
Store (Zero, GESF)
Return (SUCC)
}
Method (PDRD, 0, NotSerialized)
{
If (LNot (DRDY))
{
Sleep (ASLP)
}
Return (LNot (DRDY))
}
Method (PSTS, 0, NotSerialized)
{
If (LGreater (CSTS, 0x02))
{
Sleep (ASLP)
}
Return (LEqual (CSTS, 0x03))
}
Method (GNOT, 2, NotSerialized)
{
If (PDRD ())
{
Return (0x01)
}
If (PSTS ())
{
Return (0x01)
}
Store (Arg0, CEVT)
Store (0x03, CSTS)
If (LAnd (LEqual (CHPD, 0x00), LEqual (Arg1, 0x00)))
{
If (LNotEqual (Arg0, 0x01))
{
If (LAnd (\WXPF, LNot (\WVIS)))
{
Notify (\_SB.PCI0, Arg1)
}
Else
{
Notify (\_SB.PCI0.VID, Arg1)
}
}
}
Notify (\_SB.PCI0.VID, 0x80)
If (LNot (PSTS ()))
{
Store (0x00, CEVT)
}
Return (0x00)
}
Method (GHDS, 1, NotSerialized)
{
Store (Arg0, TIDX)
Return (GNOT (0x01, 0x00))
}
Method (GLID, 1, NotSerialized)
{
Store (Arg0, CLID)
Return (GNOT (0x02, 0x00))
}
Method (GLIS, 1, NotSerialized)
{
Store (Arg0, CLID)
Return (0x00)
}
Method (GDCK, 1, NotSerialized)
{
Store (Arg0, CDCK)
Return (GNOT (0x04, 0x80))
}
Method (GDCS, 1, NotSerialized)
{
Store (Arg0, CDCK)
}
Method (PARD, 0, NotSerialized)
{
If (LNot (ARDY))
{
Sleep (ASLP)
}
Return (LNot (ARDY))
}
Method (AINT, 2, NotSerialized)
{
If (LNot (And (TCHE, ShiftLeft (0x01, Arg0))))
{
Return (0x01)
}
If (PARD ())
{
Return (0x01)
}
If (LEqual (Arg0, 0x02))
{
XOr (PFIT, 0x07, PFIT)
Or (PFIT, 0x80000000, PFIT)
Store (0x04, ASLC)
}
Else
{
If (LEqual (Arg0, 0x01))
{
Store (Arg1, BCLP)
Or (BCLP, 0x80000000, BCLP)
Store (0x02, ASLC)
}
Else
{
If (LEqual (Arg0, 0x00))
{
Store (Arg1, ALSI)
Store (0x01, ASLC)
}
Else
{
Return (0x01)
}
}
}
Store (0x00, LBPC)
Return (0x00)
}
}
Device (AGP)
{
Name (_ADR, 0x00010000) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
Name (LART, Package (0x02)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKB,
0x00
}
})
Name (AART, Package (0x02)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (AART)
}
Else
{
Return (LART)
}
}
Mutex (MDGS, 0x07)
Name (VDEE, 0x01)
Name (VDDA, Buffer (0x02) {})
CreateBitField (VDDA, 0x00, VUPC)
CreateBitField (VDDA, 0x01, VQDL)
CreateBitField (VDDA, 0x02, VQDC)
CreateBitField (VDDA, 0x03, VQDT)
CreateBitField (VDDA, 0x04, VQDD)
CreateBitField (VDDA, 0x05, VSDL)
CreateBitField (VDDA, 0x06, VSDC)
CreateBitField (VDDA, 0x07, VSDT)
CreateBitField (VDDA, 0x08, VSDD)
CreateBitField (VDDA, 0x0A, MSWT)
CreateBitField (VDDA, 0x0B, VWST)
Device (VID)
{
Name (_ADR, 0x00) // _ADR: Address
OperationRegion (VPCG, PCI_Config, 0x00, 0x0100)
Field (VPCG, DWordAcc, NoLock, Preserve)
{
Offset (0x64),
VPWR, 8
}
Name (_S3D, 0x03) // _S3D: S3 Device State
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
\VUPS (0x02)
Store (\VCDL, VQDL)
Store (\VCDC, VQDC)
Store (\VCDT, VQDT)
Store (\VCDD, VQDD)
}
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0
{
Noop
}
Method (_PS1, 0, NotSerialized) // _PS1: Power State 1
{
Noop
}
Method (_PS2, 0, NotSerialized) // _PS2: Power State 2
{
Noop
}
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3
{
Noop
}
Method (VSWT, 0, NotSerialized)
{
If (\WVIS)
{
Store (\VEVT (0x07), Local0)
}
Else
{
Store (\VEVT (0x05), Local0)
}
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x01)
}
}
Method (VLOC, 1, NotSerialized)
{
If (LEqual (Arg0, \_SB.LID._LID ()))
{
\VSLD (Arg0)
If (LEqual (VPWR, 0x00))
{
If (Arg0)
{
Store (\VEVT (0x01), Local0)
}
Else
{
Store (\VEVT (0x02), Local0)
}
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x00)
}
}
}
}
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching
{
If (LEqual (Arg0, 0x02))
{
Store (0x14, Local0)
While (Local0)
{
Decrement (Local0)
Acquire (MDGS, 0xFFFF)
If (LEqual (0x00, MSWT))
{
Store (0x01, MSWT)
Store (0x00, Local0)
Store (Arg0, VDEE)
}
Release (MDGS)
Sleep (0xC8)
}
}
Else
{
Acquire (MDGS, 0xFFFF)
If (LEqual (VDEE, 0x02))
{
Store (0x00, MSWT)
}
If (LGreater (Arg0, 0x02))
{
Store (0x01, VDEE)
}
Else
{
Store (Arg0, VDEE)
}
Release (MDGS)
}
}
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices
{
Return (Package (0x03)
{
0x0100,
0x0210,
0x0110
})
}
Method (ASWT, 2, NotSerialized)
{
If (LEqual (0x01, VDEE))
{
And (0x01, Arg1, Local1)
\VSDS (Arg0, Local1)
}
Else
{
Store (0x14, Local0)
While (Local0)
{
Decrement (Local0)
Acquire (MDGS, 0xFFFF)
If (LEqual (0x00, MSWT))
{
Store (0x00, Local0)
If (And (0x01, Arg1))
{
Store (0x01, VUPC)
}
Else
{
Store (0x00, VUPC)
}
If (And (0x01, Arg0))
{
Store (0x01, VQDL)
}
Else
{
Store (0x00, VQDL)
}
If (And (0x02, Arg0))
{
Store (0x01, VQDC)
}
Else
{
Store (0x00, VQDC)
}
If (And (0x08, Arg0))
{
Store (0x01, VQDD)
}
Else
{
Store (0x00, VQDD)
}
}
Release (MDGS)
Sleep (0xC8)
}
If (And (0x02, Arg1))
{
Notify (VID, 0x81)
}
Else
{
Notify (VID, 0x80)
}
}
}
Method (VDSW, 1, NotSerialized)
{
If (LEqual (VPWR, 0x00))
{
If (Arg0)
{
Store (\VEVT (0x03), Local0)
}
Else
{
Store (\VEVT (0x04), Local0)
}
And (0x0F, Local0, Local1)
If (Local1)
{
ASWT (Local1, 0x00)
}
}
}
Device (LCD0)
{
Name (_ADR, 0x0110) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x00)
If (\VCDL)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Method (_DDC, 1, NotSerialized) // _DDC: Display Data Current
{
\VDDC ()
If (LEqual (Arg0, 0x01))
{
Return (\DDC1)
}
Else
{
If (LEqual (Arg0, 0x02))
{
Return (\DDC2)
}
Else
{
Return (0x00)
}
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDL)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDL)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Device (CRT0)
{
Name (_ADR, 0x0100) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x01)
If (\VCSS)
{
If (\VCDC)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Else
{
If (\VCDC)
{
Return (0x0F)
}
Else
{
Return (0x0D)
}
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDC)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDC)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Device (DVI0)
{
Name (_ADR, 0x0210) // _ADR: Address
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status
{
\VUPS (0x00)
If (\VCDD)
{
Return (0x1F)
}
Else
{
Return (0x1D)
}
}
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State
{
Return (VQDD)
}
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State
{
And (Arg0, 0x01, VSDD)
If (And (Arg0, 0x80000000))
{
If (And (Arg0, 0x40000000))
{
DSWT (0x02)
}
Else
{
DSWT (0x01)
}
}
}
}
Method (DSWT, 1, NotSerialized)
{
If (VSDL)
{
Store (0x01, Local0)
}
Else
{
Store (0x00, Local0)
}
If (VSDC)
{
Or (0x02, Local0, Local0)
}
If (VSDD)
{
Or (0x08, Local0, Local0)
}
If (Local0)
{
If (VUPC)
{
\VSDS (Local0, Arg0)
}
}
Else
{
Noop
}
}
}
OperationRegion (PEGC, PCI_Config, 0x00, 0x0100)
Field (PEGC, DWordAcc, NoLock, Preserve)
{
Offset (0xEC),
GMGP, 1,
HPGP, 1,
PMGP, 1
}
}
Device (IGBE)
{
Name (_ADR, 0x00190000) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x0D,
0x04
})
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
ABWA (0x00)
}
Method (ABWA, 1, NotSerialized)
{
Store (\ACBS (Arg0), Local0)
}
}
Device (EXP0)
{
Name (_ADR, 0x001C0000) // _ADR: Address
Name (RID, 0x00)
OperationRegion (P0CS, PCI_Config, 0x00, 0x0100)
Field (P0CS, DWordAcc, NoLock, Preserve)
{
Offset (0x60),
RID0, 16,
PSP0, 1,
PPP0, 1
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x09,
0x04
})
Name (LPRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKD,
0x00
}
})
Name (APRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x12
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x13
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
}
Device (EXP1)
{
Name (_ADR, 0x001C0001) // _ADR: Address
Name (RID, 0x00)
OperationRegion (P1CS, PCI_Config, 0x00, 0x0100)
Field (P1CS, DWordAcc, NoLock, Preserve)
{
Offset (0x60),
RID1, 16,
PSP1, 1,
PPP1, 1
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x09,
0x04
})
Name (LPRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKA,
0x00
}
})
Name (APRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x11
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x12
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x13
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x10
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
}
Device (EXP2)
{
Name (_ADR, 0x001C0002) // _ADR: Address
Name (RID, 0x00)
OperationRegion (P2CS, PCI_Config, 0x00, 0x0100)
Field (P2CS, DWordAcc, NoLock, Preserve)
{
Offset (0x60),
RID2, 16,
PSP2, 1,
PPP2, 1
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x09,
0x04
})
Name (LPRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKB,
0x00
}
})
Name (APRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x12
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x13
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x11
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
}
Device (EXP3)
{
Name (_ADR, 0x001C0003) // _ADR: Address
Name (RID, 0x00)
Name (XCPF, 0x00)
OperationRegion (P3CS, PCI_Config, 0x00, 0x0100)
Field (P3CS, DWordAcc, NoLock, Preserve)
{
Offset (0x5A),
ABP, 1,
, 2,
PDC, 1,
, 2,
PDS, 1,
Offset (0x5B),
Offset (0x60),
RID3, 16,
PSP3, 1,
PPP3, 1,
Offset (0xDB),
, 6,
HPCE, 1,
PMCE, 1,
Offset (0xDF),
, 6,
HPCS, 1,
PMCS, 1
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x09,
0x04
})
Name (LPRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKC,
0x00
}
})
Name (APRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x13
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x11
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x12
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
Device (EXUP)
{
Name (_ADR, 0x00) // _ADR: Address
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status
{
Return (0x01)
}
}
}
Device (EXP4)
{
Name (_ADR, 0x001C0004) // _ADR: Address
Name (RID, 0x00)
OperationRegion (P4CS, PCI_Config, 0x00, 0x0100)
Field (P4CS, DWordAcc, NoLock, Preserve)
{
Offset (0x60),
RID4, 16,
PSP4, 1,
PPP4, 1,
Offset (0xDF),
, 6,
HPS4, 1,
PMS4, 1
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x09,
0x04
})
Name (LPRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKD,
0x00
}
})
Name (APRT, Package (0x04)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x12
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x13
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
Device (EXPD)
{
Name (_ADR, 0x00) // _ADR: Address
}
}
Device (PCI1)
{
Name (_ADR, 0x001E0000) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
Name (LPRT, Package (0x08)
{
Package (0x04)
{
0xFFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0xFFFF,
0x01,
\_SB.LNKB,
0x00
},
Package (0x04)
{
0xFFFF,
0x02,
\_SB.LNKC,
0x00
},
Package (0x04)
{
0xFFFF,
0x03,
\_SB.LNKD,
0x00
},
Package (0x04)
{
0x0001FFFF,
0x00,
\_SB.LNKA,
0x00
},
Package (0x04)
{
0x0002FFFF,
0x00,
\_SB.LNKF,
0x00
},
Package (0x04)
{
0x0002FFFF,
0x01,
\_SB.LNKG,
0x00
},
Package (0x04)
{
0x0008FFFF,
0x00,
\_SB.LNKE,
0x00
}
})
Name (APRT, Package (0x08)
{
Package (0x04)
{
0xFFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0xFFFF,
0x01,
0x00,
0x11
},
Package (0x04)
{
0xFFFF,
0x02,
0x00,
0x12
},
Package (0x04)
{
0xFFFF,
0x03,
0x00,
0x13
},
Package (0x04)
{
0x0001FFFF,
0x00,
0x00,
0x10
},
Package (0x04)
{
0x0002FFFF,
0x00,
0x00,
0x15
},
Package (0x04)
{
0x0002FFFF,
0x01,
0x00,
0x16
},
Package (0x04)
{
0x0008FFFF,
0x00,
0x00,
0x14
}
})
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table
{
If (\GPIC)
{
Return (APRT)
}
Else
{
Return (LPRT)
}
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x0B,
0x04
})
Device (CDBS)
{
Name (_ADR, 0x00) // _ADR: Address
Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State
{
If (\WMEF)
{
Return (0x02)
}
Return (0x03)
}
Name (_SUN, 0x01) // _SUN: Slot User Number
}
}
Device (IDE0)
{
Name (_ADR, 0x001F0001) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (IDCS, PCI_Config, 0x00, 0x0100)
Field (IDCS, DWordAcc, NoLock, Preserve)
{
Offset (0x40),
PFT0, 1,
PIE0, 1,
PPE0, 1,
PDT0, 1,
PFT1, 1,
PIE1, 1,
PPE1, 1,
PDT1, 1,
PRC0, 2,
, 2,
PIS0, 2,
PSIE, 1,
PIDE, 1,
SFT0, 1,
SIE0, 1,
SPE0, 1,
SDT0, 1,
SFT1, 1,
SIE1, 1,
SPE1, 1,
SDT1, 1,
SRC0, 2,
, 2,
SIS0, 2,
SSIE, 1,
SIDE, 1,
PRC1, 2,
PIS1, 2,
SRC1, 2,
SIS1, 2,
Offset (0x48),
PSD0, 1,
PSD1, 1,
SSD0, 1,
SSD1, 1,
Offset (0x4A),
PCT0, 2,
, 2,
PCT1, 2,
Offset (0x4B),
SCT0, 2,
, 2,
SCT1, 2,
Offset (0x4C),
Offset (0x54),
PCB0, 1,
PCB1, 1,
SCB0, 1,
SCB1, 1,
PCR0, 1,
PCR1, 1,
SCR0, 1,
SCR1, 1,
, 2,
WRPP, 1,
, 1,
FPB0, 1,
FPB1, 1,
FSB0, 1,
FSB1, 1,
PSIG, 2,
SSIG, 2
}
Field (IDCS, DWordAcc, NoLock, Preserve)
{
Offset (0x40),
PTI0, 4,
PTI1, 4,
Offset (0x42),
STI0, 4,
STI1, 4
}
Method (GPCT, 4, NotSerialized)
{
If (LNot (Or (Arg0, Arg1)))
{
Return (0x00)
}
If (LAnd (LNot (Arg0), Arg1))
{
Return (0x0384)
}
Return (Multiply (Subtract (0x09, Add (Arg2, Arg3)), 0x1E
))
}
Method (GDCT, 4, NotSerialized)
{
If (LNot (Arg0))
{
Return (0x00)
}
If (Arg1)
{
Return (0x14)
}
If (Arg2)
{
Return (Multiply (Subtract (0x04, Arg3), 0x0F))
}
Return (Multiply (Subtract (0x04, Arg3), 0x1E))
}
Method (MTIM, 2, NotSerialized)
{
Store (0x00, Local0)
If (Arg0)
{
Or (Local0, 0x01, Local0)
}
If (LGreaterEqual (Arg0, 0x02))
{
Or (Local0, 0x02, Local0)
}
If (LNot (Arg1))
{
Or (Local0, 0x04, Local0)
}
If (LNot (Arg0))
{
Or (Local0, 0x08, Local0)
}
Return (Local0)
}
Method (MISP, 1, NotSerialized)
{
If (LNot (Arg0))
{
Return (0x00)
}
If (LLessEqual (Arg0, 0x02))
{
Return (0x01)
}
Return (0x02)
}
Method (MRCT, 1, NotSerialized)
{
If (LLessEqual (Arg0, 0x02))
{
Return (0x00)
}
If (LEqual (Arg0, 0x03))
{
Return (0x01)
}
Return (0x03)
}
Device (PRIM)
{
Name (_ADR, 0x00) // _ADR: Address
Name (BGTM, Buffer (0x14) {})
CreateDWordField (BGTM, 0x00, GTP0)
CreateDWordField (BGTM, 0x04, GTD0)
CreateDWordField (BGTM, 0x08, GTP1)
CreateDWordField (BGTM, 0x0C, GTD1)
CreateDWordField (BGTM, 0x10, GTMF)
Name (BPI0, 0x00)
Name (BDM0, 0x00)
Name (BPI1, 0x00)
Name (BDM1, 0x00)
Name (DRE0, 0x00)
Name (DRE1, 0x00)
Name (DIP0, 0x00)
Name (DIP1, 0x00)
Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode
{
Store (GPCT (PFT0, PDT0, PIS0, PRC0), GTP0)
Store (GDCT (PSD0, FPB0, PCB0, PCT0), GTD0)
If (LNot (GTD0))
{
Store (GTP0, GTD0)
}
If (PSIE)
{
Store (GPCT (PFT1, PDT1, PIS1, PRC1), GTP1)
Store (GDCT (PSD1, FPB1, PCB1, PCT1), GTD1)
If (LNot (GTD1))
{
Store (GTP1, GTD1)
}
}
Else
{
Store (0x00, GTP1)
Store (0x00, GTD1)
}
Store (0x00, GTMF)
If (PSD0)
{
Or (GTMF, 0x01, GTMF)
}
If (LNot (GTP0))
{
Or (GTMF, 0x01, GTMF)
Store (0x78, GTP0)
Store (0x14, GTD0)
}
If (PIE0)
{
Or (GTMF, 0x02, GTMF)
}
If (PSD1)
{
Or (GTMF, 0x04, GTMF)
}
If (PIE1)
{
Or (GTMF, 0x08, GTMF)
}
Or (GTMF, 0x10, GTMF)
Return (BGTM)
}
Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode
{
CreateDWordField (Arg0, 0x00, STP0)
CreateDWordField (Arg0, 0x04, STD0)
CreateDWordField (Arg0, 0x08, STP1)
CreateDWordField (Arg0, 0x0C, STD1)
CreateDWordField (Arg0, 0x10, STMF)
Store (0x00, DRE0)
Store (0x00, DIP0)
If (LEqual (SizeOf (Arg1), 0x0200))
{
CreateWordField (Arg1, 0x00, M000)
CreateWordField (Arg1, 0x62, M049)
CreateWordField (Arg1, 0x66, M051)
CreateWordField (Arg1, 0x6A, M053)
CreateWordField (Arg1, 0x7C, M062)
CreateWordField (Arg1, 0x7E, M063)
CreateWordField (Arg1, 0x80, M064)
CreateWordField (Arg1, 0x82, M065)
CreateWordField (Arg1, 0x88, M068)
CreateWordField (Arg1, 0x9C, M078)
CreateWordField (Arg1, 0xAC, M086)
CreateWordField (Arg1, 0xB0, M088)
CreateWordField (Arg1, 0xEE, M119)
CreateWordField (Arg1, 0x0128, M148)
If (LEqual (And (M148, 0xC000), 0x4000))
{
If (And (M148, 0x04))
{
Store (0x01, DRE0)
}
}
If (And (M086, 0x8000))
{
If (And (M119, 0x01))
{
Store (0x01, DRE0)
}
}
If (\W98F)
{
Store (\UUDM (M053, M088), STD0)
If (STD0)
{
Or (STMF, 0x01, STMF)
}
Else
{
And (STMF, 0xFE, STMF)
}
Store (\UMDM (M053, M063, M062, M065), STP0)
If (LNot (STP0))
{
Store (\UPIO (M053, M064, M051, M068), STP0)
}
If (And (M049, 0x0800))
{
Or (STMF, 0x02, STMF)
}
Else
{
And (STMF, 0xFD, STMF)
}
}
Store (\DPIO (STP0, And (STMF, 0x02)), Local0)
Store (\DUDM (STD0, And (STMF, 0x01)), Local1)
If (LGreaterEqual (\_SB.PCI0.LPC.EC.BGID (0x00), 0x0C))
{
Store (0x00, Local0)
Store (0xFF, Local1)
}
Store (MTIM (Local0, And (M000, 0x8000)), PTI0)
Store (MISP (Local0), PIS0)
Store (MRCT (Local0), PRC0)
If (LEqual (Local1, 0xFF))
{
Store (0x00, PSD0)
}
Else
{
Store (0x01, PSD0)
If (LLessEqual (Local1, 0x02))
{
Store (Local1, PCT0)
}
Else
{
If (And (Local1, 0x01))
{
Store (0x01, PCT0)
}
Else
{
Store (0x02, PCT0)
}
}
If (LGreaterEqual (Local1, 0x03))
{
Store (0x01, PCB0)
}
Else
{
Store (0x00, PCB0)
}
If (LEqual (Local1, 0x05))
{
Store (0x01, FPB0)
}
Else
{
Store (0x00, FPB0)
}
Store (0x01, PCR0)
}
Store (\FDMA (Local0, Local1), BDM0)
Store (\FPIO (Local0), BPI0)
}
If (LEqual (SizeOf (Arg2), 0x0200))
{
CreateWordField (Arg2, 0x00, S000)
CreateWordField (Arg2, 0x62, S049)
CreateWordField (Arg2, 0x66, S051)
CreateWordField (Arg2, 0x6A, S053)
CreateWordField (Arg2, 0x7C, S062)
CreateWordField (Arg2, 0x7E, S063)
CreateWordField (Arg2, 0x80, S064)
CreateWordField (Arg2, 0x82, S065)
CreateWordField (Arg2, 0x88, S068)
CreateWordField (Arg2, 0xB0, S088)
If (\W98F)
{
Store (\UUDM (S053, S088), STD1)
If (STD1)
{
Or (STMF, 0x04, STMF)
}
Else
{
And (STMF, 0xFB, STMF)
}
Store (\UMDM (S053, S063, S062, S065), STP1)
If (LNot (STP1))
{
Store (\UPIO (S053, S064, S051, S068), STP1)
}
If (And (S049, 0x0800))
{
Or (STMF, 0x08, STMF)
}
Else
{
And (STMF, 0xF7, STMF)
}
}
Store (\DPIO (STP1, And (STMF, 0x08)), Local0)
Store (\DUDM (STD1, And (STMF, 0x04)), Local1)
If (STP1)
{
Store (MTIM (Local0, And (S000, 0x8000)), PTI1)
If (And (STMF, 0x10))
{
Store (MISP (Local0), PIS1)
Store (MRCT (Local0), PRC1)
Store (0x01, PSIE)
}
}
Else
{
Store (0x00, PTI1)
Store (0x00, PSIE)
}
If (LEqual (Local1, 0xFF))
{
Store (0x00, PSD1)
}
Else
{
Store (0x01, PSD1)
If (LLessEqual (Local1, 0x02))
{
Store (Local1, PCT1)
}
Else
{
If (And (Local1, 0x01))
{
Store (0x01, PCT1)
}
Else
{
Store (0x02, PCT1)
}
}
If (LGreaterEqual (Local1, 0x03))
{
Store (0x01, PCB1)
}
Else
{
Store (0x00, PCB1)
}
If (LEqual (Local1, 0x05))
{
Store (0x01, FPB1)
}
Else
{
Store (0x00, FPB1)
}
Store (0x01, PCR1)
}
Store (\FDMA (Local0, Local1), BDM1)
Store (\FPIO (Local0), BPI1)
}
}
Device (MSTR)
{
Name (_ADR, 0x00) // _ADR: Address
Name (HDTF, Buffer (0x1C)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField (HDTF, 0x0F, HDMA)
CreateByteField (HDTF, 0x16, HPIO)
CreateByteField (HDTF, 0x0D, HFLC)
Name (ERTF, Buffer (0x23)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xEF, 0x5F, 0x00, 0x00, 0x00,
/* 0020 */ 0x00, 0xA0, 0xEF
})
CreateByteField (ERTF, 0x0F, EDMA)
CreateByteField (ERTF, 0x16, EPIO)
CreateByteField (ERTF, 0x0D, EFLC)
Name (HPTF, Buffer (0x23)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xEF, 0x10, 0x03, 0x00, 0x00,
/* 0020 */ 0x00, 0xA0, 0xEF
})
CreateByteField (HPTF, 0x0F, PDMA)
CreateByteField (HPTF, 0x16, PPIO)
CreateByteField (HPTF, 0x0D, PFLC)
Name (HXTF, Buffer (0x2A)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x03, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 0x00, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xEF, 0x5F, 0x00, 0x00, 0x00,
/* 0020 */ 0x00, 0xA0, 0xEF, 0x10, 0x03, 0x00, 0x00, 0x00,
/* 0028 */ 0xA0, 0xEF
})
CreateByteField (HXTF, 0x0F, XDMA)
CreateByteField (HXTF, 0x16, XPIO)
CreateByteField (HXTF, 0x0D, XFLC)
Name (IDTF, Buffer (0x0E)
{
/* 0000 */ 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField (IDTF, 0x01, IDMA)
CreateByteField (IDTF, 0x08, IPIO)
Name (DDTF, Buffer (0x1C)
{
/* 0000 */ 0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xE3, 0x00, 0x00, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xE3
})
CreateByteField (DDTF, 0x01, DDMA)
CreateByteField (DDTF, 0x08, DPIO)
CreateByteField (DDTF, 0x0F, DTAT)
CreateByteField (DDTF, 0x16, DTFT)
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File
{
Store (\_SB.PCI0.LPC.EC.BGID (0x00), Local0)
If (\OSSS)
{
Store (0xE1, HFLC)
Store (0xE1, EFLC)
Store (0xE1, PFLC)
Store (0xE1, XFLC)
}
If (LEqual (Local0, 0x06))
{
If (^^DRE0)
{
If (^^DIP0)
{
Store (^^BDM0, XDMA)
Store (^^BPI0, XPIO)
Return (HXTF)
}
Else
{
Store (^^BDM0, EDMA)
Store (^^BPI0, EPIO)
Return (ERTF)
}
}
If (^^DIP0)
{
Store (^^BDM0, PDMA)
Store (^^BPI0, PPIO)
Return (HPTF)
}
Store (^^BDM0, HDMA)
Store (^^BPI0, HPIO)
Return (HDTF)
}
Store (Zero, Local1)
If (LEqual (Local0, 0x03))
{
Store (One, Local1)
}
If (LEqual (Local0, 0x0A))
{
Store (One, Local1)
}
If (LEqual (Local0, 0x0B))
{
Store (One, Local1)
}
If (Local1)
{
Store (\CDFL, DTFT)
Store (\CDAH, DTAT)
Store (^^BDM0, DDMA)
Store (^^BPI0, DPIO)
Return (DDTF)
}
Else
{
Store (^^BDM0, IDMA)
Store (^^BPI0, IPIO)
Return (IDTF)
}
}
Method (_EJ0, 1, NotSerialized) // _EJx: Eject Device
{
\_SB.PCI0.LPC.EC.BEJ0 (Arg0)
}
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (\_SB.PCI0.LPC.EC.BSTA (0x01))
{
Return (0x0F)
}
Else
{
Return (0x00)
}
}
}
}
}
Device (SATA)
{
Name (_ADR, 0x001F0002) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (IDCS, PCI_Config, 0x00, 0x0100)
Field (IDCS, DWordAcc, NoLock, Preserve)
{
Offset (0x40),
PFT0, 1,
PIE0, 1,
PPE0, 1,
PDT0, 1,
PFT1, 1,
PIE1, 1,
PPE1, 1,
PDT1, 1,
PRC0, 2,
, 2,
PIS0, 2,
PSIE, 1,
PIDE, 1,
SFT0, 1,
SIE0, 1,
SPE0, 1,
SDT0, 1,
SFT1, 1,
SIE1, 1,
SPE1, 1,
SDT1, 1,
SRC0, 2,
, 2,
SIS0, 2,
SSIE, 1,
SIDE, 1,
PRC1, 2,
PIS1, 2,
SRC1, 2,
SIS1, 2,
Offset (0x48),
PSD0, 1,
PSD1, 1,
SSD0, 1,
SSD1, 1,
Offset (0x4A),
PCT0, 2,
, 2,
PCT1, 2,
Offset (0x4B),
SCT0, 2,
, 2,
SCT1, 2,
Offset (0x4C),
Offset (0x54),
PCB0, 1,
PCB1, 1,
SCB0, 1,
SCB1, 1,
PCR0, 1,
PCR1, 1,
SCR0, 1,
SCR1, 1,
, 2,
WRPP, 1,
, 1,
FPB0, 1,
FPB1, 1,
FSB0, 1,
FSB1, 1,
PSIG, 2,
SSIG, 2
}
Field (IDCS, DWordAcc, NoLock, Preserve)
{
Offset (0x40),
PTI0, 4,
PTI1, 4,
Offset (0x42),
STI0, 4,
STI1, 4
}
Method (GPCT, 4, NotSerialized)
{
If (LNot (Or (Arg0, Arg1)))
{
Return (0x00)
}
If (LAnd (LNot (Arg0), Arg1))
{
Return (0x0384)
}
Return (Multiply (Subtract (0x09, Add (Arg2, Arg3)), 0x1E
))
}
Method (GDCT, 4, NotSerialized)
{
If (LNot (Arg0))
{
Return (0x00)
}
If (Arg1)
{
Return (0x14)
}
If (Arg2)
{
Return (Multiply (Subtract (0x04, Arg3), 0x0F))
}
Return (Multiply (Subtract (0x04, Arg3), 0x1E))
}
Method (MTIM, 2, NotSerialized)
{
Store (0x00, Local0)
If (Arg0)
{
Or (Local0, 0x01, Local0)
}
If (LGreaterEqual (Arg0, 0x02))
{
Or (Local0, 0x02, Local0)
}
If (LNot (Arg1))
{
Or (Local0, 0x04, Local0)
}
If (LNot (Arg0))
{
Or (Local0, 0x08, Local0)
}
Return (Local0)
}
Method (MISP, 1, NotSerialized)
{
If (LNot (Arg0))
{
Return (0x00)
}
If (LLessEqual (Arg0, 0x02))
{
Return (0x01)
}
Return (0x02)
}
Method (MRCT, 1, NotSerialized)
{
If (LLessEqual (Arg0, 0x02))
{
Return (0x00)
}
If (LEqual (Arg0, 0x03))
{
Return (0x01)
}
Return (0x03)
}
}
Device (SMBU)
{
Name (_ADR, 0x001F0003) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
}
Device (USB0)
{
Name (_ADR, 0x001D0000) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U0CS, PCI_Config, 0xC4, 0x04)
Field (U0CS, DWordAcc, NoLock, Preserve)
{
U0EN, 2,
Offset (0x04)
}
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR1, Package (0x01) // _PR1: Power Resources for D1
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR2, Package (0x01) // _PR2: Power Resources for D2
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake
{
0x03,
0x03,
\_SB.PCI0.LPC.EC.PUBS
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (Arg0)
{
Store (0x03, U0EN)
}
Else
{
Store (0x00, U0EN)
}
\_SB.PCI0.LPC.EC.PNST (Arg0)
}
}
Device (USB1)
{
Name (_ADR, 0x001D0001) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U1CS, PCI_Config, 0xC4, 0x04)
Field (U1CS, DWordAcc, NoLock, Preserve)
{
U1EN, 2,
Offset (0x04)
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x04,
0x03
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (Arg0)
{
Store (0x03, U1EN)
}
Else
{
Store (0x00, U1EN)
}
}
Device (URTH)
{
Name (_ADR, 0x00) // _ADR: Address
Device (UPEX)
{
Name (_ADR, 0x02) // _ADR: Address
}
}
}
Device (USB2)
{
Name (_ADR, 0x001D0002) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U2CS, PCI_Config, 0xC4, 0x04)
Field (U2CS, DWordAcc, NoLock, Preserve)
{
U2EN, 2,
Offset (0x04)
}
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR1, Package (0x01) // _PR1: Power Resources for D1
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR2, Package (0x01) // _PR2: Power Resources for D2
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake
{
0x0C,
0x03,
\_SB.PCI0.LPC.EC.PUBS
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (Arg0)
{
Store (0x03, U2EN)
}
Else
{
Store (0x00, U2EN)
}
}
}
Device (USB3)
{
Name (_ADR, 0x001A0000) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U3CS, PCI_Config, 0xC4, 0x04)
Field (U3CS, DWordAcc, NoLock, Preserve)
{
U3EN, 2,
Offset (0x04)
}
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x0E,
0x03
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (Arg0)
{
Store (0x03, U3EN)
}
Else
{
Store (0x00, U3EN)
}
}
}
Device (USB4)
{
Name (_ADR, 0x001A0001) // _ADR: Address
Name (_S3D, 0x02) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U4CS, PCI_Config, 0xC4, 0x04)
Field (U4CS, DWordAcc, NoLock, Preserve)
{
U4EN, 2,
Offset (0x04)
}
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR1, Package (0x01) // _PR1: Power Resources for D1
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR2, Package (0x01) // _PR2: Power Resources for D2
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake
{
0x05,
0x03,
\_SB.PCI0.LPC.EC.PUBS
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
If (Arg0)
{
Store (0x03, U4EN)
}
Else
{
Store (0x00, U4EN)
}
}
Device (URTH)
{
Name (_ADR, 0x00) // _ADR: Address
Device (UPDK)
{
Name (_ADR, 0x02) // _ADR: Address
}
}
}
Device (EHC0)
{
Name (_ADR, 0x001D0007) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U7CS, PCI_Config, 0x60, 0x04)
Field (U7CS, DWordAcc, NoLock, Preserve)
{
Offset (0x02),
PWKI, 1,
PWUC, 6,
Offset (0x04)
}
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR1, Package (0x01) // _PR1: Power Resources for D1
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR2, Package (0x01) // _PR2: Power Resources for D2
{
\_SB.PCI0.LPC.EC.PUBS
})
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
Store (0x01, PWKI)
Store (0x0F, PWUC)
}
Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake
{
0x0D,
0x03,
\_SB.PCI0.LPC.EC.PUBS
})
Device (URTH)
{
Name (_ADR, 0x00) // _ADR: Address
Device (UPEX)
{
Name (_ADR, 0x04) // _ADR: Address
}
}
}
Device (EHC1)
{
Name (_ADR, 0x001A0007) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
OperationRegion (U8CS, PCI_Config, 0x60, 0x04)
Field (U8CS, DWordAcc, NoLock, Preserve)
{
Offset (0x02),
PWKI, 1,
PWUC, 4,
Offset (0x04)
}
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR1, Package (0x01) // _PR1: Power Resources for D1
{
\_SB.PCI0.LPC.EC.PUBS
})
Name (_PR2, Package (0x01) // _PR2: Power Resources for D2
{
\_SB.PCI0.LPC.EC.PUBS
})
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
Store (0x01, PWKI)
Store (0x0F, PWUC)
}
Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake
{
0x0D,
0x03,
\_SB.PCI0.LPC.EC.PUBS
})
Device (URTH)
{
Name (_ADR, 0x00) // _ADR: Address
Device (UPDK)
{
Name (_ADR, 0x04) // _ADR: Address
}
}
}
Device (HDEF)
{
Name (_ADR, 0x001B0000) // _ADR: Address
Name (_S3D, 0x03) // _S3D: S3 Device State
Name (RID, 0x00)
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake
{
0x0D,
0x04
})
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake
{
Noop
}
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Name (BDEV, 0xFF)
Name (BSTS, 0x00)
Name (BHKE, 0x00)
Name (BXCN, 0x00)
Method (_Q2C, 0, NotSerialized) // _Qxx: EC Query
{
If (And (SFLG, 0x0400))
{
If (LEqual (BSTS, 0x00))
{
Store (BGID (0x00), BDEV)
If (BXCN)
{
NXRE (BDEV)
}
Else
{
NBRE (BDEV)
}
}
}
}
Method (_Q2D, 0, NotSerialized) // _Qxx: EC Query
{
If (And (SFLG, 0x0400))
{
Store (BGID (0x00), BDEV)
If (BXCN)
{
NXRC (BDEV)
}
Else
{
NBIN (BDEV)
}
}
}
Method (_Q38, 0, NotSerialized) // _Qxx: EC Query
{
If (And (SFLG, 0x0400))
{
Store (BGID (0x00), Local0)
If (LNotEqual (Local0, BDEV))
{
If (LEqual (Local0, 0x0F))
{
BDIS ()
If (BXCN)
{
Store (BDEV, Local0)
Store (0x0F, BDEV)
NXEJ (Local0)
}
Else
{
NBEJ (BDEV)
Store (Local0, BDEV)
}
}
Else
{
If (HPBU)
{
If (BXCN)
{
Store (Local0, BDEV)
NXIN (Local0)
}
}
Else
{
Store (Local0, BDEV)
If (BXCN)
{
NXRC (Local0)
}
Else
{
NBIN (Local0)
}
}
}
}
}
}
Method (NBRE, 1, NotSerialized)
{
If (LLess (Arg0, 0x0C))
{
If (LEqual (\BIDE, 0x03))
{
Notify (\_SB.PCI0.SATA.SCND.MSTR, 0x03)
}
Else
{
Notify (\_SB.PCI0.IDE0.PRIM.MSTR, 0x03)
}
}
If (LEqual (Arg0, 0x10))
{
If (LOr (HPAC, HB0A))
{
If (\WNTF)
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x03)
}
}
Else
{
LED (0x04, 0xC0)
BEEP (0x0F)
Store (0x02, BSTS)
}
}
}
Method (NBEJ, 1, NotSerialized)
{
If (LEqual (BSTS, 0x00))
{
If (LLess (Arg0, 0x0C))
{
If (LEqual (\BIDE, 0x03))
{
Notify (\_SB.PCI0.SATA.SCND.MSTR, 0x01)
}
Else
{
Notify (\_SB.PCI0.IDE0.PRIM.MSTR, 0x01)
}
}
If (LEqual (Arg0, 0x10))
{
If (\WNTF)
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x01)
}
Else
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x81)
}
}
}
LED (0x04, 0x00)
BEEP (0x00)
Store (0x00, BSTS)
}
Method (NBIN, 1, NotSerialized)
{
If (LLess (Arg0, 0x0C))
{
If (LEqual (Arg0, 0x06))
{
BEN (0x02)
}
Else
{
BEN (0x01)
}
LED (0x04, 0x80)
If (LEqual (\BIDE, 0x03))
{
Notify (\_SB.PCI0.SATA.SCND.MSTR, 0x01)
}
Else
{
Notify (\_SB.PCI0.IDE0.PRIM.MSTR, 0x01)
}
}
If (LEqual (Arg0, 0x10))
{
LED (0x04, 0x80)
If (\WNTF)
{
Store (0x01, \_SB.PCI0.LPC.EC.BAT1.XB1S)
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x01)
}
Else
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x81)
}
}
BEEP (0x00)
Store (0x00, BSTS)
}
Method (BSCN, 0, NotSerialized)
{
If (LNot (HPBU))
{
Store (BGID (0x00), Local0)
Store (Local0, BDEV)
If (LLess (Local0, 0x0C))
{
If (LEqual (Local0, 0x06))
{
BEN (0x02)
}
Else
{
BEN (0x01)
}
LED (0x04, 0x80)
}
If (LEqual (Local0, 0x0E))
{
BEN (0x00)
LED (0x04, 0x80)
}
If (LEqual (Local0, 0x10))
{
LED (0x04, 0x80)
Store (0x01, \_SB.PCI0.LPC.EC.BAT1.XB1S)
}
BEEP (0x00)
Store (0x00, BSTS)
}
}
Method (BEJ0, 1, NotSerialized)
{
If (Arg0)
{
BDIS ()
LED (0x04, 0x00)
\BHDP (0x01, 0x00)
Store (0x0F, BDEV)
Store (0x01, BSTS)
If (BHKE)
{
Store (0x00, BHKE)
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x3003)
}
}
Else
{
LED (0x04, 0x80)
Store (0x00, BSTS)
}
}
Method (BEJ3, 1, NotSerialized)
{
If (Arg0)
{
BDIS ()
Store (0x01, BSTS)
}
Else
{
Store (0x00, BSTS)
}
}
Method (BPTS, 1, NotSerialized)
{
Store (0x01, HDBM)
If (LNotEqual (BSTS, 0x00))
{
Store (0x0F, BDEV)
Store (0x00, BSTS)
}
Store (0x00, BHKE)
Store (0x01, Local0)
If (LNotEqual (BDEV, 0x0F))
{
If (LAnd (LNot (\LFDC), LEqual (BDEV, 0x0D)))
{
Store (0x00, Local0)
}
}
Else
{
Store (0x00, Local0)
}
If (LGreaterEqual (Arg0, 0x04))
{
Store (0x00, Local0)
}
If (Local0)
{
BUWK (0x01)
}
Else
{
LED (0x04, 0x00)
BUWK (0x00)
}
}
Method (BWAK, 1, NotSerialized)
{
BUWK (0x00)
Store (BGID (0x00), Local0)
If (LEqual (BSTS, 0x00))
{
If (LOr (\_SB.PCI0.LPC.EC.BAT2.XB2S, LEqual (HBCS, 0x02))) {}
Else
{
If (HB1A)
{
Store (0x01, \_SB.PCI0.LPC.EC.BAT2.XB2S)
Notify (\_SB.PCI0.LPC.EC.BAT2, 0x01)
}
}
If (And (SFLG, 0x0400))
{
If (LEqual (BSTS, 0x00))
{
If (LNotEqual (Local0, BDEV))
{
If (LNotEqual (Local0, 0x10))
{
Store (0x00, \_SB.PCI0.LPC.EC.BAT1.XB1S)
}
If (BXCN)
{
Store (Local0, BDEV)
NXRC (Local0)
}
Else
{
NBEJ (BDEV)
Store (Local0, BDEV)
NBIN (Local0)
}
}
Else
{
If (LOr (\LFDC, LNotEqual (BDEV, 0x0D)))
{
If (LNotEqual (Local0, 0x0F))
{
LED (0x04, 0x80)
If (HPBU)
{
Or (ShiftLeft (Arg0, 0x08), 0x2005, BHKE)
\_SB.PCI0.LPC.EC.HKEY.MHKQ (BHKE)
If (LLessEqual (Arg0, 0x02)) {}
Else
{
If (BXCN)
{
NXRE (Local0)
}
Else
{
NBRE (Local0)
}
}
}
}
}
}
}
}
}
}
Method (BDIS, 0, NotSerialized)
{
If (\_SB.PCI0.LPC.BPRS)
{
If (LEqual (\BIDE, 0x03))
{
Store (0x00, \_SB.PCI0.SATA.SIE0)
Store (0x00, \_SB.PCI0.SATA.STI0)
Store (0x00, \_SB.PCI0.LPC.URST)
Stall (0x0F)
Store (0x01, \_SB.PCI0.SATA.SSIG)
}
Else
{
Store (0x00, \_SB.PCI0.IDE0.PIE0)
Store (0x00, \_SB.PCI0.IDE0.PTI0)
Store (0x00, \_SB.PCI0.LPC.URST)
Stall (0x0F)
Store (0x01, \_SB.PCI0.IDE0.PSIG)
}
Store (0x00, \_SB.PCI0.LPC.UBPW)
}
}
Method (BEN, 1, NotSerialized)
{
Store (0x00, \_SB.PCI0.LPC.URST)
Store (0x01, \_SB.PCI0.LPC.UBPW)
Sleep (0x0F)
If (Arg0)
{
If (LEqual (\BIDE, 0x03))
{
Store (0x00, \_SB.PCI0.SATA.SSIG)
Store (0x01, \_SB.PCI0.SATA.SIDE)
}
Else
{
Store (0x00, \_SB.PCI0.IDE0.PSIG)
Store (0x01, \_SB.PCI0.IDE0.PIDE)
}
Stall (0x2D)
Store (0x01, \_SB.PCI0.LPC.URST)
If (LNot (\WVIS))
{
If (LEqual (Arg0, 0x02))
{
Sleep (0x07D0)
}
Else
{
Sleep (0x0190)
}
}
}
If (\WVIS)
{
Store (0x3C, Local0)
Store (0x00, Local1)
If (LEqual (\BIDE, 0x03))
{
Store (0x01, Local1)
}
While (Local0)
{
Sleep (0x01F4)
If (HSWA (Local1))
{
Break
}
Decrement (Local0)
}
}
}
Method (BSTA, 1, NotSerialized)
{
If (LNot (\_SB.PCI0.LPC.BPRS))
{
Return (0x00)
}
BINI ()
If (LEqual (Arg0, 0x00))
{
Return (LEqual (BDEV, 0x0D))
}
If (LEqual (Arg0, 0x01))
{
Return (LLess (BDEV, 0x0C))
}
If (LEqual (Arg0, 0x02))
{
Return (LEqual (BDEV, 0x0E))
}
Return (0x00)
}
Method (BUWK, 1, NotSerialized)
{
If (\H8DR)
{
If (Arg0)
{
Store (0x01, \_SB.PCI0.LPC.EC.HWBU)
}
Else
{
Store (0x00, \_SB.PCI0.LPC.EC.HWBU)
}
}
Else
{
If (Arg0)
{
\MBEC (0x32, 0xFF, 0x80)
}
Else
{
\MBEC (0x32, 0x7F, 0x00)
}
}
}
Method (BINI, 0, NotSerialized)
{
If (LEqual (BDEV, 0xFF))
{
Store (BGID (0x00), BDEV)
}
}
Method (BGID, 1, NotSerialized)
{
Store (0x0F, Local0)
If (Arg0)
{
Store (0xFF, Local0)
}
Else
{
If (LEqual (\_SB.PCI0.LPC.EC.GSID (), 0x03))
{
Store (BAID (), Local0)
}
If (LEqual (Local0, 0x0F))
{
If (\H8DR)
{
If (LEqual (HBCS, 0x02))
{
Store (0x10, Local0)
}
}
Else
{
If (And (\RBEC (0xCE), 0x02))
{
Store (0x10, Local0)
}
}
}
}
If (LAnd (\HDUB, LLess (Local0, 0x0C)))
{
Store (0x0F, Local0)
}
Return (Local0)
}
Method (BAID, 0, NotSerialized)
{
If (LAnd (LEqual (BAHD, 0x00), LEqual (BAAT, 0x00)))
{
Return (0x0B)
}
Else
{
If (LAnd (LEqual (BAHD, 0x01), LEqual (BAAT, 0x00)))
{
Return (0x06)
}
Else
{
Return (0x0F)
}
}
}
Method (NXRE, 1, NotSerialized)
{
If (LEqual (Arg0, 0x0F))
{
LED (0x04, 0x00)
Store (0x00, BSTS)
}
If (LLess (Arg0, 0x0C))
{
LED (0x04, 0xC0)
Notify (\_SB.SWAP, 0x83)
}
If (LEqual (Arg0, 0x0E))
{
LED (0x04, 0xC0)
Notify (\_SB.SWAP, 0x83)
}
If (LEqual (Arg0, 0x10))
{
If (LOr (HPAC, HB0A))
{
LED (0x04, 0xC0)
Notify (\_SB.SWAP, 0x83)
}
Else
{
LED (0x04, 0xC0)
BEEP (0x0F)
Store (0x02, BSTS)
}
}
}
Method (NXRC, 1, NotSerialized)
{
If (LLess (Arg0, 0x0C))
{
LED (0x04, 0x80)
If (LEqual (Arg0, 0x06))
{
BEN (0x02)
}
Else
{
BEN (0x01)
}
Notify (\_SB.SWAP, 0x80)
}
If (LEqual (Arg0, 0x0E))
{
LED (0x04, 0x80)
BEN (0x00)
Notify (\_SB.SWAP, 0x80)
}
If (LEqual (Arg0, 0x10))
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x81)
LED (0x04, 0x80)
Notify (\_SB.SWAP, 0x80)
}
BEEP (0x00)
Store (0x00, BSTS)
}
Method (NXEJ, 1, NotSerialized)
{
If (LEqual (Arg0, 0x10))
{
Notify (\_SB.PCI0.LPC.EC.BAT1, 0x81)
}
Notify (\_SB.SWAP, 0x82)
LED (0x04, 0x00)
BEEP (0x00)
Store (0x00, BSTS)
}
Method (NXIN, 1, NotSerialized)
{
Notify (\_SB.SWAP, 0x81)
}
}
Scope (\_SB.PCI0.LPC.EC.BAT1)
{
Method (_EJ0, 1, NotSerialized) // _EJx: Eject Device
{
Store (0x00, B1ST)
Store (0x00, XB1S)
\_SB.PCI0.LPC.EC.BEJ0 (Arg0)
}
}
Scope (\_SB)
{
Device (SWAP)
{
Name (_HID, EisaId ("IBM0069")) // _HID: Hardware ID
Method (_STA, 0, NotSerialized) // _STA: Status
{
If (\WMEF)
{
Return (0x0F)
}
Else
{
Return (0x00)
}
}
Method (XCNN, 1, NotSerialized)
{
Store (Arg0, \_SB.PCI0.LPC.EC.BXCN)
Return (0x09)
}
Method (XSWP, 0, NotSerialized)
{
Return (0x01)
}
Method (XEJ0, 1, NotSerialized)
{
\_SB.PCI0.LPC.EC.BEJ0 (Arg0)
}
Method (XEJ3, 1, NotSerialized)
{
\_SB.PCI0.LPC.EC.BEJ3 (Arg0)
}
Method (XDID, 0, NotSerialized)
{
Name (XPCK, Package (0x06)
{
0x00,
0x00,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0x00
})
Store (\_SB.PCI0.LPC.EC.BDEV, Local0)
Store (Local0, Index (XPCK, 0x00))
If (LLess (Local0, 0x0C))
{
If (LEqual (\BIDE, 0x03))
{
Store (\_SB.PCI0.SATA._ADR, Index (XPCK, 0x02))
Store (\_SB.PCI0.SATA.SCND._ADR, Index (XPCK, 0x03))
Store (\_SB.PCI0.SATA.SCND.MSTR._ADR, Index (XPCK, 0x04))
}
Else
{
Store (\_SB.PCI0.IDE0._ADR, Index (XPCK, 0x02))
Store (\_SB.PCI0.IDE0.PRIM._ADR, Index (XPCK, 0x03))
Store (\_SB.PCI0.IDE0.PRIM.MSTR._ADR, Index (XPCK, 0x04))
}
}
If (LEqual (Local0, 0x10))
{
Store (\_SB.PCI0.LPC.EC.BAT1._HID, Index (XPCK, 0x02))
Store (\_SB.PCI0.LPC.EC.BAT1._UID, Index (XPCK, 0x04))
}
Store (XOr (\_SB.PCI0.LPC.BPRS, 0x00), Index (XPCK, 0x05))
Return (XPCK)
}
Method (XSTM, 1, NotSerialized)
{
Name (XDMY, Buffer (0x14) {})
If (LEqual (\BIDE, 0x03))
{
\_SB.PCI0.SATA.SCND._STM (XDMY, Arg0, 0x00)
}
Else
{
\_SB.PCI0.IDE0.PRIM._STM (XDMY, Arg0, 0x00)
}
}
Method (XGTF, 0, NotSerialized)
{
If (LEqual (\BIDE, 0x03))
{
Return (\_SB.PCI0.SATA.SCND.MSTR._GTF)
}
Else
{
Return (\_SB.PCI0.IDE0.PRIM.MSTR._GTF ())
}
}
}
}
Scope (\_SB)
{
Device (GDCK)
{
Name (_HID, EisaId ("IBM0079")) // _HID: Hardware ID
Name (_CID, EisaId ("PNP0C15")) // _CID: Compatible ID
Name (DOID, 0xFFFFFFFF)
Name (DIDB, 0xFFFFFFFF)
Name (FLAG, 0x00)
Name (WUCT, 0x00)
Name (DHKE, 0x00)
Event (DEVT)
Method (DSTA, 0, NotSerialized)
{
UDCK ()
UDKT ()
If (LOr (LEqual (GDID (), 0x4C004D24), LEqual (GDID (), 0x44004D24)))
{
Store (0x0F, Local0)
}
Else
{
If (LNot (\W98F))
{
Store (0x00, Local0)
}
Else
{
Store (0x0C, Local0)
}
}
Return (Local0)
}
Method (DPTS, 1, NotSerialized)
{
If (LAnd (LGreaterEqual (Arg0, 0x01), LLessEqual (Arg0, 0x04)))
{
Store (0x00, DHKE)
If (DFLG (0x02, 0x02))
{
Store (0x00, DOID)
DFLG (0x01, 0x02)
}
If (LOr (LEqual (GDID (), 0x4C004D24), LEqual (GDID (), 0x44004D24)))
{
\_SB.PCI0.LPC.EC.DDWK (0x01)
}
Store (GDID (), DIDB)
DFLG (0x00, 0x0100)
}
}
Name (DDTM, 0x00)
Method (DWAK, 1, NotSerialized)
{
Store (0xFFFFFFFF, DOID)
If (LAnd (LGreaterEqual (Arg0, 0x01), LLessEqual (Arg0, 0x04)))
{
Store (0x00, DDTM)
If (LOr (LEqual (DIDB, 0x4C004D24), LEqual (DIDB, 0x44004D24)))
{
Store (0x01, DDTM)
}
If (DDTM)
{
Store (0x00, DDTM)
If (LEqual (GDID (), 0x4C004D24))
{
Store (0x01, DDTM)
}
If (LEqual (GDID (), 0x44004D24))
{
Store (0x01, DDTM)
}
If (DDTM)
{
If (LEqual (Arg0, 0x04))
{
If (And (\_SB.PCI0.LPC.WAKR, 0x08))
{
DGPE ()
}
}
ShiftLeft (Arg0, 0x08, DHKE)
If (LNot (DFLG (0x02, 0x08))) {}
}
Else
{
Store (0x01, \_SB.PCI0.LPC.BUSD)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x01)
\_SB.PCI0.LPC.EC.DATT (0x01, 0x00)
Notify (\_SB.GDCK, 0x00)
\DHDP (0x00)
}
}
Else
{
Store (0x00, DDTM)
If (LEqual (GDID (), 0x4C004D24))
{
Store (0x01, DDTM)
}
If (LEqual (GDID (), 0x44004D24))
{
Store (0x01, DDTM)
}
If (DDTM)
{
WDCK ()
}
Else
{
Noop
}
}
DFLG (0x01, 0x0100)
DFLG (0x01, 0x02)
DFLG (0x01, 0x10)
DFLG (0x01, 0x20)
Store (0x01, \_SB.PCI0.LPC.DSCI)
}
}
Method (DGPE, 0, NotSerialized)
{
DFLG (0x00, 0x08)
}
Method (DDCK, 1, NotSerialized)
{
If (Arg0)
{
\_SB.PCI0.LPC.EC.LED (0x08, 0x00)
\_SB.PCI0.LPC.EC.LED (0x09, 0x80)
\_SB.PCI0.LPC.LCON (0x01)
BCON (0x01)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x00)
\_SB.PCI0.LPC.EC.DATT (0x01, 0x01)
}
Else
{
\_SB.PCI0.LPC.EC.LED (0x08, 0x80)
\_SB.PCI0.LPC.EC.LED (0x09, 0xC0)
DFLG (0x00, 0x02)
\DHDP (0x00)
BCON (0x00)
\_SB.PCI0.LPC.LCON (0x00)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x01)
\_SB.PCI0.LPC.EC.DATT (0x01, 0x00)
}
Return (0x01)
}
Method (DEJ0, 1, NotSerialized)
{
If (Arg0)
{
Store (0x00, DOID)
UDKI ()
}
DFLG (0x01, 0x02)
\_SB.PCI0.LPC.EC.LED (0x08, 0x00)
\_SB.PCI0.LPC.EC.LED (0x09, 0x00)
}
Method (DEJ3, 1, NotSerialized)
{
If (Arg0)
{
DFLG (0x00, 0x10)
If (LEqual (\SPS, 0x03))
{
PDE3 ()
}
}
}
Method (DEJ4, 1, NotSerialized)
{
If (Arg0)
{
DFLG (0x00, 0x20)
}
}
Method (PDE3, 0, NotSerialized)
{
Noop
}
Name (HIDE, 0x00)
Method (WDCK, 0, NotSerialized)
{
If (LOr (DFLG (0x02, 0x10), DFLG (0x02, 0x20)))
{
DDCK (0x01)
If (\W98F)
{
DFLG (0x00, 0x0200)
Store (0x05, HIDE)
}
}
Else
{
Notify (\_SB.GDCK, 0x00)
}
}
Method (UDCK, 0, NotSerialized)
{
If (DFLG (0x02, 0x08))
{
If (LNot (DFLG (0x02, 0x0100)))
{
\_SB.PCI0.LPC.EC.LED (0x08, 0x80)
\_SB.PCI0.LPC.EC.LED (0x09, 0xC0)
Or (DHKE, 0x2004, DHKE)
If (LEqual (\UOPT, 0x00))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (DHKE)
}
If (\W98F)
{
Notify (\_SB.GDCK, 0x01)
}
Else
{
Notify (\_SB.GDCK, 0x03)
}
DFLG (0x01, 0x08)
}
}
}
Method (UDKI, 0, NotSerialized)
{
If (\WNTF)
{
Store (0x01, WUCT)
}
Else
{
Store (0x05, WUCT)
}
}
Method (UDKT, 0, NotSerialized)
{
If (And (DHKE, 0x2004))
{
If (LEqual (GDID (), 0x00))
{
If (LNot (Decrement (WUCT)))
{
Store (0x00, DHKE)
If (LEqual (\UOPT, 0x00))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x4003)
}
}
}
}
}
Method (GDID, 0, NotSerialized)
{
If (LEqual (DOID, 0xFFFFFFFF))
{
Store (0xFFFFFFFF, \_SB.GDCK.G_ID)
Store (RDID (), DOID)
}
Return (DOID)
}
Method (RDID, 0, NotSerialized)
{
Store (0x00, Local0)
If (\_SB.PCI0.LPC.EPWG)
{
If (LEqual (\_SB.GDCK.GGID (), 0x00))
{
If (\H8DR)
{
If (\_SB.PCI0.LPC.EC.EEPR ())
{
Store (\_SB.PCI0.LPC.EC.HDEP, Local0)
}
Else
{
Store (0x4C004D24, Local0)
}
}
Else
{
Store (\DCKI, Local0)
}
}
If (LEqual (\_SB.GDCK.GGID (), 0x01))
{
Store (0x44004D24, Local0)
}
If (LEqual (\_SB.GDCK.GGID (), 0x03))
{
Store (0x0200AE30, Local0)
}
}
Return (Local0)
}
Method (RDSR, 0, NotSerialized)
{
Store (0x00, Local0)
If (LNotEqual (GDID (), 0x00))
{
If (LEqual (\_SB.GDCK.GGID (), 0x00))
{
If (\H8DR)
{
If (\_SB.PCI0.LPC.EC.EEPR ())
{
Store (\_SB.PCI0.LPC.EC.HDEN, Local0)
}
}
Else
{
Store (\DCKS, Local0)
}
}
If (LEqual (\_SB.GDCK.GGID (), 0x01))
{
Store (0x00, Local0)
}
}
Return (Local0)
}
Method (BCON, 1, NotSerialized)
{
Store (\_SB.PCI0.LPC.EC.DATT (0x00, 0x02), Local0)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x01)
Or (\_SB.PCI0.LPC.SERQ, 0x40, \_SB.PCI0.LPC.SERQ)
And (\_SB.PCI0.LPC.SERQ, 0x7F, \_SB.PCI0.LPC.SERQ)
Store (\_SB.PCI0.LPC.CLKR, Local1)
If (Arg0)
{
Store (0x00, \_SB.PCI0.LPC.CLKR)
Store (0x01, \_SB.PCI0.LPC.BUSC)
}
Else
{
Store (0x01, \_SB.PCI0.LPC.BUSD)
}
Store (Local1, \_SB.PCI0.LPC.CLKR)
Or (\_SB.PCI0.LPC.SERQ, 0xC0, \_SB.PCI0.LPC.SERQ)
And (\_SB.PCI0.LPC.SERQ, 0xBF, \_SB.PCI0.LPC.SERQ)
If (LEqual (Local0, 0x00))
{
\_SB.PCI0.LPC.EC.DATT (0x00, 0x00)
}
}
Method (DFLG, 2, NotSerialized)
{
If (LEqual (Arg0, 0x00))
{
Or (FLAG, Arg1, FLAG)
}
If (LEqual (Arg0, 0x01))
{
And (FLAG, Not (Arg1), FLAG)
}
If (And (FLAG, Arg1))
{
Return (0x01)
}
Else
{
Return (0x00)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q37, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EPWG)
{
Store (0x07D0, Local0)
Sleep (0x64)
Store (0xFFFFFFFF, \_SB.GDCK.G_ID)
While (LAnd (LEqual (\_SB.GDCK.GGID (), 0x07), Local0))
{
Sleep (0x01)
Store (0xFFFFFFFF, \_SB.GDCK.G_ID)
Decrement (Local0)
}
Store (0xFFFFFFFF, \_SB.GDCK.DOID)
If (LOr (LEqual (\_SB.GDCK.GDID (), 0x4C004D24), LEqual (\_SB.GDCK.GDID (), 0x44004D24)))
{
If (HPAC)
{
Store (0x00, \_SB.PCI0.LPC.DRST)
Notify (\_SB.GDCK, 0x00)
}
}
}
}
Method (EEPR, 0, NotSerialized)
{
Store (0x00, Local0)
If (\H8DR)
{
Store (0x00, HDEO)
Store (0x0A, HDEC)
While (LNot (And (HDEC, 0xC0)))
{
Sleep (0x01)
}
If (LNot (And (HDEC, 0x40)))
{
Store (0x00, Local1)
Store (HDEN, Local2)
Store (0x04, Local3)
While (Local3)
{
Add (Local1, And (Local2, 0xFF), Local1)
ShiftRight (Local2, 0x08, Local2)
Decrement (Local3)
}
Store (HDEP, Local2)
Store (0x04, Local3)
While (Local3)
{
Add (Local1, And (Local2, 0xFF), Local1)
ShiftRight (Local2, 0x08, Local2)
Decrement (Local3)
}
Add (Local1, HDEM, Local1)
Add (Local1, HDES, Local1)
If (LNot (And (Local1, 0xFF)))
{
Store (0x01, Local0)
}
}
}
Return (Local0)
}
}
Method (_STA, 0, NotSerialized) // _STA: Status
{
Store (GGID (), Local0)
If (LNot (\W98F))
{
Store (0x00, Local1)
}
Else
{
Store (0x0C, Local1)
}
If (LEqual (Local0, 0x03))
{
Store (\_SB.PCI0.LPC.EC.SSTA (), Local1)
}
Return (Local1)
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
\_SB.PCI0.LPC.EC.SINI ()
\_SB.PCI0.LPC.EC.DATT (0x02, 0x01)
If (LEqual (GGID (), 0x07))
{
\_SB.PCI0.LPC.EC.DATT (0x01, 0x00)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x01)
}
Else
{
\_SB.PCI0.LPC.EC.DATT (0x01, 0x01)
\_SB.PCI0.LPC.EC.DATT (0x00, 0x00)
}
\_SB.PCI0.LPC.EC.DDWK (0x00)
Store (0x01, \_SB.PCI0.LPC.DSCI)
}
Method (_DCK, 1, NotSerialized) // _DCK: Dock Present
{
Store (0x00, Local0)
If (LEqual (GGID (), 0x03))
{
Store (\_SB.PCI0.LPC.EC.SDCK (Arg0), Local0)
}
If (\VIGD)
{
\_SB.PCI0.VID.VDSW (Arg0)
}
Return (Local0)
}
Name (UDOP, 0x00)
Method (_EJ0, 1, NotSerialized) // _EJx: Eject Device
{
If (LEqual (GGID (), 0x03))
{
\_SB.PCI0.LPC.EC.SEJ0 (Arg0)
}
}
Method (XEJ3, 1, NotSerialized)
{
If (LEqual (GGID (), 0x03))
{
\_SB.PCI0.LPC.EC.SEJ3 (Arg0)
}
}
Method (_EJ4, 1, NotSerialized) // _EJx: Eject Device
{
If (LEqual (GGID (), 0x03))
{
\_SB.PCI0.LPC.EC.SEJ4 (Arg0)
}
}
Method (PEJ3, 0, NotSerialized)
{
If (LEqual (GGID (), 0x03))
{
\_SB.PCI0.LPC.EC.PSE3 ()
}
}
Method (_BDN, 0, NotSerialized) // _BDN: BIOS Dock Name
{
Store (0x00, Local0)
If (LEqual (GGID (), 0x03))
{
Store (\_SB.PCI0.LPC.EC.SLBN (), Local0)
}
Return (Local0)
}
Method (_UID, 0, NotSerialized) // _UID: Unique ID
{
Store (0x00, Local0)
If (LEqual (GGID (), 0x03))
{
Store (\_SB.PCI0.LPC.EC.SLUD (), Local0)
}
Return (Local0)
}
Method (GPTS, 1, NotSerialized)
{
\_SB.PCI0.LPC.EC.SPTS (Arg0)
}
Method (GWAK, 1, NotSerialized)
{
\_SB.PCI0.LPC.EC.SWAK (Arg0)
\_SB.PCI0.LPC.EC.DDWK (0x00)
}
Method (GGPE, 0, NotSerialized)
{
If (LEqual (GGID (), 0x03))
{
\_SB.PCI0.LPC.EC.SGPE ()
}
}
Name (G_ID, 0xFFFFFFFF)
Method (GGID, 0, NotSerialized)
{
Store (G_ID, Local0)
If (LEqual (Local0, 0xFFFFFFFF))
{
Store (\_SB.PCI0.LPC.DKI0, Local0)
Store (\_SB.PCI0.LPC.DKI1, Local1)
Store (\_SB.PCI0.LPC.GL03, Local2)
And (Local2, 0x01, Local2)
Or (Local0, ShiftLeft (Local1, 0x01), Local0)
Or (Local0, ShiftLeft (Local2, 0x02), Local0)
Store (Local0, G_ID)
}
Return (Local0)
}
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q50, 0, NotSerialized) // _Qxx: EC Query
{
Store (\_SB.GDCK.GGID (), Local0)
If (LNotEqual (Local0, 0x07))
{
\_SB.PCI0.LPC.EC.LED (0x08, 0x80)
If (LEqual (ES07, 0x01))
{
\_SB.PCI0.LPC.EC.LED (0x09, 0xC0)
If (LEqual (Local0, 0x03))
{
\_SB.PCI0.LPC.EC.SPEJ ()
}
If (\W98F)
{
Notify (\_SB.GDCK, 0x01)
}
Else
{
Notify (\_SB.GDCK, 0x03)
}
Store (0x01, ES07)
}
If (LEqual (ES01, 0x01))
{
If (LNot (HPBU))
{
If (And (SFLG, 0x0400))
{
Store (BGID (0x00), BDEV)
If (BXCN)
{
NXRC (BDEV)
}
Else
{
NBIN (BDEV)
}
}
}
Store (One, ES01)
}
If (LEqual (ES10, 0x01))
{
Store (0x01, ES10)
}
}
}
Method (_Q58, 0, NotSerialized) // _Qxx: EC Query
{
Store (0xFFFFFFFF, \_SB.GDCK.G_ID)
Store (0xFFFFFFFF, \_SB.PCI0.LPC.EC.SLID)
Store (\_SB.GDCK.GGID (), Local0)
If (LEqual (Local0, 0x03))
{
ASSI (0x00)
Sleep (0x64)
If (LNotEqual (\_SB.PCI0.LPC.SIOD, 0xFF))
{
Notify (\_SB.GDCK, 0x00)
}
}
\_SB.PCI0.IGBE.ABWA (0x00)
}
Method (GUSB, 1, NotSerialized)
{
ShiftLeft (Arg0, 0x02, Local0)
If (\H8DR)
{
Store (Arg0, UHPW)
Store (Arg0, SLIS)
}
Else
{
Store (Arg0, UHPW)
\MBEC (0x03, 0xFB, Local0)
}
}
Method (DATT, 2, NotSerialized)
{
Store (0x00, Local0)
If (LEqual (Arg0, 0x00))
{
If (LEqual (Arg1, 0x01))
{
If (\H8DR)
{
Or (HAM6, 0x80, HAM6)
}
Else
{
\MBEC (0x16, 0xFF, 0x80)
}
Store (0x01, Local0)
}
If (LEqual (Arg1, 0x00))
{
If (\H8DR)
{
And (HAM6, 0x7F, HAM6)
}
Else
{
\MBEC (0x16, 0x7F, 0x00)
}
}
If (LEqual (Arg1, 0x02))
{
If (\H8DR)
{
If (And (HAM6, 0x80))
{
Store (0x01, Local0)
}
}
Else
{
If (And (\RBEC (0x16), 0x80))
{
Store (0x01, Local0)
}
}
}
}
If (LEqual (Arg0, 0x01))
{
If (LEqual (Arg1, 0x01))
{
If (\H8DR)
{
Or (HAMA, 0x01, HAMA)
}
Else
{
\MBEC (0x1A, 0xFF, 0x01)
}
Store (0x01, Local0)
}
If (LEqual (Arg1, 0x00))
{
If (\H8DR)
{
And (HAMA, 0xFE, HAMA)
}
Else
{
\MBEC (0x1A, 0xFE, 0x00)
}
}
If (LEqual (Arg1, 0x02))
{
If (\H8DR)
{
If (And (HAMA, 0x01))
{
Store (0x01, Local0)
}
}
Else
{
If (And (\RBEC (0x1A), 0x01))
{
Store (0x01, Local0)
}
}
}
}
If (LEqual (Arg0, 0x02))
{
If (LEqual (Arg1, 0x01))
{
If (\H8DR)
{
Or (HAMB, 0x01, HAMB)
}
Else
{
\MBEC (0x1B, 0xFF, 0x01)
}
Store (0x01, Local0)
}
If (LEqual (Arg1, 0x00))
{
If (\H8DR)
{
And (HAMB, 0xFE, HAMB)
}
Else
{
\MBEC (0x1B, 0xFE, 0x00)
}
}
If (LEqual (Arg1, 0x02))
{
If (\H8DR)
{
If (And (HAMB, 0x01))
{
Store (0x01, Local0)
}
}
Else
{
If (And (\RBEC (0x1B), 0x01))
{
Store (0x01, Local0)
}
}
}
}
Return (Local0)
}
Method (DDWK, 1, NotSerialized)
{
Store (0x00, Local0)
If (LEqual (Arg0, 0x01))
{
If (\H8DR)
{
Store (One, HWDK)
}
Else
{
\MBEC (0x32, 0xFF, 0x08)
}
Store (0x01, Local0)
}
If (LEqual (Arg0, 0x00))
{
If (\H8DR)
{
Store (Zero, HWDK)
}
Else
{
\MBEC (0x32, 0xF7, 0x00)
}
}
If (LEqual (Arg0, 0x02))
{
If (\H8DR)
{
If (HWDK)
{
Store (0x01, Local0)
}
}
Else
{
If (And (\RBEC (0x32), 0x08))
{
Store (0x01, Local0)
}
}
}
Return (Local0)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Name (SLID, 0xFFFFFFFF)
Name (SIDB, 0xFFFFFFFF)
Name (SFLG, 0x00)
Name (SUCT, 0x00)
Name (SHKE, 0x00)
Name (IFLG, 0x00)
Method (SLBN, 0, NotSerialized)
{
Return (0x03)
}
Method (SLUD, 0, NotSerialized)
{
Return (0x00)
}
Method (SSTA, 0, NotSerialized)
{
SUDK ()
SUDT ()
If (LEqual (GSID (), 0x03))
{
Store (0x0F, Local0)
}
Else
{
If (LNot (\W98F))
{
Store (0x00, Local0)
}
Else
{
Store (0x0C, Local0)
}
}
If (\W98F)
{
Store (HIDS (Local0), Local0)
}
Return (Local0)
}
Method (SINI, 0, NotSerialized)
{
If (LEqual (GSID (), 0x03))
{
If (LNot (IFLG))
{
Store (0x01, ES07)
}
Or (SFLG, 0x0400, SFLG)
}
Else
{
And (SFLG, Not (0x0400), SFLG)
}
Store (0x01, IFLG)
}
Method (SPTS, 1, NotSerialized)
{
If (LAnd (LGreaterEqual (Arg0, 0x01), LLessEqual (Arg0, 0x04)))
{
Store (0x00, SHKE)
Store (0x00, SIDB)
Store (Zero, \_SB.PCI0.LPC.GO16)
If (LEqual (Arg0, 0x03))
{
Store (0x80, \_SB.PCI0.LPC.GER0)
}
If (And (SFLG, 0x02))
{
Store (0x00, SLID)
And (SFLG, Not (0x02), SFLG)
}
If (LEqual (GSID (), 0x03))
{
If (LEqual (Arg0, 0x03))
{
\_SB.PCI0.LPC.EC.DDWK (0x01)
}
Store (0x03, SIDB)
}
Or (SFLG, 0x0100, SFLG)
}
}
Method (SWAK, 1, NotSerialized)
{
Store (0xFFFFFFFF, SLID)
If (LAnd (LGreaterEqual (Arg0, 0x01), LLessEqual (Arg0, 0x04)))
{
If (LEqual (SIDB, 0x03))
{
If (LEqual (GSID (), 0x03))
{
LED (0x03, 0x80)
ShiftLeft (Arg0, 0x08, SHKE)
If (LEqual (Arg0, 0x03))
{
Store (One, \_SB.PCI0.LPC.GO16)
Store (0x82, \_SB.PCI0.LPC.GER0)
}
If (LEqual (Arg0, 0x04))
{
Store (0x01, ES07)
}
}
Else
{
GUSB (0x00)
Notify (\_SB.GDCK, 0x00)
And (SFLG, Not (0x0400), SFLG)
}
}
Else
{
If (LEqual (GSID (), 0x03))
{
ASSI (0x00)
Sleep (0x64)
If (LNotEqual (\_SB.PCI0.LPC.SIOD, 0xFF))
{
WSDK ()
}
}
Else
{
Noop
}
}
Store (THRI, Local1)
Store (0xF0, Local2)
Store (Or (Local2, Local1), ATMX)
Sleep (0x64)
And (SFLG, Not (0x0100), SFLG)
And (SFLG, Not (0x02), SFLG)
And (SFLG, Not (0x10), SFLG)
And (SFLG, Not (0x20), SFLG)
}
Store (0x00, HB1I)
}
Method (SGPE, 0, NotSerialized)
{
Or (SFLG, 0x08, SFLG)
}
Method (SDCK, 1, NotSerialized)
{
If (\H8DR)
{
If (Arg0)
{
Sleep (0x64)
If (LNot (BXCN))
{
BSCN ()
}
\_SB.PCI0.LPC.EC.DATT (0x01, 0x01)
Store (0x00, HB1I)
Or (SFLG, 0x0400, SFLG)
}
Else
{
Or (SFLG, 0x02, SFLG)
GUSB (0x00)
Store (0x01, HB1I)
If (\WNTF)
{
Store (0x00, \_SB.PCI0.LPC.EC.BAT1.B1ST)
Store (0x00, \_SB.PCI0.LPC.EC.BAT1.XB1S)
Store (0x00, \_SB.PCI0.LPC.EC.BAT2.B2ST)
Store (0x00, \_SB.PCI0.LPC.EC.BAT2.XB2S)
}
BEJ0 (0x01)
If (BXCN)
{
Notify (\_SB.SWAP, 0x82)
}
\_SB.PCI0.LPC.EC.DATT (0x01, 0x00)
And (SFLG, Not (0x0400), SFLG)
}
}
Return (0x01)
}
Method (SEJ0, 1, NotSerialized)
{
Store (0x00, SLID)
If (Arg0)
{
ASSI (0x01)
}
LED (0x03, 0x00)
SUDI ()
And (SFLG, Not (0x02), SFLG)
}
Method (SEJ3, 1, NotSerialized)
{
Or (SFLG, 0x10, SFLG)
If (LEqual (\SPS, 0x03))
{
PSE3 ()
}
}
Method (SEJ4, 1, NotSerialized)
{
Or (SFLG, 0x20, SFLG)
}
Method (PSE3, 0, NotSerialized)
{
If (And (SFLG, 0x10))
{
LED (0x03, 0x00)
}
}
Name (SHDE, 0x00)
Method (WSDK, 0, NotSerialized)
{
If (And (SFLG, Or (0x10, 0x20)))
{
SDCK (0x01)
If (\W98F)
{
Or (SFLG, 0x0200, SFLG)
Store (0x05, SHDE)
}
}
Else
{
Notify (\_SB.GDCK, 0x00)
}
}
Method (HIDS, 1, NotSerialized)
{
Store (Arg0, Local0)
If (And (SFLG, 0x0200))
{
If (LEqual (Arg0, 0x0F))
{
If (\W98F)
{
Store (0x0C, Local0)
}
Decrement (SHDE)
If (LNot (SHDE))
{
And (SFLG, Not (0x0200), SFLG)
Notify (\_SB.GDCK, 0x00)
}
}
Else
{
And (SFLG, Not (0x0200), SFLG)
}
}
Return (Local0)
}
Method (SUDK, 0, NotSerialized)
{
If (And (SFLG, 0x08))
{
If (LNot (And (SFLG, 0x0100)))
{
Or (SHKE, 0x2004, SHKE)
If (LEqual (\UOPT, 0x00))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (SHKE)
}
If (\W98F)
{
Notify (\_SB.GDCK, 0x01)
}
Else
{
Notify (\_SB.GDCK, 0x03)
}
And (SFLG, Not (0x08), SFLG)
}
}
}
Method (SUDI, 0, NotSerialized)
{
If (\WNTF)
{
Store (0x01, SUCT)
}
Else
{
Store (0x05, SUCT)
}
}
Method (SUDT, 0, NotSerialized)
{
If (And (SHKE, 0x2004))
{
If (LEqual (GSID (), 0x00))
{
If (LNot (Decrement (SUCT)))
{
Store (0x00, SHKE)
If (LEqual (\UOPT, 0x00))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x4003)
}
}
}
}
}
Method (GSID, 0, NotSerialized)
{
If (LEqual (SLID, 0xFFFFFFFF))
{
Store (0xFFFFFFFF, \_SB.GDCK.G_ID)
If (LEqual (\_SB.GDCK.GGID (), 0x03))
{
Store (0x03, SLID)
}
Else
{
Store (0x00, SLID)
}
}
Return (SLID)
}
Method (SPEJ, 0, NotSerialized)
{
LED (0x03, 0x00)
Sleep (0xC8)
LED (0x03, 0x80)
Sleep (0xC8)
LED (0x03, 0x00)
Sleep (0xC8)
LED (0x03, 0x80)
Sleep (0xC8)
LED (0x03, 0x00)
Sleep (0xC8)
LED (0x03, 0x80)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (RPTS, 1, NotSerialized)
{
Noop
}
Method (RWAK, 1, NotSerialized)
{
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q43, 0, NotSerialized) // _Qxx: EC Query
{
\UCMS (0x18)
}
Method (SAUM, 1, NotSerialized)
{
If (LGreater (Arg0, 0x03))
{
Noop
}
Else
{
If (\H8DR)
{
Store (Arg0, HAUM)
}
Else
{
\MBEC (0x03, 0x9F, ShiftLeft (Arg0, 0x05))
}
}
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Name (BRTB, Package (0x02)
{
Package (0x10)
{
0x27,
0x36,
0x48,
0x56,
0x64,
0x70,
0x7C,
0x87,
0x93,
0x9F,
0xAB,
0xBA,
0xC9,
0xD9,
0xEE,
0xFF
},
Package (0x10)
{
0x27,
0x34,
0x3E,
0x48,
0x52,
0x5B,
0x64,
0x6D,
0x77,
0x7F,
0x88,
0x90,
0x98,
0xA0,
0xA9,
0xB2
}
})
Name (BRTF, 0x01)
Method (_Q14, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x8000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1010)
}
If (\NBCF)
{
If (\VIGD)
{
Notify (\_SB.PCI0.VID.LCD0, 0x86)
}
Else
{
Notify (\_SB.PCI0.AGP.VID.LCD0, 0x86)
}
}
Else
{
If (\VIGD)
{
Store (\UCMS (0x15), \BRLV)
Store (\BRLV, Local0)
If (LNotEqual (Local0, 0x0F))
{
Increment (Local0)
Store (Local0, \BRLV)
}
\_SB.PCI0.LPC.EC.BRNS ()
\UCMS (0x16)
}
Else
{
\UCMS (0x04)
}
}
}
Method (_Q15, 0, NotSerialized) // _Qxx: EC Query
{
If (\VCDB)
{
Store (0x00, \VCDB)
Store (\UCMS (0x15), \BRLV)
\_SB.PCI0.LPC.EC.BRNS ()
\UCMS (0x16)
Return (0x00)
}
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00010000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1011)
}
If (\NBCF)
{
If (\VIGD)
{
Notify (\_SB.PCI0.VID.LCD0, 0x87)
}
Else
{
Notify (\_SB.PCI0.AGP.VID.LCD0, 0x87)
}
}
Else
{
If (\VIGD)
{
Store (\UCMS (0x15), \BRLV)
Store (\BRLV, Local0)
If (Local0)
{
Decrement (Local0)
Store (Local0, \BRLV)
}
\_SB.PCI0.LPC.EC.BRNS ()
\UCMS (0x16)
}
Else
{
\UCMS (0x05)
}
}
}
Method (BRNS, 0, NotSerialized)
{
Store (\BRLV, Local0)
Store (0x00, Local1)
If (\BRHB)
{
If (LNot (\_SB.PCI0.LPC.EC.AC._PSR ()))
{
Store (0x01, Local1)
}
}
Store (DerefOf (Index (DerefOf (Index (BRTB, Local1)), Local0)),
Local2)
\_SB.PCI0.VID.AINT (0x01, Local2)
}
Method (BRTO, 1, NotSerialized)
{
If (BRTF)
{
Store (Arg0, Local0)
While (LGreater (Local0, 0x01))
{
If (LEqual (\BRFQ, 0x01))
{
Sleep (0x64)
Decrement (Local0)
}
Else
{
If (LEqual (\BRFQ, 0x03))
{
Sleep (0x64)
Decrement (Local0)
}
Else
{
Store (0x00, Local0)
}
}
}
}
}
Method (BRTT, 0, NotSerialized)
{
If (\VIGD)
{
Store (\BRLV, Local0)
If (LEqual (Local0, 0x00))
{
If (LNotEqual (\BRFQ, 0x02))
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x080C))
{
Store (0x01, \BRFQ)
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5010)
}
}
}
Else
{
If (LNotEqual (\BRFQ, 0x00))
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x080C))
{
Store (0x03, \BRFQ)
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5010)
}
}
}
}
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q19, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00800000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1018)
}
\UCMS (0x03)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q63, 0, NotSerialized) // _Qxx: EC Query
{
If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00080000))
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1014)
}
\UCMS (0x0B)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q70, 0, NotSerialized) // _Qxx: EC Query
{
FNST ()
}
Method (_Q72, 0, NotSerialized) // _Qxx: EC Query
{
FNST ()
}
Method (_Q73, 0, NotSerialized) // _Qxx: EC Query
{
FNST ()
}
Method (FNST, 0, NotSerialized)
{
If (\H8DR)
{
Store (HFNS, Local0)
Store (HFNE, Local1)
}
Else
{
And (\RBEC (0x0E), 0x03, Local0)
And (\RBEC (0x00), 0x08, Local1)
}
If (Local1)
{
If (LEqual (Local0, 0x00))
{
\UCMS (0x11)
}
If (LEqual (Local0, 0x01))
{
\UCMS (0x0F)
}
If (LEqual (Local0, 0x02))
{
\UCMS (0x10)
}
}
}
}
Scope (\_SB.PCI0.LPC.EC.HKEY)
{
Name (WGFL, 0x00)
Method (WLSW, 0, NotSerialized)
{
Return (\_SB.PCI0.LPC.EC.GSTS)
}
Method (GWAN, 0, NotSerialized)
{
Store (0x00, Local0)
If (And (WGFL, 0x01))
{
Or (Local0, 0x01, Local0)
}
If (And (WGFL, 0x08))
{
Return (Local0)
}
If (WPWS ())
{
Or (Local0, 0x02, Local0)
}
If (And (WGFL, 0x04))
{
Or (Local0, 0x04, Local0)
}
Return (Local0)
}
Method (SWAN, 1, NotSerialized)
{
If (And (Arg0, 0x02))
{
WPWC (0x01)
}
Else
{
WPWC (0x00)
}
If (And (Arg0, 0x04))
{
Or (WGFL, 0x04, WGFL)
\WGSV (0x02)
}
Else
{
And (WGFL, Not (0x04), WGFL)
\WGSV (0x03)
}
}
Method (GBDC, 0, NotSerialized)
{
Store (0x00, Local0)
If (And (WGFL, 0x10))
{
Or (Local0, 0x01, Local0)
}
If (And (WGFL, 0x80))
{
Return (Local0)
}
If (BPWS ())
{
Or (Local0, 0x02, Local0)
}
If (And (WGFL, 0x40))
{
Or (Local0, 0x04, Local0)
}
Return (Local0)
}
Method (SBDC, 1, NotSerialized)
{
If (And (Arg0, 0x02))
{
BPWC (0x01)
}
Else
{
BPWC (0x00)
}
If (And (Arg0, 0x04))
{
Or (WGFL, 0x40, WGFL)
\BLTH (0x02)
}
Else
{
And (WGFL, Not (0x40), WGFL)
\BLTH (0x03)
}
}
Method (WPWS, 0, NotSerialized)
{
If (\H8DR)
{
Store (\_SB.PCI0.LPC.EC.DCWW, Local0)
}
Else
{
Store (ShiftRight (And (\RBEC (0x3A), 0x40), 0x06), Local0)
}
Return (Local0)
}
Method (WTGL, 0, NotSerialized)
{
If (And (WGFL, 0x01))
{
WPWC (LNot (WPWS ()))
}
}
Method (WPWC, 1, NotSerialized)
{
If (LAnd (Arg0, LAnd (And (WGFL, 0x01), LNot (And (
WGFL, 0x08)))))
{
If (\H8DR)
{
Store (One, \_SB.PCI0.LPC.EC.DCWW)
}
Else
{
\MBEC (0x3A, 0xFF, 0x40)
}
Or (WGFL, 0x02, WGFL)
}
Else
{
If (\H8DR)
{
Store (Zero, \_SB.PCI0.LPC.EC.DCWW)
}
Else
{
\MBEC (0x3A, 0xBF, 0x00)
}
And (WGFL, Not (0x02), WGFL)
}
}
Method (BPWS, 0, NotSerialized)
{
If (\H8DR)
{
Store (\_SB.PCI0.LPC.EC.DCBD, Local0)
}
Else
{
Store (ShiftRight (And (\RBEC (0x3A), 0x10), 0x04), Local0)
}
Return (Local0)
}
Method (BTGL, 0, NotSerialized)
{
If (And (WGFL, 0x10))
{
BPWC (LNot (BPWS ()))
}
}
Method (BPWC, 1, NotSerialized)
{
If (LAnd (Arg0, LAnd (And (WGFL, 0x10), LNot (And (
WGFL, 0x80)))))
{
If (\H8DR)
{
Store (One, \_SB.PCI0.LPC.EC.DCBD)
}
Else
{
\MBEC (0x3A, 0xFF, 0x10)
}
Or (WGFL, 0x20, WGFL)
}
Else
{
If (\H8DR)
{
Store (Zero, \_SB.PCI0.LPC.EC.DCBD)
}
Else
{
\MBEC (0x3A, 0xEF, 0x00)
}
And (WGFL, Not (0x20), WGFL)
}
}
Method (WGIN, 0, NotSerialized)
{
Store (0x00, WGFL)
Store (\WGSV (0x01), WGFL)
If (WPWS ())
{
Or (WGFL, 0x02, WGFL)
}
If (BPWS ())
{
Or (WGFL, 0x20, WGFL)
}
}
Method (WGPS, 1, NotSerialized)
{
If (LGreaterEqual (Arg0, 0x04))
{
\BLTH (0x05)
}
If (LNot (And (WGFL, 0x04)))
{
WPWC (0x00)
}
If (LNot (And (WGFL, 0x40)))
{
BPWC (0x00)
}
}
Method (WGWK, 1, NotSerialized)
{
If (And (WGFL, 0x20))
{
BPWC (0x01)
}
If (And (WGFL, 0x02))
{
WPWC (0x01)
}
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q41, 0, NotSerialized) // _Qxx: EC Query
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x7000)
}
}
}
Scope (\_SB.PCI0.IDE0.PRIM)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.LPC.EC.BAT1)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.USB4.URTH.UPDK)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Scope (\_SB.PCI0.EHC1.URTH.UPDK)
{
Name (_EJD, "_SB.GDCK") // _EJD: Ejection Dependent Device
}
Name (\_S0, Package (0x04) // _S0_: S0 System State
{
0x00,
0x00,
0x00,
0x00
})
Name (\_S3, Package (0x04) // _S3_: S3 System State
{
0x05,
0x05,
0x00,
0x00
})
Name (\_S4, Package (0x04) // _S4_: S4 System State
{
0x06,
0x06,
0x00,
0x00
})
Name (\_S5, Package (0x04) // _S5_: S5 System State
{
0x07,
0x07,
0x00,
0x00
})
Method (\_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep
{
Store (0x01, Local0)
If (LEqual (Arg0, \SPS))
{
Store (0x00, Local0)
}
If (LOr (LEqual (Arg0, 0x00), LGreaterEqual (Arg0, 0x06)))
{
Store (0x00, Local0)
}
If (Local0)
{
Store (Arg0, \SPS)
\_SB.PCI0.LPC.EC.HKEY.MHKE (0x00)
If (\_SB.PCI0.LPC.EC.KBLT)
{
\UCMS (0x0D)
}
If (LEqual (Arg0, 0x01))
{
Store (\_SB.PCI0.LPC.EC.HFNI, \FNID)
Store (0x00, \_SB.PCI0.LPC.EC.HFNI)
Store (0x00, \_SB.PCI0.LPC.EC.HFSP)
}
If (LEqual (Arg0, 0x03))
{
\VVPD (0x03)
\TRAP ()
Store (\_SB.PCI0.LPC.EC.AC._PSR (), \ACST)
}
If (LEqual (Arg0, 0x04))
{
\_SB.SLPB._PSW (0x00)
If (\SPEN)
{
\STEP (0x07)
}
\TRAP ()
}
If (LEqual (Arg0, 0x05))
{
\TRAP ()
}
\_SB.PCI0.LPC.EC.BPTS (Arg0)
If (LGreaterEqual (Arg0, 0x04))
{
Store (0x00, \_SB.PCI0.LPC.EC.HWLB)
}
Else
{
Store (0x01, \_SB.PCI0.LPC.EC.HWLB)
}
If (LNotEqual (Arg0, 0x05))
{
Store (0x01, \_SB.PCI0.LPC.EC.HCMU)
\_SB.GDCK.GPTS (Arg0)
If (\W98F)
{
\CBRI ()
}
}
\_SB.PCI0.LPC.EC.HKEY.WGPS (Arg0)
}
}
Name (WAKI, Package (0x02)
{
0x00,
0x00
})
Method (\_WAK, 1, NotSerialized) // _WAK: Wake
{
If (LOr (LEqual (Arg0, 0x00), LGreaterEqual (Arg0, 0x05)))
{
Return (WAKI)
}
Store (0x00, \SPS)
Store (0x00, \_SB.PCI0.LPC.EC.HCMU)
Store (0x80, \_SB.PCI0.LPC.EC.HFSP)
\_SB.PCI0.LPC.EC.EVNT (0x01)
\_SB.PCI0.LPC.EC.HKEY.MHKE (0x01)
\_SB.PCI0.LPC.EC.FNST ()
\UCMS (0x0D)
Store (0x00, \LIDB)
\_SB.PCI0.IGBE.ABWA (0x00)
If (LEqual (Arg0, 0x01))
{
Store (\_SB.PCI0.LPC.EC.HFNI, \FNID)
}
If (LEqual (Arg0, 0x03))
{
THRM (0x00)
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHC4))
{
If (\_SB.PCI0.LPC.EC.AC._PSR ())
{
Store (0x00, \C4AC)
}
Else
{
Store (0x01, \C4AC)
}
}
If (\OSC4)
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
Else
{
If (\WNTF)
{
If (\_SB.PCI0.LPC.EC.HKEY.CKC4 (0x00))
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
}
Else
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
}
If (LNotEqual (\ACST, \_SB.PCI0.LPC.EC.AC._PSR ()))
{
\_SB.PCI0.LPC.EC.ATMC ()
}
If (LAnd (\WXPF, LGreaterEqual (\WSPV, 0x01)))
{
PPMS (0x02)
}
If (LAnd (And (\CFGD, 0x01000000), LAnd (\WXPF, LLessEqual (
\WSPV, 0x01))))
{
If (And (\CFGD, 0xF0))
{
PPMS (0x00)
}
}
If (\VIGD)
{
\_SB.PCI0.VID.GLIS (\_SB.LID._LID ())
Store (\_SB.GDCK.GGID (), Local0)
If (LOr (LEqual (Local0, 0x00), LEqual (Local0, 0x01)))
{
\_SB.PCI0.VID.GDCS (0x01)
}
Else
{
\_SB.PCI0.VID.GDCS (0x00)
}
If (\WVIS)
{
\VBTD ()
}
}
}
If (LEqual (Arg0, 0x04))
{
\NVSS (0x00)
If (DTSE)
{
THRM (0x02)
}
If (\W98F)
{
Notify (\_SB.SLPB, 0x02)
}
If (\WMEF)
{
\_SB.PCI0.LPC.EC.BEEP (0x05)
}
If (LNot (\W98F))
{
Store (0x00, \_SB.PCI0.LPC.EC.HSPA)
}
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHC4))
{
If (\_SB.PCI0.LPC.EC.AC._PSR ())
{
Store (0x00, \C4AC)
}
Else
{
Store (0x01, \C4AC)
}
}
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
Else
{
If (\WNTF)
{
If (\_SB.PCI0.LPC.EC.HKEY.CKC4 (0x00))
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
}
Else
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
}
If (\SPEN)
{
\STEP (0x08)
}
\_SB.PCI0.LPC.EC.ATMC ()
If (LAnd (And (\CFGD, 0x01000000), LAnd (\WXPF, LLessEqual (
\WSPV, 0x01))))
{
If (And (\CFGD, 0xF0))
{
PPMS (0x00)
}
}
}
If (XOr (\_SB.PCI0.EXP3.PDS, \_SB.PCI0.EXP3.XCPF))
{
If (\_SB.PCI0.EXP3.PDS)
{
Store (0x01, \_SB.PCI0.EXP3.XCPF)
}
Else
{
Store (0x00, \_SB.PCI0.EXP3.XCPF)
}
Notify (\_SB.PCI0.EXP3, 0x00)
}
\_SB.GDCK.GWAK (Arg0)
If (LEqual (\_SB.PCI0.LPC.EC.GSID (), 0x03))
{
\_SB.PCI0.LPC.EC.BWAK (Arg0)
}
\_SB.PCI0.LPC.EC.HKEY.WGWK (Arg0)
Notify (\_TZ.THM0, 0x80)
Notify (\_TZ.THM1, 0x80)
\VSLD (\_SB.LID._LID ())
If (\VIGD)
{
\_SB.PCI0.VID.GLIS (\_SB.LID._LID ())
}
If (LAnd (\W98F, LNot (\WMEF)))
{
Notify (\_SB.PCI0.USB0, 0x00)
Notify (\_SB.PCI0.USB1, 0x00)
}
If (LLess (Arg0, 0x04))
{
If (And (\RRBF, 0x02))
{
ShiftLeft (Arg0, 0x08, Local0)
Store (Or (0x2013, Local0), Local0)
\_SB.PCI0.LPC.EC.HKEY.MHKQ (Local0)
}
}
If (LEqual (Arg0, 0x04))
{
Store (0x00, Local0)
Store (\CSUM (0x00), Local1)
If (LNotEqual (Local1, \CHKC))
{
Store (0x01, Local0)
Store (Local1, \CHKC)
}
Store (\CSUM (0x01), Local1)
If (LNotEqual (Local1, \CHKE))
{
Store (0x01, Local0)
Store (Local1, \CHKE)
}
If (Local0)
{
Notify (\_SB, 0x00)
}
}
Store (Zero, \RRBF)
Return (WAKI)
}
Scope (\_SI)
{
Method (_SST, 1, NotSerialized) // _SST: System Status
{
If (LEqual (Arg0, 0x00))
{
\_SB.PCI0.LPC.EC.LED (0x00, 0x00)
\_SB.PCI0.LPC.EC.LED (0x07, 0x00)
}
If (LEqual (Arg0, 0x01))
{
If (LOr (\SPS, \WNTF))
{
\_SB.PCI0.LPC.EC.BEEP (0x05)
}
\_SB.PCI0.LPC.EC.LED (0x00, 0x80)
\_SB.PCI0.LPC.EC.LED (0x07, 0x00)
}
If (LEqual (Arg0, 0x02))
{
\_SB.PCI0.LPC.EC.LED (0x00, 0x80)
\_SB.PCI0.LPC.EC.LED (0x07, 0xC0)
}
If (LEqual (Arg0, 0x03))
{
If (LGreater (\SPS, 0x03))
{
\_SB.PCI0.LPC.EC.BEEP (0x07)
}
Else
{
If (LEqual (\SPS, 0x03))
{
\_SB.PCI0.LPC.EC.BEEP (0x03)
\_SB.GDCK.PEJ3 ()
}
Else
{
\_SB.PCI0.LPC.EC.BEEP (0x04)
}
}
If (LEqual (\SPS, 0x03)) {}
Else
{
\_SB.PCI0.LPC.EC.LED (0x00, 0x80)
}
\_SB.PCI0.LPC.EC.LED (0x07, 0xC0)
}
If (LEqual (Arg0, 0x04))
{
\_SB.PCI0.LPC.EC.BEEP (0x03)
\_SB.PCI0.LPC.EC.LED (0x07, 0xC0)
}
}
}
Scope (\_GPE)
{
Method (_L18, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Store (\_SB.PCI0.LPC.EC.HWAK, Local0)
Store (Local0, \RRBF)
Sleep (0x0A)
If (And (Local0, 0x02)) {}
If (And (Local0, 0x04))
{
If (\W98F)
{
Notify (\_SB.SLPB, 0x02)
}
Else
{
Notify (\_SB.LID, 0x02)
}
}
If (And (Local0, 0x10))
{
And (Local0, 0xF7, Local0)
Notify (\_SB.SLPB, 0x02)
}
If (And (Local0, 0x08))
{
\_SB.GDCK.GGPE ()
Notify (\_SB.SLPB, 0x02)
}
If (And (Local0, 0x10))
{
Notify (\_SB.SLPB, 0x02)
}
If (And (Local0, 0x40)) {}
If (And (Local0, 0x80))
{
Notify (\_SB.SLPB, 0x02)
}
}
Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
If (\_SB.PCI0.EXP0.PSP0)
{
Store (0x01, \_SB.PCI0.EXP0.PSP0)
Notify (\_SB.PCI0.EXP0, 0x02)
}
If (\_SB.PCI0.EXP1.PSP1)
{
Store (0x01, \_SB.PCI0.EXP1.PSP1)
Notify (\_SB.PCI0.EXP1, 0x02)
}
If (\_SB.PCI0.EXP2.PSP2)
{
Store (0x01, \_SB.PCI0.EXP2.PSP2)
Notify (\_SB.PCI0.EXP2, 0x02)
}
If (\_SB.PCI0.EXP3.PSP3)
{
Store (0x01, \_SB.PCI0.EXP3.PSP3)
Store (0x01, \_SB.PCI0.EXP3.PMCS)
Notify (\_SB.PCI0.EXP3, 0x02)
}
If (\_SB.PCI0.EXP4.PSP4)
{
Store (0x01, \_SB.PCI0.EXP4.PSP4)
Store (0x01, \_SB.PCI0.EXP4.PMS4)
Notify (\_SB.PCI0.EXP4, 0x02)
}
}
Method (_L01, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
If (\_SB.PCI0.EXP3.HPCS)
{
Store (0x01, \_SB.PCI0.EXP3.HPCS)
If (\_SB.PCI0.EXP3.ABP)
{
Store (0x01, \_SB.PCI0.EXP3.ABP)
}
If (\_SB.PCI0.EXP3.PDC)
{
Store (0x01, \_SB.PCI0.EXP3.PDC)
Store (0x00, \_SB.PCI0.EXP3.XCPF)
Notify (\_SB.PCI0.EXP3, 0x00)
If (\_SB.PCI0.EXP3.PDS)
{
Store (0x01, \_SB.PCI0.EXP3.XCPF)
Sleep (0x64)
Notify (\_SB.PCI0.EXP3.EXUP, 0x01)
}
}
}
}
Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
Store (0x00, \_SB.PCI0.LPC.SWGE)
If (And (\SWGP, 0x01))
{
And (\SWGP, Not (0x01), \SWGP)
If (\_SB.PCI0.LPC.EC.HKEY.DHKC)
{
If (DT02)
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6022)
}
}
Notify (\_TZ.THM1, 0x80)
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
If (DT00)
{
\STEP (0x09)
}
Else
{
\STEP (0x0A)
}
}
}
}
If (LAnd (\CWUE, And (\SWGP, 0x02)))
{
And (\SWGP, Not (0x02), \SWGP)
If (\OSC4)
{
Notify (\_PR.CPU0, 0x81)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x81)
}
}
Else
{
If (\_SB.PCI0.LPC.EC.HKEY.CKC4 (0x00))
{
Store (0x00, \_SB.PCI0.LPC.C4C3)
}
Else
{
Store (0x01, \_SB.PCI0.LPC.C4C3)
}
}
}
}
Method (_L06, 0, NotSerialized) // _Lxx: Level-Triggered GPE
{
If (\_SB.PCI0.VID.GSSE)
{
\_SB.PCI0.VID.OPRN ()
}
Else
{
Store (0x01, \_SB.PCI0.LPC.SCIS)
}
}
}
Scope (\_SB.PCI0.LPC.EC.HKEY)
{
Method (MHQT, 1, NotSerialized)
{
If (LAnd (\WNTF, \TATC))
{
If (LEqual (Arg0, 0x00))
{
Store (\TATC, Local0)
Return (Local0)
}
Else
{
If (LEqual (Arg0, 0x01))
{
Store (\TDFA, Local0)
Add (Local0, ShiftLeft (\TDTA, 0x04), Local0)
Add (Local0, ShiftLeft (\TDFD, 0x08), Local0)
Add (Local0, ShiftLeft (\TDTD, 0x0C), Local0)
Add (Local0, ShiftLeft (\TNFT, 0x10), Local0)
Add (Local0, ShiftLeft (\TNTT, 0x14), Local0)
Return (Local0)
}
Else
{
If (LEqual (Arg0, 0x02))
{
Store (\TCFA, Local0)
Add (Local0, ShiftLeft (\TCTA, 0x04), Local0)
Add (Local0, ShiftLeft (\TCFD, 0x08), Local0)
Add (Local0, ShiftLeft (\TCTD, 0x0C), Local0)
Return (Local0)
}
Else
{
If (LEqual (Arg0, 0x03)) {}
Else
{
If (LEqual (Arg0, 0x04))
{
Store (\TATW, Local0)
Return (Local0)
}
Else
{
Noop
}
}
}
}
}
}
Return (0x00)
}
Method (MHAT, 1, NotSerialized)
{
If (LAnd (\WNTF, \TATC))
{
Store (And (Arg0, 0xFF), Local0)
If (LNot (ATMV (Local0)))
{
Return (0x00)
}
Store (And (ShiftRight (Arg0, 0x08), 0xFF), Local0)
If (LNot (ATMV (Local0)))
{
Return (0x00)
}
Store (And (Arg0, 0x0F), \TCFA)
Store (And (ShiftRight (Arg0, 0x04), 0x0F), \TCTA)
Store (And (ShiftRight (Arg0, 0x08), 0x0F), \TCFD)
Store (And (ShiftRight (Arg0, 0x0C), 0x0F), \TCTD)
ATMC ()
Return (0x01)
}
Return (0x00)
}
Method (MHGT, 1, NotSerialized)
{
If (LAnd (\WNTF, \TATC))
{
Store (ShiftLeft (\TSFT, 0x10), Local0)
Add (Local0, ShiftLeft (\TSTT, 0x14), Local0)
Store (And (Arg0, 0xFF), Local1)
If (LNot (ATMV (Local1)))
{
Return (0xFFFF)
}
Store (And (Arg0, 0x0F), Local1)
If (LEqual (Local1, 0x00))
{
Add (Local0, \TIF0, Local0)
}
Else
{
If (LEqual (Local1, 0x01))
{
Add (Local0, \TIF1, Local0)
}
Else
{
If (LEqual (Local1, 0x02))
{
Add (Local0, \TIF2, Local0)
}
Else
{
Add (Local0, 0xFF, Local0)
}
}
}
Store (And (ShiftRight (Arg0, 0x04), 0x0F), Local1)
If (LEqual (Local1, 0x00))
{
Add (Local0, ShiftLeft (\TIT0, 0x08), Local0)
}
Else
{
If (LEqual (Local1, 0x01))
{
Add (Local0, ShiftLeft (\TIT1, 0x08), Local0)
}
Else
{
If (LEqual (Local1, 0x02))
{
Add (Local0, ShiftLeft (\TIT2, 0x08), Local0)
}
Else
{
Add (Local0, ShiftLeft (0xFF, 0x08), Local0)
}
}
}
Return (Local0)
}
Return (0x00)
}
Method (ATMV, 1, NotSerialized)
{
Store (And (Arg0, 0x0F), Local1)
Store (\TNFT, Local0)
If (LGreaterEqual (Local1, Local0))
{
Return (0x00)
}
Store (And (ShiftRight (Arg0, 0x04), 0x0F), Local2)
Store (\TNTT, Local0)
If (LGreaterEqual (Local2, Local0))
{
Return (0x00)
}
If (\TATL)
{
If (XOr (Local1, Local2))
{
Return (0x00)
}
}
Return (0x01)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (ATMC, 0, NotSerialized)
{
If (LAnd (\WNTF, \TATC))
{
If (HPAC)
{
Store (\TCFA, Local0)
Store (\TCTA, Local1)
Store (Or (ShiftLeft (Local1, 0x04), Local0), ATMX)
If (LEqual (\TCTA, 0x00))
{
Store (\TCR0, \TCRT)
Store (\TPS0, \TPSV)
}
Else
{
If (LEqual (\TCTA, 0x01))
{
Store (\TCR1, \TCRT)
Store (\TPS1, \TPSV)
}
Else
{
}
}
}
Else
{
Store (\TCFD, Local0)
Store (\TCTD, Local1)
Store (Or (ShiftLeft (Local1, 0x04), Local0), ATMX)
If (LEqual (\TCTD, 0x00))
{
Store (\TCR0, \TCRT)
Store (\TPS0, \TPSV)
}
Else
{
If (LEqual (\TCTD, 0x01))
{
Store (\TCR1, \TCRT)
Store (\TPS1, \TPSV)
}
Else
{
}
}
}
Notify (\_TZ.THM0, 0x81)
THRM (0x01)
}
}
}
Scope (\_TZ)
{
ThermalZone (THM0)
{
Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature
{
Return (C2K (0x7F))
}
Method (_TMP, 0, NotSerialized) // _TMP: Temperature
{
If (\H8DR)
{
Store (\_SB.PCI0.LPC.EC.TMP0, Local0)
Store (\_SB.PCI0.LPC.EC.HT12, Local1)
Store (\_SB.PCI0.LPC.EC.HT13, Local2)
}
Else
{
Store (\RBEC (0x78), Local0)
Store (And (\RBEC (0x20), 0x40), Local1)
Store (And (\RBEC (0x20), 0x80), Local2)
}
If (Local2)
{
Return (C2K (0x80))
}
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHKC))
{
If (Local1)
{
Return (C2K (0x80))
}
}
Return (C2K (Local0))
}
}
ThermalZone (THM1)
{
Method (_PSL, 0, NotSerialized) // _PSL: Passive List
{
If (\MPEN)
{
Return (Package (0x02)
{
\_PR.CPU0,
\_PR.CPU1
})
}
Return (Package (0x01)
{
\_PR.CPU0
})
}
Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature
{
Return (\TCRT)
}
Method (_PSV, 0, NotSerialized) // _PSV: Passive Temperature
{
Return (\TPSV)
}
Method (_TC1, 0, NotSerialized) // _TC1: Thermal Constant 1
{
Return (\TTC1)
}
Method (_TC2, 0, NotSerialized) // _TC2: Thermal Constant 2
{
Return (\TTC2)
}
Method (_TSP, 0, NotSerialized) // _TSP: Thermal Sampling Period
{
Return (\TTSP)
}
Method (_TMP, 0, NotSerialized) // _TMP: Temperature
{
If (\DTSE)
{
THRM (0x02)
Store (DTS1, Local0)
If (LGreaterEqual (DTS0, DTS1))
{
Store (DTS0, Local0)
}
If (LNot (\_SB.PCI0.LPC.EC.HKEY.DHKC))
{
If (DT02)
{
Add (\TCRT, 0x01, Local0)
Return (Local0)
}
}
Return (C2K (Local0))
}
Else
{
Return (\_TZ.THM0._TMP ())
}
}
}
Method (C2K, 1, NotSerialized)
{
Add (Multiply (Arg0, 0x0A), 0x0AAC, Local0)
If (LLessEqual (Local0, 0x0AAC))
{
Store (0x0BB8, Local0)
}
If (LGreater (Local0, 0x0FAC))
{
Store (0x0BB8, Local0)
}
Return (Local0)
}
}
Scope (\_SB.PCI0.LPC.EC)
{
Method (_Q40, 0, NotSerialized) // _Qxx: EC Query
{
Notify (\_TZ.THM0, 0x80)
If (\H8DR)
{
Store (\_SB.PCI0.LPC.EC.HT11, Local0)
Store (\_SB.PCI0.LPC.EC.HT12, Local1)
}
Else
{
Store (And (\RBEC (0x20), 0x20), Local0)
Store (And (\RBEC (0x20), 0x40), Local1)
}
If (\_SB.PCI0.LPC.EC.HKEY.DHKC)
{
If (Local1)
{
\_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6022)
}
}
If (VIGD)
{
Noop
}
Else
{
\VTHR ()
}
If (\SPEN)
{
If (\OSPX)
{
Notify (\_PR.CPU0, 0x80)
If (\MPEN)
{
Notify (\_PR.CPU1, 0x80)
}
}
Else
{
If (LOr (\_SB.PCI0.LPC.EC.HT00, \_SB.PCI0.LPC.EC.HT10))
{
\STEP (0x09)
}
Else
{
\STEP (0x0A)
}
}
}
}
}
Name (GPIC, 0x00)
Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model
{
Store (Arg0, \GPIC)
}
OperationRegion (SMI0, SystemIO, 0xB2, 0x01)
Field (SMI0, ByteAcc, NoLock, Preserve)
{
APMC, 8
}
Field (MNVS, AnyAcc, NoLock, Preserve)
{
Offset (0xFC0),
CMD, 8,
ERR, 32,
PAR0, 32,
PAR1, 32,
PAR2, 32,
PAR3, 32
}
Mutex (MSMI, 0x07)
Method (SMI, 5, NotSerialized)
{
Acquire (MSMI, 0xFFFF)
Store (Arg0, CMD)
Store (Arg1, PAR0)
Store (Arg2, PAR1)
Store (Arg3, PAR2)
Store (Arg4, PAR3)
Store (0xF5, APMC)
While (LEqual (ERR, 0x01))
{
Sleep (0x64)
Store (0xF5, APMC)
}
Store (PAR0, Local0)
Release (MSMI)
Return (Local0)
}
Method (RPCI, 1, NotSerialized)
{
Return (SMI (0x00, 0x00, Arg0, 0x00, 0x00))
}
Method (WPCI, 2, NotSerialized)
{
SMI (0x00, 0x01, Arg0, Arg1, 0x00)
}
Method (MPCI, 3, NotSerialized)
{
SMI (0x00, 0x02, Arg0, Arg1, Arg2)
}
Method (RBEC, 1, NotSerialized)
{
Return (SMI (0x00, 0x03, Arg0, 0x00, 0x00))
}
Method (WBEC, 2, NotSerialized)
{
SMI (0x00, 0x04, Arg0, Arg1, 0x00)
}
Method (MBEC, 3, NotSerialized)
{
SMI (0x00, 0x05, Arg0, Arg1, Arg2)
}
Method (RISA, 1, NotSerialized)
{
Return (SMI (0x00, 0x06, Arg0, 0x00, 0x00))
}
Method (WISA, 2, NotSerialized)
{
SMI (0x00, 0x07, Arg0, Arg1, 0x00)
}
Method (MISA, 3, NotSerialized)
{
SMI (0x00, 0x08, Arg0, Arg1, Arg2)
}
Method (VEXP, 0, NotSerialized)
{
SMI (0x01, 0x00, 0x00, 0x00, 0x00)
}
Method (VUPS, 1, NotSerialized)
{
SMI (0x01, 0x01, Arg0, 0x00, 0x00)
}
Method (VSDS, 2, NotSerialized)
{
SMI (0x01, 0x02, Arg0, Arg1, 0x00)
}
Method (VDDC, 0, NotSerialized)
{
SMI (0x01, 0x03, 0x00, 0x00, 0x00)
}
Method (VVPD, 1, NotSerialized)
{
SMI (0x01, 0x04, Arg0, 0x00, 0x00)
}
Method (VNRS, 1, NotSerialized)
{
SMI (0x01, 0x05, Arg0, 0x00, 0x00)
}
Method (GLPW, 0, NotSerialized)
{
Return (SMI (0x01, 0x06, 0x00, 0x00, 0x00))
}
Method (VSLD, 1, NotSerialized)
{
SMI (0x01, 0x07, Arg0, 0x00, 0x00)
}
Method (VEVT, 1, NotSerialized)
{
Return (SMI (0x01, 0x08, Arg0, 0x00, 0x00))
}
Method (VTHR, 0, NotSerialized)
{
Return (SMI (0x01, 0x09, 0x00, 0x00, 0x00))
}
Method (VBRC, 1, NotSerialized)
{
SMI (0x01, 0x0A, Arg0, 0x00, 0x00)
}
Method (VBRG, 0, NotSerialized)
{
Return (SMI (0x01, 0x0E, 0x00, 0x00, 0x00))
}
Method (VBTD, 0, NotSerialized)
{
Return (SMI (0x01, 0x0F, 0x00, 0x00, 0x00))
}
Method (UCMS, 1, NotSerialized)
{
Return (SMI (0x02, Arg0, 0x00, 0x00, 0x00))
}
Method (BHDP, 2, NotSerialized)
{
Return (SMI (0x03, 0x00, Arg0, Arg1, 0x00))
}
Method (DHDP, 1, NotSerialized)
{
Return (SMI (0x03, 0x01, Arg0, 0x00, 0x00))
}
Method (STEP, 1, NotSerialized)
{
SMI (0x04, Arg0, 0x00, 0x00, 0x00)
}
Method (TRAP, 0, NotSerialized)
{
SMI (0x05, 0x00, 0x00, 0x00, 0x00)
}
Method (CBRI, 0, NotSerialized)
{
SMI (0x05, 0x01, 0x00, 0x00, 0x00)
}
Method (ASSI, 1, NotSerialized)
{
SMI (0x05, 0x05, Arg0, 0x00, 0x00)
}
Method (HSWA, 1, NotSerialized)
{
If (LLessEqual (Arg0, 0x01))
{
Return (SMI (0x05, 0x04, Arg0, 0x00, 0x00))
}
Else
{
Return (0x01)
}
}
Method (ACBS, 1, NotSerialized)
{
Return (SMI (0x05, 0x06, Arg0, 0x00, 0x00))
}
Method (BLTH, 1, NotSerialized)
{
Return (SMI (0x06, Arg0, 0x00, 0x00, 0x00))
}
Method (FISP, 0, NotSerialized)
{
SMI (0x07, 0x00, 0x00, 0x00, 0x00)
}
Method (ATCC, 1, NotSerialized)
{
SMI (0x08, Arg0, 0x00, 0x00, 0x00)
}
Method (WGSV, 1, NotSerialized)
{
Return (SMI (0x09, Arg0, 0x00, 0x00, 0x00))
}
Method (THRM, 1, NotSerialized)
{
Return (SMI (0x0A, Arg0, 0x00, 0x00, 0x00))
}
Method (PPMS, 1, NotSerialized)
{
Return (SMI (0x0B, Arg0, 0x00, 0x00, 0x00))
}
Method (TPHY, 1, NotSerialized)
{
SMI (0x0C, Arg0, 0x00, 0x00, 0x00)
}
Method (CSUM, 1, NotSerialized)
{
Return (SMI (0x0E, Arg0, 0x00, 0x00, 0x00))
}
Method (NVSS, 1, NotSerialized)
{
Return (SMI (0x0F, Arg0, 0x00, 0x00, 0x00))
}
Method (DPIO, 2, NotSerialized)
{
If (LNot (Arg0))
{
Return (0x00)
}
If (LGreater (Arg0, 0xF0))
{
Return (0x00)
}
If (LGreater (Arg0, 0xB4))
{
If (Arg1)
{
Return (0x02)
}
Else
{
Return (0x01)
}
}
If (LGreater (Arg0, 0x78))
{
Return (0x03)
}
Return (0x04)
}
Method (DUDM, 2, NotSerialized)
{
If (LNot (Arg1))
{
Return (0xFF)
}
If (LGreater (Arg0, 0x5A))
{
Return (0x00)
}
If (LGreater (Arg0, 0x3C))
{
Return (0x01)
}
If (LGreater (Arg0, 0x2D))
{
Return (0x02)
}
If (LGreater (Arg0, 0x1E))
{
Return (0x03)
}
If (LGreater (Arg0, 0x14))
{
Return (0x04)
}
Return (0x05)
}
Method (DMDM, 2, NotSerialized)
{
If (Arg1)
{
Return (0x00)
}
If (LNot (Arg0))
{
Return (0x00)
}
If (LGreater (Arg0, 0x96))
{
Return (0x01)
}
If (LGreater (Arg0, 0x78))
{
Return (0x02)
}
Return (0x03)
}
Method (UUDM, 2, NotSerialized)
{
If (LNot (And (Arg0, 0x04)))
{
Return (0x00)
}
If (And (Arg1, 0x20))
{
Return (0x14)
}
If (And (Arg1, 0x10))
{
Return (0x1E)
}
If (And (Arg1, 0x08))
{
Return (0x2D)
}
If (And (Arg1, 0x04))
{
Return (0x3C)
}
If (And (Arg1, 0x02))
{
Return (0x5A)
}
If (And (Arg1, 0x01))
{
Return (0x78)
}
Return (0x00)
}
Method (UMDM, 4, NotSerialized)
{
If (LNot (And (Arg0, 0x02)))
{
Return (0x00)
}
If (And (Arg1, 0x04))
{
Return (Arg3)
}
If (And (Arg1, 0x02))
{
If (LLessEqual (Arg3, 0x78))
{
Return (0xB4)
}
Else
{
Return (Arg3)
}
}
If (And (Arg2, 0x04))
{
If (LLessEqual (Arg3, 0xB4))
{
Return (0xF0)
}
Else
{
Return (Arg3)
}
}
Return (0x00)
}
Method (UPIO, 4, NotSerialized)
{
If (LNot (And (Arg0, 0x02)))
{
If (LEqual (Arg2, 0x02))
{
Return (0xF0)
}
Else
{
Return (0x0384)
}
}
If (And (Arg1, 0x02))
{
Return (Arg3)
}
If (And (Arg1, 0x01))
{
If (LLessEqual (Arg3, 0x78))
{
Return (0xB4)
}
Else
{
Return (Arg3)
}
}
If (LEqual (Arg2, 0x02))
{
Return (0xF0)
}
Else
{
Return (0x0384)
}
}
Method (FDMA, 2, NotSerialized)
{
If (LNotEqual (Arg1, 0xFF))
{
Return (Or (Arg1, 0x40))
}
If (LGreaterEqual (Arg0, 0x03))
{
Return (Or (Subtract (Arg0, 0x02), 0x20))
}
If (Arg0)
{
Return (0x12)
}
Return (0x00)
}
Method (FPIO, 1, NotSerialized)
{
If (LGreaterEqual (Arg0, 0x03))
{
Return (Or (Arg0, 0x08))
}
If (LEqual (Arg0, 0x01))
{
Return (0x01)
}
Return (0x00)
}
Method (SCMP, 2, NotSerialized)
{
Store (SizeOf (Arg0), Local0)
If (LNotEqual (Local0, SizeOf (Arg1)))
{
Return (One)
}
Increment (Local0)
Name (STR1, Buffer (Local0) {})
Name (STR2, Buffer (Local0) {})
Store (Arg0, STR1)
Store (Arg1, STR2)
Store (Zero, Local1)
While (LLess (Local1, Local0))
{
Store (DerefOf (Index (STR1, Local1)), Local2)
Store (DerefOf (Index (STR2, Local1)), Local3)
If (LNotEqual (Local2, Local3))
{
Return (One)
}
Increment (Local1)
}
Return (Zero)
}
Name (SPS, 0x00)
Name (OSIF, 0x00)
Name (W98F, 0x00)
Name (WNTF, 0x00)
Name (WMEF, 0x00)
Name (WXPF, 0x00)
Name (WVIS, 0x00)
Name (WSPV, 0x00)
Name (LNUX, 0x00)
Name (H8DR, 0x00)
Name (MEMX, 0x00)
Name (ACST, 0x00)
Name (FNID, 0x00)
Name (RRBF, 0x00)
Name (NBCF, 0x00)
Scope (\)
{
Method (KOU2, 0, NotSerialized)
{
Stall (0x64)
}
}
Scope (\_SB.PCI0.VID.LCD0)
{
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels
{
Store (0x01, \NBCF)
Return (Package (0x12)
{
0x64,
0x64,
0x14,
0x19,
0x1E,
0x23,
0x28,
0x2D,
0x32,
0x37,
0x3C,
0x41,
0x46,
0x4B,
0x50,
0x55,
0x5A,
0x64
})
}
Name (BCLP, Package (0x10)
{
0x14,
0x19,
0x1E,
0x23,
0x28,
0x2D,
0x32,
0x37,
0x3C,
0x41,
0x46,
0x4B,
0x50,
0x55,
0x5A,
0x64
})
Name (BCLL, Package (0x10)
{
0x00,
0x01,
0x02,
0x03,
0x04,
0x05,
0x06,
0x07,
0x08,
0x09,
0x0A,
0x0B,
0x0C,
0x0D,
0x0E,
0x0F
})
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method
{
Store (Match (BCLP, MEQ, Arg0, MTR, 0x00, 0x00), Local0)
If (LNotEqual (Local0, Ones))
{
Store (DerefOf (Index (BCLL, Local0)), \BRLV)
\_SB.PCI0.LPC.EC.BRNS ()
\UCMS (0x16)
}
}
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current
{
Store (\BRLV, Local0)
If (LLessEqual (Local0, 0x0F))
{
Return (DerefOf (Index (BCLP, Local0)))
}
Else
{
Return (Zero)
}
}
}
Scope (\_SB.PCI0.AGP.VID.LCD0)
{
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels
{
Store (0x01, NBCF)
Return (Package (0x12)
{
0x64,
0x64,
0x14,
0x19,
0x1E,
0x23,
0x28,
0x2D,
0x32,
0x37,
0x3C,
0x41,
0x46,
0x4B,
0x50,
0x55,
0x5A,
0x64
})
}
Name (BCLP, Package (0x10)
{
0x14,
0x19,
0x1E,
0x23,
0x28,
0x2D,
0x32,
0x37,
0x3C,
0x41,
0x46,
0x4B,
0x50,
0x55,
0x5A,
0x64
})
Name (BCLL, Package (0x10)
{
0x00,
0x01,
0x02,
0x03,
0x04,
0x05,
0x06,
0x07,
0x08,
0x09,
0x0A,
0x0B,
0x0C,
0x0D,
0x0E,
0x0F
})
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method
{
Store (Match (BCLP, MEQ, Arg0, MTR, 0x00, 0x00), Local0)
If (LNotEqual (Local0, Ones))
{
Store (DerefOf (Index (BCLL, Local0)), Local1)
\VBRC (Local1)
}
}
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current
{
Store (\VBRG (), Local0)
If (LLessEqual (Local0, 0x0F))
{
Return (DerefOf (Index (BCLP, Local0)))
}
Else
{
Return (Zero)
}
}
}
Scope (\_PR.CPU0)
{
Name (_TPC, 0x00) // _TPC: Throttling Present Capabilities
Method (_PTC, 0, NotSerialized) // _PTC: Processor Throttling Control
{
If (And (PDC0, 0x04))
{
Return (Package (0x02)
{
ResourceTemplate ()
{
Register (FFixedHW,
0x00, // Bit Width
0x00, // Bit Offset
0x0000000000000000, // Address
,)
},
ResourceTemplate ()
{
Register (FFixedHW,
0x00, // Bit Width
0x00, // Bit Offset
0x0000000000000000, // Address
,)
}
})
}
Return (Package (0x02)
{
ResourceTemplate ()
{
Register (SystemIO,
0x04, // Bit Width
0x01, // Bit Offset
0x0000000000001010, // Address
,)
},
ResourceTemplate ()
{
Register (SystemIO,
0x04, // Bit Width
0x01, // Bit Offset
0x0000000000001010, // Address
,)
}
})
}
Name (TSSI, Package (0x08)
{
Package (0x05)
{
0x64,
0x03E8,
0x00,
0x00,
0x00
},
Package (0x05)
{
0x58,
0x036B,
0x00,
0x0F,
0x00
},
Package (0x05)
{
0x4B,
0x02EE,
0x00,
0x0E,
0x00
},
Package (0x05)
{
0x3F,
0x0271,
0x00,
0x0D,
0x00
},
Package (0x05)
{
0x32,
0x01F4,
0x00,
0x0C,
0x00
},
Package (0x05)
{
0x26,
0x0177,
0x00,
0x0B,
0x00
},
Package (0x05)
{
0x19,
0xFA,
0x00,
0x0A,
0x00
},
Package (0x05)
{
0x0D,
0x7D,
0x00,
0x09,
0x00
}
})
Name (TSSM, Package (0x08)
{
Package (0x05)
{
0x64,
0x03E8,
0x00,
0x00,
0x00
},
Package (0x05)
{
0x58,
0x036B,
0x00,
0x1E,
0x00
},
Package (0x05)
{
0x4B,
0x02EE,
0x00,
0x1C,
0x00
},
Package (0x05)
{
0x3F,
0x0271,
0x00,
0x1A,
0x00
},
Package (0x05)
{
0x32,
0x01F4,
0x00,
0x18,
0x00
},
Package (0x05)
{
0x26,
0x0177,
0x00,
0x16,
0x00
},
Package (0x05)
{
0x19,
0xFA,
0x00,
0x14,
0x00
},
Package (0x05)
{
0x0D,
0x7D,
0x00,
0x12,
0x00
}
})
Name (TSSF, 0x00)
Method (_TSS, 0, NotSerialized) // _TSS: Throttling Supported States
{
If (LAnd (LNot (TSSF), CondRefOf (_PSS)))
{
Store (_PSS, Local0)
Store (SizeOf (Local0), Local1)
Decrement (Local1)
Store (DerefOf (Index (DerefOf (Index (Local0, Local1)), 0x01)),
Local2)
Store (0x00, Local3)
While (LLess (Local3, SizeOf (TSSI)))
{
Store (Divide (Multiply (Local2, Subtract (0x08, Local3)), 0x08,
), Local4)
Store (Local4, Index (DerefOf (Index (TSSI, Local3)), 0x01))
Store (Local4, Index (DerefOf (Index (TSSM, Local3)), 0x01))
Increment (Local3)
}
Store (Ones, TSSF)
}
If (And (PDC0, 0x04))
{
Return (TSSM)
}
Return (TSSI)
}
Method (_TSD, 0, NotSerialized) // _TSD: Throttling State Dependencies
{
If (LAnd (And (CFGD, 0x01000000), LNot (And (PDC0, 0x04
))))
{
Return (Package (0x01)
{
Package (0x05)
{
0x05,
0x00,
0x00,
0xFD,
0x02
}
})
}
Return (Package (0x01)
{
Package (0x05)
{
0x05,
0x00,
0x00,
0xFC,
0x01
}
})
}
}
Scope (\_PR.CPU1)
{
Name (_TPC, 0x00) // _TPC: Throttling Present Capabilities
Method (_PTC, 0, NotSerialized) // _PTC: Processor Throttling Control
{
Return (\_PR.CPU0._PTC ())
}
Method (_TSS, 0, NotSerialized) // _TSS: Throttling Supported States
{
Return (\_PR.CPU0._TSS ())
}
Method (_TSD, 0, NotSerialized) // _TSD: Throttling State Dependencies
{
If (LAnd (And (CFGD, 0x01000000), LNot (And (PDC1, 0x04
))))
{
Return (Package (0x01)
{
Package (0x05)
{
0x05,
0x00,
0x00,
0xFD,
0x02
}
})
}
Return (Package (0x01)
{
Package (0x05)
{
0x05,
0x00,
0x01,
0xFC,
0x01
}
})
}
}
Scope (\)
{
Name (SSDT, Package (0x0C)
{
"CPU0IST ",
0xBF6E1B32,
0x00000282,
"CPU1IST ",
0xBF6E1A6A,
0x000000C8,
"CPU0CST ",
0xBF6E1E39,
0x0000085E,
"CPU1CST ",
0xBF6E1DB4,
0x00000085
})
Name (CFGD, 0x113F69F7)
Name (\PDC0, 0x80000000)
Name (\PDC1, 0x80000000)
Name (\SDTL, 0x00)
}
Scope (\_PR.CPU0)
{
Name (HI0, 0x00)
Name (HC0, 0x00)
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities
{
CreateDWordField (Arg0, 0x00, REVS)
CreateDWordField (Arg0, 0x04, SIZE)
Store (SizeOf (Arg0), Local0)
Store (Subtract (Local0, 0x08), Local1)
CreateField (Arg0, 0x40, Multiply (Local1, 0x08), TEMP)
Name (STS0, Buffer (0x04)
{
0x00, 0x00, 0x00, 0x00
})
Concatenate (STS0, TEMP, Local2)
_OSC (Buffer (0x10)
{
/* 0000 */ 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
/* 0008 */ 0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
}, REVS, SIZE, Local2)
}
Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities
{
CreateDWordField (Arg3, 0x00, STS0)
CreateDWordField (Arg3, 0x04, CAP0)
CreateDWordField (Arg0, 0x00, IID0)
CreateDWordField (Arg0, 0x04, IID1)
CreateDWordField (Arg0, 0x08, IID2)
CreateDWordField (Arg0, 0x0C, IID3)
Name (UID0, Buffer (0x10)
{
/* 0000 */ 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
/* 0008 */ 0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
})
CreateDWordField (UID0, 0x00, EID0)
CreateDWordField (UID0, 0x04, EID1)
CreateDWordField (UID0, 0x08, EID2)
CreateDWordField (UID0, 0x0C, EID3)
If (LNot (LAnd (LAnd (LEqual (IID0, EID0), LEqual (IID1, EID1)),
LAnd (LEqual (IID2, EID2), LEqual (IID3, EID3)))))
{
Store (0x06, STS0)
Return (Arg3)
}
If (LNotEqual (Arg1, 0x01))
{
Store (0x0A, STS0)
Return (Arg3)
}
Or (And (PDC0, 0x7FFFFFFF), CAP0, PDC0)
If (And (CFGD, 0x01))
{
If (LAnd (LAnd (And (CFGD, 0x01000000), LEqual (And (PDC0,
0x09), 0x09)), LNot (And (SDTL, 0x01))))
{
Or (SDTL, 0x01, SDTL)
OperationRegion (IST0, SystemMemory, DerefOf (Index (SSDT, 0x01)), DerefOf (Index (SSDT, 0x02
)))
Load (IST0, HI0)
}
}
If (And (CFGD, 0xF0))
{
If (LAnd (LAnd (And (CFGD, 0x01000000), And (PDC0, 0x18
)), LNot (And (SDTL, 0x02))))
{
Or (SDTL, 0x02, SDTL)
OperationRegion (CST0, SystemMemory, DerefOf (Index (SSDT, 0x07)), DerefOf (Index (SSDT, 0x08
)))
Load (CST0, HC0)
}
}
Return (Arg3)
}
}
Scope (\_PR.CPU1)
{
Name (HI1, 0x00)
Name (HC1, 0x00)
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities
{
CreateDWordField (Arg0, 0x00, REVS)
CreateDWordField (Arg0, 0x04, SIZE)
Store (SizeOf (Arg0), Local0)
Store (Subtract (Local0, 0x08), Local1)
CreateField (Arg0, 0x40, Multiply (Local1, 0x08), TEMP)
Name (STS1, Buffer (0x04)
{
0x00, 0x00, 0x00, 0x00
})
Concatenate (STS1, TEMP, Local2)
_OSC (Buffer (0x10)
{
/* 0000 */ 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
/* 0008 */ 0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
}, REVS, SIZE, Local2)
}
Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities
{
CreateDWordField (Arg3, 0x00, STS1)
CreateDWordField (Arg3, 0x04, CAP1)
CreateDWordField (Arg0, 0x00, IID0)
CreateDWordField (Arg0, 0x04, IID1)
CreateDWordField (Arg0, 0x08, IID2)
CreateDWordField (Arg0, 0x0C, IID3)
Name (UID1, Buffer (0x10)
{
/* 0000 */ 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
/* 0008 */ 0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
})
CreateDWordField (UID1, 0x00, EID0)
CreateDWordField (UID1, 0x04, EID1)
CreateDWordField (UID1, 0x08, EID2)
CreateDWordField (UID1, 0x0C, EID3)
If (LNot (LAnd (LAnd (LEqual (IID0, EID0), LEqual (IID1, EID1)),
LAnd (LEqual (IID2, EID2), LEqual (IID3, EID3)))))
{
Store (0x06, STS1)
Return (Arg3)
}
If (LNotEqual (Arg1, 0x01))
{
Store (0x0A, STS1)
Return (Arg3)
}
Or (And (PDC1, 0x7FFFFFFF), CAP1, PDC1)
If (And (CFGD, 0x01))
{
If (LAnd (LAnd (And (CFGD, 0x01000000), LEqual (And (PDC1,
0x09), 0x09)), LNot (And (SDTL, 0x10))))
{
Or (SDTL, 0x10, SDTL)
OperationRegion (IST1, SystemMemory, DerefOf (Index (SSDT, 0x04)), DerefOf (Index (SSDT, 0x05
)))
Load (IST1, HI1)
}
}
If (And (CFGD, 0xF0))
{
If (LAnd (LAnd (And (CFGD, 0x01000000), And (PDC1, 0x18
)), LNot (And (SDTL, 0x20))))
{
Or (SDTL, 0x20, SDTL)
OperationRegion (CST1, SystemMemory, DerefOf (Index (SSDT, 0x0A)), DerefOf (Index (SSDT, 0x0B
)))
Load (CST1, HC1)
}
}
Return (Arg3)
}
Method (_INI, 0, NotSerialized) // _INI: Initialize
{
If (\DTSE)
{
THRM (0x00)
}
If (LAnd (\WXPF, LLessEqual (\WSPV, 0x01)))
{
PPMS (0x00)
}
}
}
Scope (\_SB.PCI0.SATA)
{
Device (PRT0)
{
Name (DRE0, 0x00)
Name (DIP0, 0x00)
Name (HDTF, Buffer (0x0E)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5
})
CreateByteField (HDTF, 0x0D, HFLC)
Name (ERTF, Buffer (0x15)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x5F, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField (ERTF, 0x0D, EFLC)
Name (HPTF, Buffer (0x15)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x10, 0x03,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField (HPTF, 0x0D, PFLC)
Name (HXTF, Buffer (0x1C)
{
/* 0000 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00,
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xA0, 0xF5, 0x5F, 0x00,
/* 0010 */ 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x10, 0x03, 0x00,
/* 0018 */ 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField (HXTF, 0x0D, XFLC)
Name (_ADR, 0xFFFF) // _ADR: Address
Method (_SDD, 1, NotSerialized) // _SDD: Set Device Data
{
Store (0x00, DRE0)
Store (0x00, DIP0)
If (LEqual (SizeOf (Arg0), 0x0200))
{
CreateWordField (Arg0, 0x9C, M078)
CreateWordField (Arg0, 0xAC, M086)
CreateWordField (Arg0, 0xEE, M119)
CreateWordField (Arg0, 0x0128, M148)
If (LEqual (And (M148, 0xC000), 0x4000))
{
If (And (M148, 0x04))
{
Store (0x01, DRE0)
}
}
If (And (M086, 0x8000))
{
If (And (M119, 0x01))
{
Store (0x01, DRE0)
}
}
If (And (M078, 0x08))
{
Store (0x01, DIP0)
}
}
}
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File
{
If (\OSSS)
{
Store (0xE1, XFLC)
Store (0xE1, EFLC)
Store (0xE1, HFLC)
Store (0xE1, PFLC)
}
If (DRE0)
{
If (DIP0)
{
Return (HXTF)
}
Else
{
Return (ERTF)
}
}
If (DIP0)
{
Return (HPTF)
}
Return (HDTF)
}
}
}
}