NetBSD Problem Report #41882
From dhgutteridge@sympatico.ca Wed Aug 12 23:16:19 2009
Return-Path: <dhgutteridge@sympatico.ca>
Received: from mail.netbsd.org (mail.netbsd.org [204.152.190.11])
by www.NetBSD.org (Postfix) with ESMTP id 91CCC63C284
for <gnats-bugs@gnats.netbsd.org>; Wed, 12 Aug 2009 23:16:19 +0000 (UTC)
Message-Id: <BLU0-SMTP48CCBD0FC7981B848F5AA1B7040@phx.gbl>
Date: Wed, 12 Aug 2009 19:16:13 -0400
From: "David H. Gutteridge" <dhgutteridge@sympatico.ca>
Reply-To: gutteridge@netbsd.org
To: gnats-bugs@netbsd.org
Subject: ACPI errors encountered on NetBSD 5 on an LG X110
>Number: 41882
>Category: kern
>Synopsis: ACPI errors encountered on NetBSD 5 on an LG X110
>Confidential: no
>Severity: non-critical
>Priority: low
>Responsible: kern-bug-people
>State: open
>Class: sw-bug
>Submitter-Id: net
>Arrival-Date: Wed Aug 12 23:20:01 +0000 2009
>Last-Modified: Mon Jan 21 02:30:31 +0000 2019
>Originator: David H. Gutteridge
>Release: NetBSD 5.0_STABLE
>Organization:
>Environment:
NetBSD arcusvii.nonus-porta.net 5.0_STABLE NetBSD 5.0_STABLE
(ARCUSVII) #0: Sun Jul 26 19:04:57 EDT 2009 disciple@arcusvii.nonus-
porta.net:/home/disciple/netbsd-5/usr/src/sys/arch/i386/compile/obj/
ARCUSVII i386
Architecture: i386
Machine: i386
>Description:
Hello,
I'm seeing ACPI errors reported when I boot a 5.0-ish kernel with ACPI
enabled on my LG X110 netbook (one of many incarnations of the MSI
Wind). Also, ACPI-related functions like screen brightness don't work,
which I understood from previous inquiries is to be expected.
Here's the relevant excerpt from the dmesg:
NetBSD 5.0_STABLE (ARCUSVII) #0: Sun Jul 26 19:04:57 EDT 2009
disciple@arcusvii.nonus-porta.net:/home/disciple/netbsd-5/usr/src/
sys/arch/i386/compile/obj/ARCUSVII
total memory = 1013 MB
avail memory = 984 MB
timecounter: Timecounters tick every 10.000 msec
timecounter: Timecounter "i8254" frequency 1193182 Hz quality 100
LG Electronics X110-L.A7B1A9 (Ver.001)
mainbus0 (root)
cpu0 at mainbus0 apid 0: Intel 686-class, 1600MHz, id 0x106c2
cpu0: Enhanced SpeedStep (1324 mV) 1600 MHz
cpu0: Enhanced SpeedStep frequencies available (MHz): 1600 1467 1333
1200 1067 933 800
cpu1 at mainbus0 apid 1: Intel 686-class, 1600MHz, id 0x106c2
ioapic0 at mainbus0 apid 2: pa 0xfec00000, version 20, 24 pins
acpi0 at mainbus0: Intel ACPICA 20080321
acpi0: X/RSDT: OemId < LGE, LGPC,06222004>, AslId <MSFT,00010013>
ACPI Error (evregion-0427): No handler for Region [EC__] (0xc1f02840)
[EmbeddedControl] [20080321]
ACPI Error (exfldio-0390): Region EmbeddedControl(3) has no handler
[20080321]
ACPI Error (psparse-0627): Method parse/execution failed
[\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
ACPI Error (uteval-0306): Method execution failed
[\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
acpi0: SCI interrupting at int 9
acpi0: fixed-feature power button present
timecounter: Timecounter "ACPI-Safe" frequency 3579545 Hz quality 900
ACPI-Safe 24-bit timer
ACPI Error (evregion-0427): No handler for Region [EC__] (0xc1f02840)
[EmbeddedControl] [20080321]
ACPI Error (exfldio-0390): Region EmbeddedControl(3) has no handler
[20080321]
ACPI Error (psparse-0627): Method parse/execution failed
[\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
ACPI Error (uteval-0306): Method execution failed
[\_SB_.PCI0.SBRG.EC__.BAT1._STA] (Node 0xc1f03340), AE_NOT_EXIST
pcppi1 at acpi0 (SPKR, PNP0800): io 0x61
midi0 at pcppi1: PC speaker (CPU-intensive output)
sysbeep0 at pcppi1
attimer1 at acpi0 (TMR, PNP0100): io 0x40-0x43 irq 0
npx1 at acpi0 (COPR, PNP0C04): io 0xf0-0xff irq 13
npx1: reported by CPUID; using exception 16
pckbc1 at acpi0 (PS2K, PNP0303) (kbd port): io 0x60,0x64 irq 1
pckbc2 at acpi0 (PS2M, PNP0F03) (aux port): irq 12
acpiec0 at acpi0 (EC, PNP0C09): io 0x62,0x66
acpiacad0 at acpi0 (ADP1, ACPI0003): ACPI AC Adapter
acpibat0 at acpi0 (BAT1, PNP0C0A-1): ACPI Battery (Control Method)
acpibat0: battery info: MSI Corp.
, LION
, MS-N021
acpilid0 at acpi0 (LID0, PNP0C0D): ACPI Lid Switch
SCM0 (pnp0c14) at acpi0 not configured
hpet0 at acpi0 (HPET, PNP0103): mem 0xfed03000-0xfed033ff
timecounter: Timecounter "hpet0" frequency 14318179 Hz quality 2000
acpibut0 at acpi0 (PWRB, PNP0C0C): ACPI Power Button
acpibut1 at acpi0 (SLPB, PNP0C0E): ACPI Sleep Button
acpitz0 at acpi0 (THRM): critical 100.0C, passive cooling
apm0 at acpi0: Power Management spec V1.2
attimer1: attached to pcppi1
Here is the ASL generated from acpidump(8), if this is of any use:
/*
RSD PTR: Checksum=72, OEMID=LGE, RsdtAddress=0x3f610f10
*/
/*
RSDT: Length=56, Revision=1, Checksum=230,
OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x6222004,
Creator ID=MSFT, Creator Revision=0x10013
*/
/*
Entries={ 0x3f611910, 0x3f610e90, 0x3f605510, 0x3f5e8a10, 0x3f611a10 }
*/
/*
DSDT=0x3f608010
INT_MODEL=APIC
SCI_INT=9
SMI_CMD=0xb2, ACPI_ENABLE=0xa0, ACPI_DISABLE=0xa1, S4BIOS_REQ=0x0
PM1a_EVT_BLK=0x400-0x403
PM1a_CNT_BLK=0x404-0x405
PM2_CNT_BLK=0x420-0x420
PM2_TMR_BLK=0x408-0x40b
PM2_GPE0_BLK=0x428-0x42f
P_LVL2_LAT=1ms, P_LVL3_LAT=57ms
FLUSH_SIZE=1024, FLUSH_STRIDE=16
DUTY_OFFSET=1, DUTY_WIDTH=3
DAY_ALRM=125, MON_ALRM=126, CENTURY=50
Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4}
*/
/*
DSDT: Length=22450, Revision=1, Checksum=42,
OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x0,
Creator ID=INTL, Creator Revision=0x20051117
*/
DefinitionBlock ("acpi_dst.aml", "DSDT", 0x1, "LGE", "LGPC", 0x0)
{
Name(SP1O, 0x2e)
Name(IOCE, 0x00)
Name(IOCL, 0x00)
Name(IO1B, 0x0a20)
Name(IO1L, 0x20)
Name(IOEC, 0x0a10)
Name(IO4L, 0x80)
Name(IO5L, 0x80)
Name(IO2B, 0x0a00)
Name(IO2L, 0x20)
Name(IOPM, 0x0a00)
Name(IO3B, 0x00)
Name(IO3L, 0x10)
Name(SI1P, 0x00)
Name(MCHB, 0xfed14000)
Name(MCHL, 0x4000)
Name(EGPB, 0xfed19000)
Name(EGPL, 0x1000)
Name(DMIB, 0xfed18000)
Name(DMIL, 0x1000)
Name(PEBS, 0xe0000000)
Name(PELN, 0x10000000)
Name(LAPB, 0xfee00000)
Name(SMBS, 0x1180)
Name(SMBL, 0x20)
Name(PMBS, 0x0400)
Name(PMLN, 0x80)
Name(SMIP, 0xb2)
Name(GPBS, 0x0500)
Name(GPLN, 0x40)
Name(APCB, 0xfec00000)
Name(APCL, 0x1000)
Name(PM30, 0x0430)
Name(SRCB, 0xfed20000)
Name(SRCL, 0x4000)
Name(SUSW, 0xff)
Name(HPTB, 0xfed00000)
Name(HPTC, 0xfed23404)
Name(ACPH, 0xde)
Name(ASSB, 0x00)
Name(AOTB, 0x00)
Name(AAXB, 0x00)
Name(PEHP, 0x01)
Name(SHPC, 0x00)
Name(PEPM, 0x01)
Name(PEER, 0x01)
Name(PECS, 0x01)
Name(ITKE, 0x00)
Name(CMOS, 0x60)
Method(RRIO, 4) {
Store("RRIO", Debug)
}
Method(RDMA, 3) {
Store("rDMA", Debug)
}
Name(PICM, 0x00)
Method(_PIC, 1) {
If(Arg0) {
Store(0xaa, DBG8)
}
Else {
Store(0xac, DBG8)
}
Store(Arg0, PICM)
}
Name(OSVR, Ones)
Method(OSFL) {
If(LNot(LEqual(OSVR, Ones))) {
Return(OSVR)
}
If(LEqual(PICM, 0x00)) {
Store(0xac, DBG8)
}
Store(0x01, OSVR)
If(CondRefOf(\_OSI, Local0)) {
If(\_OSI("Linux")) {
Store(0x03, OSVR)
}
Else {
If(\_OSI("Windows\x202001")) {
Store(0x04, OSVR)
}
Else {
If(\_OSI("Windows\x202001.1")) {
Store(0x05, OSVR)
}
Else {
If(\_OSI("FreeBSD")) {
Store(0x06, OSVR)
}
Else {
If(\_OSI("HP\x2dUX")) {
Store(0x07, OSVR)
}
Else {
If(\_OSI("OpenVMS")) {
Store(0x08, OSVR)
}
}
}
}
}
}
}
Else {
If(MCTH(\_OS, "Microsoft\x20Windows\x20NT")) {
Store(0x00, OSVR)
}
Else {
If(MCTH(\_OS, "Microsoft\x20Windows")) {
Store(0x01, OSVR)
}
Else {
If(MCTH(\_OS, "Microsoft\x20WindowsME\x3a
\x20Millennium\x20Edition")) {
Store(0x02, OSVR)
}
Else {
If(MCTH(\_OS, "Linux")) {
Store(0x03, OSVR)
}
Else {
If(MCTH(\_OS, "FreeBSD")) {
Store(0x06, OSVR)
}
Else {
If(MCTH(\_OS, "HP\x2dUX")) {
Store(0x07, OSVR)
}
Else {
If(MCTH(\_OS, "OpenVMS")) {
Store(0x08, OSVR)
}
}
}
}
}
}
}
}
Return(OSVR)
}
Method(MCTH, 2) {
If(LLess(SizeOf(Arg0), SizeOf(Arg1))) {
Return(Zero)
}
Add(SizeOf(Arg0), 0x01, Local0)
Name(BUF0, Buffer(Local0) { })
Name(BUF1, Buffer(Local0) { })
Store(Arg0, BUF0)
Store(Arg1, BUF1)
While(Local0) {
Decrement(Local0)
If(LNot(LEqual(DerefOf(Index(BUF0, Local0, )), DerefOf(Index
(BUF1, Local0, ))))) {
Return(Zero)
}
}
Return(One)
}
Name(PRWP, Package(0x02) {
Zero,
Zero,
})
Method(GPRW, 2) {
Store(Arg0, Index(PRWP, 0x00, ))
Store(ShiftLeft(SS1, 0x01, ), Local0)
Or(Local0, ShiftLeft(SS2, 0x02, ), Local0)
Or(Local0, ShiftLeft(SS3, 0x03, ), Local0)
Or(Local0, ShiftLeft(SS4, 0x04, ), Local0)
If(And(ShiftLeft(0x01, Arg1, ), Local0, )) {
Store(Arg1, Index(PRWP, 0x01, ))
}
Else {
ShiftRight(Local0, 0x01, Local0)
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
FindSetLeftBit(Local0, Index(PRWP, 0x01, ))
}
Else {
FindSetRightBit(Local0, Index(PRWP, 0x01, ))
}
}
Return(PRWP)
}
Name(WAKP, Package(0x02) {
Zero,
Zero,
})
OperationRegion(DEB0, SystemIO, 0x80, 0x01)
Field(DEB0, ByteAcc, NoLock, Preserve) {
DBG8, 8
}
OperationRegion(DEB1, SystemIO, 0x90, 0x02)
Field(DEB1, WordAcc, NoLock, Preserve) {
DBG9, 16
}
Name(SS1, 0x01)
Name(SS2, 0x00)
Name(SS3, 0x01)
Name(SS4, 0x01)
Name(IOST, 0x4400)
Name(TOPM, 0x3fffffff)
Name(ROMS, 0xffe00000)
Name(MG1B, 0x000c0000)
Name(MG1L, 0x00040000)
Name(MG2B, 0x40000000)
Name(MG2L, 0xbff00000)
Scope(\_SB) {
Name(PR00, Package(0x12) {
Package(0x04) {
0x0001ffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0x0001ffff,
0x01,
LNKB,
0x00,
},
Package(0x04) {
0x0001ffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0x0001ffff,
0x03,
LNKD,
0x00,
},
Package(0x04) {
0x001fffff,
0x00,
LNKC,
0x00,
},
Package(0x04) {
0x001fffff,
0x01,
LNKD,
0x00,
},
Package(0x04) {
0x001dffff,
0x00,
LNKH,
0x00,
},
Package(0x04) {
0x001dffff,
0x01,
LNKD,
0x00,
},
Package(0x04) {
0x001dffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0x001dffff,
0x03,
LNKA,
0x00,
},
Package(0x04) {
0x001effff,
0x00,
LNKB,
0x00,
},
Package(0x04) {
0x001effff,
0x01,
LNKE,
0x00,
},
Package(0x04) {
0x001bffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0x001cffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0x001cffff,
0x01,
LNKB,
0x00,
},
Package(0x04) {
0x001cffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0x001cffff,
0x03,
LNKD,
0x00,
},
Package(0x04) {
0x0002ffff,
0x00,
LNKA,
0x00,
},
})
Name(AR00, Package(0x12) {
Package(0x04) {
0x0001ffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x0001ffff,
0x01,
0x00,
0x11,
},
Package(0x04) {
0x0001ffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0x0001ffff,
0x03,
0x00,
0x13,
},
Package(0x04) {
0x001fffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x001fffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0x001dffff,
0x00,
0x00,
0x17,
},
Package(0x04) {
0x001dffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0x001dffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0x001dffff,
0x03,
0x00,
0x10,
},
Package(0x04) {
0x001effff,
0x00,
0x00,
0x11,
},
Package(0x04) {
0x001effff,
0x01,
0x00,
0x14,
},
Package(0x04) {
0x001bffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x001cffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x001cffff,
0x01,
0x00,
0x11,
},
Package(0x04) {
0x001cffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0x001cffff,
0x03,
0x00,
0x13,
},
Package(0x04) {
0x0002ffff,
0x00,
0x00,
0x10,
},
})
Name(PR02, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKD,
0x00,
},
})
Name(AR02, 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,
},
})
Name(PR04, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKD,
0x00,
},
})
Name(AR04, 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,
},
})
Name(PR05, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKA,
0x00,
},
})
Name(AR05, 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,
},
})
Name(PR06, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKB,
0x00,
},
})
Name(AR06, 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,
},
})
Name(PR07, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKC,
0x00,
},
})
Name(AR07, 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,
},
})
Name(PR08, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKD,
0x00,
},
})
Name(AR08, 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,
},
})
Name(PR09, Package(0x04) {
Package(0x04) {
0xffff,
0x00,
LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x01,
LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x02,
LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x03,
LNKA,
0x00,
},
})
Name(AR09, 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,
},
})
Name(PRSA, Buffer(0x06) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
Alias(PRSA, PRSB)
Alias(PRSA, PRSC)
Alias(PRSA, PRSD)
Alias(PRSA, PRSE)
Alias(PRSA, PRSF)
Alias(PRSA, PRSG)
Alias(PRSA, PRSH)
Device(PCI0) {
Name(_HID, 0x080ad041)
Name(_CID, 0x030ad041)
Name(_ADR, 0x00)
Method(^BN00) {
Return(0x00)
}
Method(_BBN) {
Return(BN00())
}
Name(_UID, 0x00)
Method(_PRT) {
If(PICM) {
Return(AR00)
}
Return(PR00)
}
Method(_S3D) {
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
Return(0x02)
}
Else {
Return(0x03)
}
}
Scope(\_SB) {
Scope(PCI0) {
Device(MCH) {
Name(_HID, 0x010cd041)
Name(_UID, 0x03b1)
Name(_STA, 0x0f)
Name(MCHR, Buffer(0x32) {0x86, 0x9, 0x0, 0x1,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
Method(_CRS) {
CreateDWordField(MCHR, 0x08, ML)
CreateDWordField(MCHR, 0x04, MB)
Store(\MCHB, MB)
Store(\MCHL, ML)
CreateDWordField(MCHR, 0x14, EL)
CreateDWordField(MCHR, 0x10, EB)
Store(\EGPB, EB)
Store(\EGPL, EL)
CreateDWordField(MCHR, 0x20, DL)
CreateDWordField(MCHR, 0x1c, DB)
Store(\DMIB, DB)
Store(\DMIL, DL)
CreateDWordField(MCHR, 0x2c, PL)
CreateDWordField(MCHR, 0x28, PB)
Store(\PEBS, PB)
Store(\PELN, PL)
Return(MCHR)
}
}
}
}
Method(NPTS, 1) {
}
Method(NWAK, 1) {
}
Device(P0P2) {
Name(_ADR, 0x00010000)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR02)
}
Return(PR02)
}
Device(PEGP) {
Name(_ADR, 0xffff)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
}
}
Device(IDE0) {
Name(_ADR, 0x001f0001)
Name(\_SB.PCI0.NATA, Package(0x01) {
0x001f0001,
})
Name(REGF, 0x01)
Method(_REG, 2) {
If(LEqual(Arg0, 0x02)) {
Store(Arg1, REGF)
}
}
Name(TIM0, Package(0x08) {
Package(0x04) {
0x78,
0xb4,
0xf0,
0x0384,
},
Package(0x04) {
0x23,
0x21,
0x10,
0x00,
},
Package(0x04) {
0x0b,
0x09,
0x04,
0x00,
},
Package(0x06) {
0x70,
0x49,
0x36,
0x27,
0x19,
0x0f,
},
Package(0x06) {
0x00,
0x01,
0x02,
0x01,
0x02,
0x01,
},
Package(0x06) {
0x00,
0x00,
0x00,
0x01,
0x01,
0x01,
},
Package(0x04) {
0x04,
0x03,
0x02,
0x00,
},
Package(0x04) {
0x02,
0x01,
0x00,
0x00,
},
})
Name(TMD0, Buffer(0x14) { })
CreateDWordField(TMD0, 0x00, PIO0)
CreateDWordField(TMD0, 0x04, DMA0)
CreateDWordField(TMD0, 0x08, PIO1)
CreateDWordField(TMD0, 0x0c, DMA1)
CreateDWordField(TMD0, 0x10, CHNF)
OperationRegion(CFG2, PCI_Config, 0x40, 0x20)
Field(CFG2, DWordAcc, NoLock, Preserve) {
PMPT, 4,
PSPT, 4,
PMRI, 6,
Offset(0x2),
SMPT, 4,
SSPT, 4,
SMRI, 6,
Offset(0x4),
PSRI, 4,
SSRI, 4,
Offset(0x8),
PM3E, 1,
PS3E, 1,
SM3E, 1,
SS3E, 1,
Offset(0xa),
PMUT, 2,
, 2,
PSUT, 2,
Offset(0xb),
SMUT, 2,
, 2,
SSUT, 2,
Offset(0xc),
Offset(0x14),
PM6E, 1,
PS6E, 1,
SM6E, 1,
SS6E, 1,
PMCR, 1,
PSCR, 1,
SMCR, 1,
SSCR, 1,
, 4,
PMAE, 1,
PSAE, 1,
SMAE, 1,
SSAE, 1
}
Name(GMPT, 0x00)
Name(GMUE, 0x00)
Name(GMUT, 0x00)
Name(GMCR, 0x00)
Name(GSPT, 0x00)
Name(GSUE, 0x00)
Name(GSUT, 0x00)
Name(GSCR, 0x00)
Device(CHN0) {
Name(_ADR, 0x00)
Method(_GTM) {
ShiftLeft(PSCR, 0x01, Local1)
Or(PMCR, Local1, Local0)
ShiftLeft(PMAE, 0x02, Local3)
ShiftLeft(PM6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(PM3E, Local3, Local1)
ShiftLeft(PMPT, 0x04, Local3)
Or(Local1, Local3, Local1)
ShiftLeft(PSAE, 0x02, Local3)
ShiftLeft(PS6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(PS3E, Local3, Local2)
ShiftLeft(PSPT, 0x04, Local3)
Or(Local2, Local3, Local2)
Return(GTM(PMRI, Local1, PMUT, PSRI, Local2,
PSUT, Local0))
}
Method(_STM, 3) {
Store(Arg0, Debug)
Store(Arg0, TMD0)
ShiftLeft(PMAE, 0x02, Local3)
ShiftLeft(PM6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(PM3E, Local3, Local0)
ShiftLeft(PMPT, 0x04, Local3)
Or(Local0, Local3, Local0)
ShiftLeft(PSAE, 0x02, Local3)
ShiftLeft(PS6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(PS3E, Local3, Local1)
ShiftLeft(PSPT, 0x04, Local3)
Or(Local1, Local3, Local1)
Store(PMRI, GMPT)
Store(Local0, GMUE)
Store(PMUT, GMUT)
Store(PMCR, GMCR)
Store(PSRI, GSPT)
Store(Local1, GSUE)
Store(PSUT, GSUT)
Store(PSCR, GSCR)
STM()
Store(GMPT, PMRI)
Store(GMUE, Local0)
Store(GMUT, PMUT)
Store(GMCR, PMCR)
Store(GSUE, Local1)
Store(GSUT, PSUT)
Store(GSCR, PSCR)
If(And(Local0, 0x01, )) {
Store(0x01, PM3E)
}
Else {
Store(0x00, PM3E)
}
If(And(Local0, 0x02, )) {
Store(0x01, PM6E)
}
Else {
Store(0x00, PM6E)
}
If(And(Local0, 0x04, )) {
Store(0x01, PMAE)
}
Else {
Store(0x00, PMAE)
}
If(And(Local1, 0x01, )) {
Store(0x01, PS3E)
}
Else {
Store(0x00, PS3E)
}
If(And(Local1, 0x02, )) {
Store(0x01, PS6E)
}
Else {
Store(0x00, PS6E)
}
If(And(Local1, 0x04, )) {
Store(0x01, PSAE)
}
Else {
Store(0x00, PSAE)
}
Store(GTF(0x00, Arg1), ATA0)
Store(GTF(0x01, Arg2), ATA1)
}
Device(DRV0) {
Name(_ADR, 0x00)
Method(_GTF) {
Return(RATA(ATA0))
}
}
Device(DRV1) {
Name(_ADR, 0x01)
Method(_GTF) {
Return(RATA(ATA1))
}
}
}
Device(CHN1) {
Name(_ADR, 0x01)
Method(_GTM) {
ShiftLeft(SSCR, 0x01, Local1)
Or(SMCR, Local1, Local0)
ShiftLeft(SMAE, 0x02, Local3)
ShiftLeft(SM6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(SM3E, Local3, Local1)
ShiftLeft(SMPT, 0x04, Local3)
Or(Local1, Local3, Local1)
ShiftLeft(SSAE, 0x02, Local3)
ShiftLeft(SS6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(SS3E, Local3, Local2)
ShiftLeft(SSPT, 0x04, Local3)
Or(Local2, Local3, Local2)
Return(GTM(SMRI, Local1, SMUT, SSRI, Local2,
SSUT, Local0))
}
Method(_STM, 3) {
Store(Arg0, Debug)
Store(Arg0, TMD0)
ShiftLeft(SMAE, 0x02, Local3)
ShiftLeft(SM6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(SM3E, Local3, Local0)
ShiftLeft(SMPT, 0x04, Local3)
Or(Local0, Local3, Local0)
ShiftLeft(SSAE, 0x02, Local3)
ShiftLeft(SS6E, 0x01, Local4)
Or(Local3, Local4, Local3)
Or(SS3E, Local3, Local1)
ShiftLeft(SSPT, 0x04, Local3)
Or(Local1, Local3, Local1)
Store(SMRI, GMPT)
Store(Local0, GMUE)
Store(SMUT, GMUT)
Store(SMCR, GMCR)
Store(SSRI, GSPT)
Store(Local1, GSUE)
Store(SSUT, GSUT)
Store(SSCR, GSCR)
STM()
Store(GMPT, SMRI)
Store(GMUE, Local0)
Store(GMUT, SMUT)
Store(GMCR, SMCR)
Store(GSUE, Local1)
Store(GSUT, SSUT)
Store(GSCR, SSCR)
If(And(Local0, 0x01, )) {
Store(0x01, SM3E)
}
Else {
Store(0x00, SM3E)
}
If(And(Local0, 0x02, )) {
Store(0x01, SM6E)
}
Else {
Store(0x00, SM6E)
}
If(And(Local0, 0x04, )) {
Store(0x01, SMAE)
}
Else {
Store(0x00, SMAE)
}
If(And(Local1, 0x01, )) {
Store(0x01, SS3E)
}
Else {
Store(0x00, SS3E)
}
If(And(Local1, 0x02, )) {
Store(0x01, SS6E)
}
Else {
Store(0x00, SS6E)
}
If(And(Local1, 0x04, )) {
Store(0x01, SSAE)
}
Else {
Store(0x00, SSAE)
}
Store(GTF(0x00, Arg1), ATA2)
Store(GTF(0x01, Arg2), ATA3)
}
Device(DRV0) {
Name(_ADR, 0x00)
Method(_GTF) {
Return(RATA(ATA2))
}
}
Device(DRV1) {
Name(_ADR, 0x01)
Method(_GTF) {
Return(RATA(ATA3))
}
}
}
Method(GTM, 7, Serialized) {
Store(Ones, PIO0)
Store(Ones, PIO1)
Store(Ones, DMA0)
Store(Ones, DMA1)
Store(0x10, CHNF)
If(REGF) {
}
Else {
Return(TMD0)
}
If(And(Arg1, 0x20, )) {
Or(CHNF, 0x02, CHNF)
}
Store(Match(DerefOf(Index(TIM0, 0x01, )), MEQ, Arg0,
MTR, 0x00, 0x00), Local6)
Store(DerefOf(Index(DerefOf(Index(TIM0, 0x00, )),
Local6, )), Local7)
Store(Local7, DMA0)
Store(Local7, PIO0)
If(And(Arg4, 0x20, )) {
Or(CHNF, 0x08, CHNF)
}
Store(Match(DerefOf(Index(TIM0, 0x02, )), MEQ, Arg3,
MTR, 0x00, 0x00), Local6)
Store(DerefOf(Index(DerefOf(Index(TIM0, 0x00, )),
Local6, )), Local7)
Store(Local7, DMA1)
Store(Local7, PIO1)
If(And(Arg1, 0x07, )) {
Store(Arg2, Local5)
If(And(Arg1, 0x02, )) {
Add(Local5, 0x02, Local5)
}
If(And(Arg1, 0x04, )) {
Add(Local5, 0x04, Local5)
}
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x03, )), Local5, )), DMA0)
Or(CHNF, 0x01, CHNF)
}
If(And(Arg4, 0x07, )) {
Store(Arg5, Local5)
If(And(Arg4, 0x02, )) {
Add(Local5, 0x02, Local5)
}
If(And(Arg4, 0x04, )) {
Add(Local5, 0x04, Local5)
}
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x03, )), Local5, )), DMA1)
Or(CHNF, 0x04, CHNF)
}
Store(TMD0, Debug)
Return(TMD0)
}
Method(STM, 0, Serialized) {
If(REGF) {
}
Else {
Store(0x00, GMUE)
Store(0x00, GMUT)
Store(0x00, GSUE)
Store(0x00, GSUT)
If(And(CHNF, 0x01, )) {
Store(Match(DerefOf(Index(TIM0, 0x03, )),
MLE, DMA0, MTR, 0x00, 0x00), Local0)
If(LGreater(Local0, 0x05)) {
Store(0x05, Local0)
}
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x04, )), Local0, )), GMUT)
Or(GMUE, 0x01, GMUE)
If(LGreater(Local0, 0x02)) {
Or(GMUE, 0x02, GMUE)
}
If(LGreater(Local0, 0x04)) {
And(GMUE, 0xfd, GMUE)
Or(GMUE, 0x04, GMUE)
}
}
Else {
If(Or(LEqual(PIO0, Ones), LEqual(PIO0,
0x00), )) {
If(And(LLess(DMA0, Ones), LGreater(DMA0,
0x00), )) {
Store(DMA0, PIO0)
Or(GMUE, 0x80, GMUE)
}
}
}
If(And(CHNF, 0x04, )) {
Store(Match(DerefOf(Index(TIM0, 0x03, )),
MLE, DMA1, MTR, 0x00, 0x00), Local0)
If(LGreater(Local0, 0x05)) {
Store(0x05, Local0)
}
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x04, )), Local0, )), GSUT)
Or(GSUE, 0x01, GSUE)
If(LGreater(Local0, 0x02)) {
Or(GSUE, 0x02, GSUE)
}
If(LGreater(Local0, 0x04)) {
And(GSUE, 0xfd, GSUE)
Or(GSUE, 0x04, GSUE)
}
}
Else {
If(Or(LEqual(PIO1, Ones), LEqual(PIO1,
0x00), )) {
If(And(LLess(DMA1, Ones), LGreater(DMA1,
0x00), )) {
Store(DMA1, PIO1)
Or(GSUE, 0x80, GSUE)
}
}
}
If(And(CHNF, 0x02, )) {
Or(GMUE, 0x20, GMUE)
}
If(And(CHNF, 0x08, )) {
Or(GSUE, 0x20, GSUE)
}
And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,
PIO0, MTR, 0x00, 0x00), 0x07, Local0)
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x01, )), Local0, )), Local1)
Store(Local1, GMPT)
If(LLess(Local0, 0x03)) {
Or(GMUE, 0x50, GMUE)
}
And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,
PIO1, MTR, 0x00, 0x00), 0x07, Local0)
Store(DerefOf(Index(DerefOf(Index(TIM0,
0x02, )), Local0, )), Local1)
Store(Local1, GSPT)
If(LLess(Local0, 0x03)) {
Or(GSUE, 0x50, GSUE)
}
}
}
Name(AT01, Buffer(0x07) {0x3, 0x0, 0x0, 0x0, 0x0, 0x0,
0xef })
Name(AT02, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x90 })
Name(AT03, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0xc6 })
Name(AT04, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x91 })
Name(ATA0, Buffer(0x1d) { })
Name(ATA1, Buffer(0x1d) { })
Name(ATA2, Buffer(0x1d) { })
Name(ATA3, Buffer(0x1d) { })
Name(ATAB, Buffer(0x1d) { })
CreateByteField(ATAB, 0x00, CMDC)
Method(GTFB, 3, Serialized) {
Multiply(CMDC, 0x38, Local0)
Add(Local0, 0x08, Local1)
CreateField(ATAB, Local1, 0x38, CMDX)
Multiply(CMDC, 0x07, Local0)
CreateByteField(ATAB, Add(Local0, 0x02, ), A001)
CreateByteField(ATAB, Add(Local0, 0x06, ), A005)
Store(Arg0, CMDX)
Store(Arg1, A001)
Store(Arg2, A005)
Increment(CMDC)
}
Method(GTF, 2, Serialized) {
Store(Arg1, Debug)
Store(0x00, CMDC)
Name(ID49, 0x0c00)
Name(ID59, 0x00)
Name(ID53, 0x04)
Name(ID63, 0x0f00)
Name(ID88, 0x0f00)
Name(IRDY, 0x01)
Name(PIOT, 0x00)
Name(DMAT, 0x00)
If(LEqual(SizeOf(Arg1), 0x0200)) {
CreateWordField(Arg1, 0x62, IW49)
Store(IW49, ID49)
CreateWordField(Arg1, 0x6a, IW53)
Store(IW53, ID53)
CreateWordField(Arg1, 0x7e, IW63)
Store(IW63, ID63)
CreateWordField(Arg1, 0x76, IW59)
Store(IW59, ID59)
CreateWordField(Arg1, 0xb0, IW88)
Store(IW88, ID88)
}
Store(0xa0, Local7)
If(Arg0) {
Store(0xb0, Local7)
And(CHNF, 0x08, IRDY)
If(And(CHNF, 0x10, )) {
Store(PIO1, PIOT)
}
Else {
Store(PIO0, PIOT)
}
If(And(CHNF, 0x04, )) {
If(And(CHNF, 0x10, )) {
Store(DMA1, DMAT)
}
Else {
Store(DMA0, DMAT)
}
}
}
Else {
And(CHNF, 0x02, IRDY)
Store(PIO0, PIOT)
If(And(CHNF, 0x01, )) {
Store(DMA0, DMAT)
}
}
If(LAnd(LAnd(And(ID53, 0x04, ), And(ID88,
0xff00, )), DMAT)) {
Store(Match(DerefOf(Index(TIM0, 0x03, )), MLE,
DMAT, MTR, 0x00, 0x00), Local1)
If(LGreater(Local1, 0x05)) {
Store(0x05, Local1)
}
GTFB(AT01, Or(0x40, Local1, ), Local7)
}
Else {
If(LAnd(And(ID63, 0xff00, ), PIOT)) {
And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,
PIOT, MTR, 0x00, 0x00), 0x03, Local0)
Or(0x20, DerefOf(Index(DerefOf(Index(TIM0,
0x07, )), Local0, )), Local1)
GTFB(AT01, Local1, Local7)
}
}
If(IRDY) {
And(Match(DerefOf(Index(TIM0, 0x00, )), MGE,
PIOT, MTR, 0x00, 0x00), 0x07, Local0)
Or(0x08, DerefOf(Index(DerefOf(Index(TIM0,
0x06, )), Local0, )), Local1)
GTFB(AT01, Local1, Local7)
}
Else {
If(And(ID49, 0x0400, )) {
GTFB(AT01, 0x01, Local7)
}
}
If(LAnd(And(ID59, 0x0100, ), And(ID59, 0xff, ))) {
GTFB(AT03, And(ID59, 0xff, ), Local7)
}
Store(ATAB, Debug)
Return(ATAB)
}
Method(RATA, 1) {
CreateByteField(Arg0, 0x00, CMDN)
Multiply(CMDN, 0x38, Local0)
CreateField(Arg0, 0x08, Local0, RETB)
Store(RETB, Debug)
Return(RETB)
}
}
Device(USB0) {
Name(_ADR, 0x001d0000)
OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
Field(BAR0, ByteAcc, NoLock, Preserve) {
USBW, 2,
Offset(0x1)
}
Method(_S3D) {
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
Return(0x02)
}
Else {
Return(0x03)
}
}
Method(_PSW, 1) {
If(Arg0) {
Store(0x03, USBW)
}
Else {
Store(0x00, USBW)
}
}
Method(_PRW) {
Return(GPRW(0x03, 0x03))
}
}
Device(USB1) {
Name(_ADR, 0x001d0001)
OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
Field(BAR0, ByteAcc, NoLock, Preserve) {
USBW, 2,
Offset(0x1)
}
Method(_S3D) {
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
Return(0x02)
}
Else {
Return(0x03)
}
}
Method(_PSW, 1) {
If(Arg0) {
Store(0x03, USBW)
}
Else {
Store(0x00, USBW)
}
}
Method(_PRW) {
Return(GPRW(0x04, 0x03))
}
}
Device(USB2) {
Name(_ADR, 0x001d0002)
OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
Field(BAR0, ByteAcc, NoLock, Preserve) {
USBW, 2,
Offset(0x1)
}
Method(_S3D) {
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
Return(0x02)
}
Else {
Return(0x03)
}
}
Method(_PSW, 1) {
If(Arg0) {
Store(0x03, USBW)
}
Else {
Store(0x00, USBW)
}
}
Method(_PRW) {
Return(GPRW(0x0c, 0x03))
}
}
Device(USB3) {
Name(_ADR, 0x001d0003)
OperationRegion(BAR0, PCI_Config, 0xc4, 0x01)
Field(BAR0, ByteAcc, NoLock, Preserve) {
USBW, 2,
Offset(0x1)
}
Method(_S3D) {
If(LOr(LEqual(OSFL(), 0x01), LEqual(OSFL(), 0x02))) {
Return(0x02)
}
Else {
Return(0x03)
}
}
Method(_PSW, 1) {
If(Arg0) {
Store(0x03, USBW)
}
Else {
Store(0x00, USBW)
}
}
Method(_PRW) {
Return(GPRW(0x0e, 0x03))
}
}
Device(EHCI) {
Name(_ADR, 0x001d0007)
Method(_PRW) {
Return(GPRW(0x0d, 0x03))
}
}
Device(MC97) {
Name(_ADR, 0x001e0003)
Method(_PRW) {
Return(GPRW(0x05, 0x04))
}
}
Device(P0P1) {
Name(_ADR, 0x001e0000)
Method(_PRW) {
Return(GPRW(0x0b, 0x04))
}
}
Device(SBRG) {
Name(_ADR, 0x001f0000)
Method(SPTS, 1) {
Store(One, PS1S)
Store(One, PS1S)
Store(One, PS1E)
If(LEqual(Arg0, 0x04)) {
Store(One, \_SB.PCI0.SBRG.EC.RSD3)
}
If(LEqual(Arg0, 0x05)) {
Store(Zero, \_SB.PCI0.SBRG.EC.RSD3)
}
}
Method(SWAK, 1) {
Store(Zero, PS1E)
If(LEqual(Arg0, 0x04)) {
Notify(\_SB.PWRB, 0x02)
}
}
OperationRegion(APMP, SystemIO, SMIP, 0x02)
Field(APMP, ByteAcc, NoLock, Preserve) {
APMC, 8,
APMS, 8
}
Field(APMP, ByteAcc, NoLock, Preserve) {
Offset(0x1),
, 1,
BRTC, 1
}
OperationRegion(PMS0, SystemIO, PMBS, 0x04)
Field(PMS0, ByteAcc, NoLock, Preserve) {
, 10,
RTCS, 1,
, 4,
WAKS, 1,
Offset(0x3),
PWBT, 1,
Offset(0x4)
}
OperationRegion(SMIE, SystemIO, PM30, 0x08)
Field(SMIE, ByteAcc, NoLock, Preserve) {
, 4,
PS1E, 1,
, 31,
PS1S, 1,
Offset(0x8)
}
Scope(\_SB) {
Name(PWRS, 0x00)
Device(PWRB) {
Name(_HID, 0x0c0cd041)
Method(_STA) {
Return(0x0b)
}
}
}
Scope(\_SB) {
Name(SLPS, 0x00)
Device(SLPB) {
Name(_HID, 0x0e0cd041)
Method(_STA) {
Return(0x0f)
}
}
}
Scope(\_SB) {
Scope(PCI0) {
Device(ICH7) {
Name(_HID, 0x010cd041)
Name(_UID, 0x01c7)
Name(_STA, 0x0f)
Name(ICHR, Buffer(0x56) {0x47, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0,
0xe0, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xb0, 0xff,
0x0, 0x0, 0x10, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x4, 0x80, 0xfc, 0x0,
0xc, 0x0, 0x0, 0x79, 0x0 })
Method(_CRS) {
CreateWordField(ICHR, 0x02, PBB)
CreateWordField(ICHR, 0x04, PBH)
CreateByteField(ICHR, 0x07, PML)
Store(\PMBS, PBB)
Store(\PMBS, PBH)
Store(\PMLN, PML)
If(SMBS) {
CreateWordField(ICHR, 0x0a, SMB)
CreateWordField(ICHR, 0x0c, SMH)
CreateByteField(ICHR, 0x0f, SML)
Store(\SMBS, SMB)
Store(\SMBS, SMH)
Store(\SMBL, SML)
}
If(GPBS) {
CreateWordField(ICHR, 0x12, IGB)
CreateWordField(ICHR, 0x14, IGH)
CreateByteField(ICHR, 0x17, IGL)
Store(\GPBS, IGB)
Store(\GPBS, IGH)
Store(\GPLN, IGL)
}
If(APCB) {
CreateDWordField(ICHR, 0x1c, APB)
CreateDWordField(ICHR, 0x20, APL)
Store(\APCB, APB)
Store(\APCL, APL)
}
CreateDWordField(ICHR, 0x34, RCB)
CreateDWordField(ICHR, 0x38, RCL)
Store(\SRCB, RCB)
Store(\SRCL, RCL)
Return(ICHR)
}
}
}
}
Device(SPKR) {
Name(_HID, 0x0008d041)
Name(_CRS, Buffer(0x0a) {0x47, 0x1, 0x61, 0x0, 0x61,
0x0, 0x0, 0x1, 0x79, 0x0 })
}
Device(PIC) {
Name(_HID, 0xd041)
Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20,
0x0, 0x0, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x0, 0x2, 0x22, 0x4,
0x0, 0x79, 0x0 })
}
Device(DMAD) {
Name(_HID, 0x0002d041)
Name(_CRS, Buffer(0x35) {0x2a, 0x10, 0x4, 0x47, 0x1,
0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x0,
0x3, 0x47, 0x1, 0x87, 0x0, 0x87, 0x0, 0x0, 0x1, 0x47, 0x1, 0x89, 0x0,
0x89, 0x0, 0x0, 0x3, 0x47, 0x1, 0x8f, 0x0, 0x8f, 0x0, 0x0, 0x1, 0x47,
0x1, 0xc0, 0x0, 0xc0, 0x0, 0x0, 0x20, 0x79, 0x0 })
}
Device(TMR) {
Name(_HID, 0x0001d041)
Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0x40, 0x0, 0x40,
0x0, 0x0, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
}
Device(RTC0) {
Name(_HID, 0x000bd041)
Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0x70, 0x0, 0x70,
0x0, 0x0, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
}
Device(RMSC) {
Name(_HID, 0x020cd041)
Name(_UID, 0x10)
Name(CRS, Buffer(0x7a) {0x47, 0x1, 0x10, 0x0, 0x10,
0x0, 0x0, 0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x0, 0x1e, 0x47,
0x1, 0x44, 0x0, 0x44, 0x0, 0x0, 0x1c, 0x47, 0x1, 0x63, 0x0, 0x63,
0x0, 0x0, 0x1, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x0, 0x1, 0x47, 0x1,
0x67, 0x0, 0x67, 0x0, 0x0, 0x9, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x0,
0xe, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x0, 0x1, 0x47, 0x1, 0x84, 0x0,
0x84, 0x0, 0x0, 0x3, 0x47, 0x1, 0x88, 0x0, 0x88, 0x0, 0x0, 0x1, 0x47,
0x1, 0x8c, 0x0, 0x8c, 0x0, 0x0, 0x3, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0,
0x0, 0x10, 0x47, 0x1, 0xa2, 0x0, 0xa2, 0x0, 0x0, 0x1e, 0x47, 0x1,
0xe0, 0x0, 0xe0, 0x0, 0x0, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4,
0x0, 0x2, 0x79, 0x0 })
Method(_CRS) {
Return(CRS)
}
}
Device(COPR) {
Name(_HID, 0x040cd041)
Name(_CRS, Buffer(0x0d) {0x47, 0x1, 0xf0, 0x0, 0xf0,
0x0, 0x0, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
}
Device(PS2K) {
Name(_HID, 0x0303d041)
Name(_CID, 0x0b03d041)
Method(_STA) {
Return(0x0f)
}
Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60,
0x0, 0x0, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x0, 0x1, 0x22, 0x2,
0x0, 0x79, 0x0 })
Name(_PRS, Buffer(0x10) {0x31, 0x0, 0x4b, 0x60, 0x0,
0x1, 0x4b, 0x64, 0x0, 0x1, 0x22, 0x2, 0x0, 0x38, 0x79, 0x0 })
}
Device(PS2M) {
Name(_HID, 0x030fd041)
Name(_CID, 0x130fd041)
Method(_STA) {
Return(0x0f)
}
Name(_CRS, Buffer(0x05) {0x22, 0x0, 0x10, 0x79, 0x0 })
Name(_PRS, Buffer(0x08) {0x31, 0x0, 0x22, 0x0, 0x10,
0x38, 0x79, 0x0 })
}
}
Device(P0P4) {
Name(_ADR, 0x001c0000)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR04)
}
Return(PR04)
}
Device(PSL0) {
Name(_ADR, 0x00)
}
}
Device(P0P5) {
Name(_ADR, 0x001c0001)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR05)
}
Return(PR05)
}
Device(PSL1) {
Name(_ADR, 0xffff)
}
}
Device(P0P6) {
Name(_ADR, 0x001c0002)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR06)
}
Return(PR06)
}
}
Device(P0P7) {
Name(_ADR, 0x001c0003)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR07)
}
Return(PR07)
}
}
Device(P0P8) {
Name(_ADR, 0x001c0004)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR08)
}
Return(PR08)
}
}
Device(P0P9) {
Name(_ADR, 0x001c0005)
Method(_PRW) {
Return(GPRW(0x09, 0x04))
}
Method(_PRT) {
If(PICM) {
Return(AR09)
}
Return(PR09)
}
}
Device(IGD) {
Name(_ADR, 0x00020000)
Method(_DOS, 1) {
Store(Arg0, SWIT)
}
Name(_DOD, Package(0x02) {
0x00010100,
0x00010410,
})
Device(CRT) {
Name(_ADR, 0x0100)
Name(_DCS, 0x1f)
Name(_DGS, 0x00)
Method(_DSS, 1) {
}
}
Device(LCD) {
Name(_ADR, 0x0410)
Name(_DCS, 0x1f)
Name(_DGS, 0x01)
Method(_DSS, 1) {
}
Name(LCFG, 0x00)
Name(LCBF, 0x00)
Method(_BCM, 1) {
If(LEqual(Arg0, 0x14)) {
Store(0x00, Local0)
}
If(LEqual(Arg0, 0x1e)) {
Store(0x01, Local0)
}
If(LEqual(Arg0, 0x28)) {
Store(0x02, Local0)
}
If(LEqual(Arg0, 0x32)) {
Store(0x03, Local0)
}
If(LEqual(Arg0, 0x3c)) {
Store(0x04, Local0)
}
If(LEqual(Arg0, 0x46)) {
Store(0x05, Local0)
}
If(LEqual(Arg0, 0x50)) {
Store(0x06, Local0)
}
If(LEqual(Arg0, 0x5a)) {
Store(0x07, Local0)
}
If(LEqual(Arg0, 0x64)) {
Store(0x08, Local0)
}
Store(Local0, LCBF)
Store(Local0, \_SB.PCI0.SBRG.EC.BRLV)
}
Name(PBCL, Package(0x0b) {
0x50,
0x14,
0x14,
0x1e,
0x28,
0x32,
0x3c,
0x46,
0x50,
0x5a,
0x64,
})
Method(_BCL) {
Return(PBCL)
}
Method(_BQC) {
If(LCFG) {
Store(LCBF, Local0)
}
Else {
Store(\_SB.PCI0.SBRG.EC.BRLV, Local0)
Store(Local0, LCBF)
Store(0x01, LCFG)
}
Add(Local0, 0x02, Local0)
Store(DerefOf(Index(PBCL, Local0, )), Local1)
Return(Local1)
}
}
Name(SWIT, 0x00)
Name(GDCS, 0x02)
Name(GDGS, 0x01)
Name(GDTS, 0x00)
Name(GDFG, 0x01)
}
}
Scope(\_GPE) {
Method(_L09) {
Notify(\_SB.PCI0.P0P2, 0x02)
Notify(\_SB.PCI0.P0P2.PEGP, 0x02)
Notify(\_SB.PCI0.P0P4, 0x02)
Notify(\_SB.PCI0.P0P5, 0x02)
Notify(\_SB.PCI0.P0P6, 0x02)
Notify(\_SB.PCI0.P0P7, 0x02)
Notify(\_SB.PCI0.P0P8, 0x02)
Notify(\_SB.PCI0.P0P9, 0x02)
}
Method(_L03) {
Notify(\_SB.PCI0.USB0, 0x02)
}
Method(_L04) {
Notify(\_SB.PCI0.USB1, 0x02)
}
Method(_L0C) {
Notify(\_SB.PCI0.USB2, 0x02)
}
Method(_L0E) {
Notify(\_SB.PCI0.USB3, 0x02)
}
Method(_L0D) {
Notify(\_SB.PCI0.EHCI, 0x02)
}
Method(_L05) {
Notify(\_SB.PCI0.MC97, 0x02)
}
Method(_L0B) {
Notify(\_SB.PCI0.P0P1, 0x02)
}
}
}
OperationRegion(\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x0c)
Field(\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve) {
PIRA, 8,
PIRB, 8,
PIRC, 8,
PIRD, 8,
Offset(0x8),
PIRE, 8,
PIRF, 8,
PIRG, 8,
PIRH, 8
}
Scope(\_SB) {
Name(BUFA, Buffer(0x06) {0x23, 0x0, 0x80, 0x18, 0x79, 0x0 })
CreateWordField(BUFA, 0x01, IRA0)
Device(LNKA) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x01)
Method(_STA) {
And(PIRA, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSA)
}
Method(_DIS) {
Or(PIRA, 0x80, PIRA)
}
Method(_CRS) {
And(PIRA, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRA)
}
}
Device(LNKB) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x02)
Method(_STA) {
And(PIRB, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSB)
}
Method(_DIS) {
Or(PIRB, 0x80, PIRB)
}
Method(_CRS) {
And(PIRB, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRB)
}
}
Device(LNKC) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x03)
Method(_STA) {
And(PIRC, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSC)
}
Method(_DIS) {
Or(PIRC, 0x80, PIRC)
}
Method(_CRS) {
And(PIRC, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRC)
}
}
Device(LNKD) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x04)
Method(_STA) {
And(PIRD, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSD)
}
Method(_DIS) {
Or(PIRD, 0x80, PIRD)
}
Method(_CRS) {
And(PIRD, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRD)
}
}
Device(LNKE) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x05)
Method(_STA) {
And(PIRE, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSE)
}
Method(_DIS) {
Or(PIRE, 0x80, PIRE)
}
Method(_CRS) {
And(PIRE, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRE)
}
}
Device(LNKF) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x06)
Method(_STA) {
And(PIRF, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSF)
}
Method(_DIS) {
Or(PIRF, 0x80, PIRF)
}
Method(_CRS) {
And(PIRF, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRF)
}
}
Device(LNKG) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x07)
Method(_STA) {
And(PIRG, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSG)
}
Method(_DIS) {
Or(PIRG, 0x80, PIRG)
}
Method(_CRS) {
And(PIRG, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRG)
}
}
Device(LNKH) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x08)
Method(_STA) {
And(PIRH, 0x80, Local0)
If(Local0) {
Return(0x09)
}
Else {
Return(0x0b)
}
}
Method(_PRS) {
Return(PRSH)
}
Method(_DIS) {
Or(PIRH, 0x80, PIRH)
}
Method(_CRS) {
And(PIRH, 0x0f, Local0)
ShiftLeft(0x01, Local0, IRA0)
Return(BUFA)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRA)
FindSetRightBit(IRA, Local0)
Decrement(Local0)
Store(Local0, PIRH)
}
}
}
Scope(\_PR) {
Processor(CPU0, 1, 0x410, 0x6) {
}
Processor(CPU1, 2, 0x410, 0x6) {
}
}
Scope(\_SB) {
Scope(PCI0) {
Method(_INI) {
}
Name(CRS, Buffer(0x88) {0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0,
0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc,
0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0,
0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3,
0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x87, 0x17, 0x0,
0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff,
0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0,
0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0,
0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
CreateDWordField(CRS, 0x5c, MIN5)
CreateDWordField(CRS, 0x60, MAX5)
CreateDWordField(CRS, 0x68, LEN5)
CreateDWordField(CRS, 0x76, MIN6)
CreateDWordField(CRS, 0x7a, MAX6)
CreateDWordField(CRS, 0x82, LEN6)
Method(_CRS) {
Store(MG1L, Local0)
If(Local0) {
Store(MG1B, MIN5)
Store(MG1L, LEN5)
Add(MIN5, Decrement(Local0), MAX5)
}
Store(MG2B, MIN6)
Store(MG2L, LEN6)
Store(MG2L, Local0)
Add(MIN6, Decrement(Local0), MAX6)
Return(CRS)
}
}
}
Name(WOTB, 0x00)
Name(WSSB, 0x00)
Name(WAXB, 0x00)
Method(_PTS, 1) {
Store(Arg0, DBG8)
PTS(Arg0)
Store(0x00, Index(WAKP, 0x00, ))
Store(0x00, Index(WAKP, 0x01, ))
Store(ASSB, WSSB)
Store(AOTB, WOTB)
Store(AAXB, WAXB)
Store(Arg0, ASSB)
Store(OSFL(), AOTB)
Store(Zero, AAXB)
}
Method(_WAK, 1) {
ShiftLeft(Arg0, 0x04, DBG8)
WAK(Arg0)
If(ASSB) {
Store(WSSB, ASSB)
Store(WOTB, AOTB)
Store(WAXB, AAXB)
}
If(DerefOf(Index(WAKP, 0x00, ))) {
Store(0x00, Index(WAKP, 0x01, ))
}
Else {
Store(Arg0, Index(WAKP, 0x01, ))
}
Return(WAKP)
}
OperationRegion(PMS0, SystemIO, PMBS, 0x02)
Field(PMS0, ByteAcc, NoLock, Preserve) {
Offset(0x1),
PWBT, 1,
, 1,
RTCS, 1,
, 4,
WAKS, 1
}
OperationRegion(SMIE, SystemIO, PM30, 0x08)
Field(SMIE, ByteAcc, NoLock, Preserve) {
, 4,
PS1E, 1,
, 31,
PS1S, 1,
Offset(0x8)
}
Scope(\_SB) {
Scope(PCI0) {
Device(HPET) {
Name(_HID, 0x0301d041)
Name(CRS, Buffer(0x0e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0,
0xd0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0 })
OperationRegion(HCNT, SystemMemory, \HPTC, 0x04)
Field(HCNT, DWordAcc, NoLock, Preserve) {
HPTS, 2,
, 5,
HPTE, 1
}
Method(_STA) {
If(LEqual(OSFL(), 0x00)) {
If(HPTE) {
Return(0x0f)
}
}
Else {
If(HPTE) {
Return(0x0b)
}
}
Return(0x00)
}
Method(_CRS) {
CreateDWordField(CRS, 0x04, HTBS)
Multiply(HPTS, 0x1000, Local0)
Add(Local0, 0xfed00000, HTBS)
Return(CRS)
}
}
}
}
Scope(\_SB) {
Scope(PCI0) {
Method(_OSC, 4) {
Name(SUPP, 0x00)
Name(CTRL, 0x00)
CreateDWordField(Arg3, 0x00, CDW1)
CreateDWordField(Arg3, 0x04, CDW2)
CreateDWordField(Arg3, 0x08, CDW3)
If(LEqual(Arg0, Buffer(0x10) {0x5b, 0x4d, 0xdb, 0x33,
0xf7, 0x1f, 0x1c, 0x40, 0x96, 0x57, 0x74, 0x41, 0xc0, 0x3d, 0xd7,
0x66 })) {
Store(CDW2, SUPP)
Store(CDW3, CTRL)
If(LNot(LEqual(And(SUPP, 0x16, ), 0x16))) {
And(CTRL, 0x1e, CTRL)
}
If(LNot(PEHP)) {
And(CTRL, 0x1e, CTRL)
}
If(LNot(SHPC)) {
And(CTRL, 0x1d, CTRL)
}
If(LNot(PEPM)) {
And(CTRL, 0x1b, CTRL)
}
If(LNot(PEER)) {
And(CTRL, 0x15, CTRL)
}
If(LNot(PECS)) {
And(CTRL, 0x0f, CTRL)
}
If(LNot(LEqual(Arg1, One))) {
Or(CDW1, 0x08, CDW1)
}
If(LNot(LEqual(CDW3, CTRL))) {
Or(CDW1, 0x10, CDW1)
}
Store(CTRL, CDW3)
Return(Arg3)
}
Else {
Or(CDW1, 0x04, CDW1)
Return(Arg3)
}
}
}
}
Device(OMSC) {
Name(_HID, 0x020cd041)
Name(_UID, 0x0e11)
}
Device(\_SB.RMEM) {
Name(_HID, 0x010cd041)
Name(_UID, 0x01)
}
Scope(\_SB.PCI0.SBRG) {
OperationRegion(RTCA, SystemIO, 0x72, 0x02)
Field(RTCA, ByteAcc, NoLock, Preserve) {
RTCI, 8,
RTCD, 8
}
Method(_INI) {
Store(CMOS, RTCI)
Store(OSFL(), RTCD)
}
}
Scope(\_TZ) {
Method(KELV, 1) {
And(Arg0, 0xff, Local0)
Multiply(Local0, 0x0a, Local0)
Add(Local0, 0x0aac, Local0)
Return(Local0)
}
ThermalZone(THRM) {
Method(_TMP) {
If(\_SB.PCI0.SBRG.EC.MYEC) {
If(\_SB.PCI0.SBRG.EC.CTSD) {
Store(0x00, \_SB.PCI0.SBRG.EC.CTSD)
Return(KELV(0x6e))
}
Else {
Store(\_SB.PCI0.SBRG.EC.CPUT, Local0)
Add(Local0, 0x02, Local0)
Return(KELV(Local0))
}
}
Else {
Return(KELV(0x2d))
}
}
Method(_CRT) {
Return(KELV(0x64))
}
}
}
Scope(\_SB.PCI0.SBRG) {
Device(EC) {
Name(_HID, 0x090cd041)
Name(_GPE, 0x17)
Name(CTID, 0x00)
Name(MYEC, 0x01)
Name(CTSD, 0x00)
Name(\PTHR, 0x00)
Method(_REG, 2) {
If(LEqual(Arg0, 0x03)) {
Store(Arg1, MYEC)
}
Store(0x00, CTSD)
}
Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,
0x0, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x0, 0x1, 0x79, 0x0 })
OperationRegion(EC, EmbeddedControl, 0x00, 0x0100)
Field(EC, ByteAcc, NoLock, Preserve) {
SMPR, 8,
SMST, 8,
SMAD, 8,
SMCM, 8,
SMD0, 264,
SMAA, 8,
Offset(0x2c),
HSTT, 1,
Offset(0x2d),
Offset(0x30),
POWS, 1,
LIDS, 1,
KBCS, 1,
Offset(0x31),
MBTS, 1,
MBCS, 1,
MBDS, 1,
MBFS, 1,
MBWS, 1,
MBLS, 1,
MBCL, 1,
MBFL, 1,
Offset(0x34),
HSKS, 3,
Offset(0x35),
Offset(0x38),
MDCL, 8,
MDCH, 8,
MDVL, 8,
MDVH, 8,
MCAL, 8,
MCAH, 8,
MSTL, 8,
MSTH, 8,
MCCL, 8,
MCCH, 8,
MPOL, 8,
MPOH, 8,
MFCL, 8,
MFCH, 8,
MCUL, 8,
MCUH, 8,
MRCL, 8,
MRCH, 8,
MVOL, 8,
MVOH, 8,
MTEL, 8,
MTEH, 8,
RSV1, 8,
RSD2, 4,
RSD3, 1,
RSD4, 3,
SDCL, 8,
SDCH, 8,
SDVL, 8,
SDVH, 8,
SCAL, 8,
SCAH, 8,
SSTL, 8,
SSTH, 8,
SCCL, 8,
SCCH, 8,
SPOL, 8,
SPOH, 8,
SFCL, 8,
SFCH, 8,
SCUL, 8,
SCUH, 8,
SRCL, 8,
SRCH, 8,
SVOL, 8,
SVOH, 8,
STEL, 8,
STEH, 8,
Offset(0x68),
CPUT, 8,
Offset(0x7e),
RES1, 3,
CHET, 1,
Offset(0x80),
SYST, 8,
Offset(0xc4),
BSFL, 1,
Offset(0xed),
SCIC, 8,
Offset(0xf1),
BRLV, 8,
Offset(0xfe),
DCBL, 8,
ACBL, 8
}
Device(ADP1) {
Name(_HID, "ACPI0003")
Name(BFLG, 0x01)
Name(ACP, 0x01)
Method(_PSR) {
If(\_SB.PCI0.SBRG.EC.POWS) {
Return(One)
}
Else {
Return(Zero)
}
}
Name(_PCL, Package(0x01) {
\_SB,
})
}
Name(BIF0, Package(0x0d) {
0x01,
0x1130,
0x1130,
0x01,
0x39d0,
0x00,
0x00,
0x01,
0x01,
"MS\x2dN021",
"1",
"LION",
"MSI\x20Corp.",
})
Name(STAT, Package(0x04) {
0x02,
0x0500,
0x0800,
0x03e8,
})
Device(BAT1) {
Name(_HID, 0x0a0cd041)
Name(_UID, 0x01)
Name(_PCL, Package(0x01) {
\_SB,
})
Name(SBT1, 0x3a)
Name(SBT2, 0x3a)
Name(FLG, 0x00)
Method(_STA) {
If(\_SB.PCI0.SBRG.EC.MYEC) {
If(\_SB.PCI0.SBRG.EC.MBTS) {
Return(0x1f)
}
Else {
Return(0x0f)
}
}
Else {
Return(0x0f)
}
}
Method(_BIF) {
If(\_SB.PCI0.SBRG.EC.MYEC) {
UPBI()
}
Else {
IVBI()
Store(0x99, DBG8)
Sleep(0x03e8)
}
Return(BIF0)
}
Method(_BST) {
If(\_SB.PCI0.SBRG.EC.MYEC) {
UPBS()
}
Else {
IVBS()
}
Return(STAT)
}
Method(IVBI) {
Store(0xffffffff, Index(BIF0, 0x01, ))
Store(0xffffffff, Index(BIF0, 0x02, ))
Store(0xffffffff, Index(BIF0, 0x04, ))
Store("Wrong", Index(BIF0, 0x09, ))
Store("\x20", Index(BIF0, 0x0a, ))
Store("Wrong", Index(BIF0, 0x0b, ))
Store("Wrong", Index(BIF0, 0x0c, ))
}
Method(IVBS) {
Store(0x00, Index(STAT, 0x00, ))
Store(0xffffffff, Index(STAT, 0x01, ))
Store(0xffffffff, Index(STAT, 0x02, ))
Store(0x2710, Index(STAT, 0x03, ))
}
Method(UPBI) {
Store(0x00, Local0)
Store(0x00, Local1)
Store(0x00, Local2)
Store(0x00, Local3)
Store(MDCH, Local0)
Store(MDCL, Local1)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local1, Local0)
Store(Local0, Index(BIF0, 0x01, ))
Store(MFCH, Local0)
Store(MFCL, Local1)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local1, Local1)
Store(Local1, Index(BIF0, 0x02, ))
Store(MDVH, Local0)
Store(MDVL, Local2)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local2, Local2)
Store(Local2, Index(BIF0, 0x04, ))
Store("\x0a", Index(BIF0, 0x0a, ))
Store("LION\x0a", Index(BIF0, 0x0b, ))
Store(CTID, Local0)
If(LEqual(Local0, 0x00)) {
Store("MS\x2dN021\x0a", Index(BIF0, 0x09, ))
Store("MSI\x20Corp.\x0a", Index(BIF0, 0x0c, ))
}
Else {
Store("\x3fMODEL\x0a", Index(BIF0, 0x09, ))
Store("\x3fCUSTOMER\x0a", Index(BIF0, 0x0c, ))
}
}
Method(UPBS) {
Store(0x00, Local0)
Store(0x00, Local1)
Store(0x00, Local2)
Store(0x00, Local3)
Store(0x00, Local4)
Store(0x00, Local7)
Store(MBTS, Local0)
If(LEqual(Local0, 0x01)) {
Store(POWS, Local0)
If(LEqual(Local0, 0x01)) {
Store(MBCS, Local1)
If(LEqual(Local1, 0x01)) {
Or(Local4, 0x02, Local4)
}
}
Else {
Or(Local4, 0x01, Local4)
Store(MBLS, Local0)
If(LEqual(Local0, 0x01)) {
Or(Local4, 0x04, Local4)
}
}
Store(POWS, Local0)
If(LEqual(Local0, 0x01)) {
Store(MBCS, Local0)
If(LEqual(Local0, 0x01)) {
Store(MCUH, Local0)
Store(MCUL, Local1)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local1, Local1)
If(LEqual(Local1, 0xffff)) {
Store(0xffffffff, Local1)
}
Store(Local1, Index(STAT, 0x01, ))
}
Else {
Store(0x00, Index(STAT, 0x01, ))
}
}
Else {
Store(MCUH, Local0)
Store(MCUL, Local1)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local1, Local1)
XOr(Local1, 0xffff, Local1)
If(LEqual(Local1, 0x00)) {
Store(0xffffffff, Local1)
}
Store(Local1, Index(STAT, 0x01, ))
}
If(LEqual(MRCH, 0x00)) {
If(LEqual(MRCL, 0x00)) {
Store(0x01, \_SB.PCI0.SBRG.EC.BAT1.FLG)
Store(0x01, \_SB.PCI0.SBRG.EC.BSFL)
}
}
If(LEqual(\_SB.PCI0.SBRG.EC.BAT1.FLG, 0x00)) {
Store(MRCH, Local0)
Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT1)
Store(MRCL, Local0)
Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT2)
}
Else {
Store(\_SB.PCI0.SBRG.EC.BAT1.SBT1, Local0)
Store(Local0, MRCH)
Store(\_SB.PCI0.SBRG.EC.BAT1.SBT2, Local0)
Store(Local0, MRCL)
Store(0x00, \_SB.PCI0.SBRG.EC.BAT1.FLG)
}
Store(MRCH, Local0)
Store(MRCL, Local2)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local2, Local2)
Store(Local2, Index(STAT, 0x02, ))
Store(MVOH, Local0)
Store(MVOL, Local3)
ShiftLeft(Local0, 0x08, Local0)
Or(Local0, Local3, Local3)
Store(Local3, Index(STAT, 0x03, ))
Store(Local4, Index(STAT, 0x00, ))
Sleep(0x64)
}
Else {
IVBS()
}
}
}
Device(LID0) {
Name(_HID, 0x0d0cd041)
Method(_LID) {
If(\_SB.PCI0.SBRG.EC.MYEC) {
Store(\_SB.PCI0.SBRG.EC.LIDS, Local0)
}
Else {
Store(0x01, Local0)
}
Return(Local0)
}
}
Method(_Q80) {
Store(0x80, SCIC)
Store(0x80, DBG8)
}
Method(_Q81) {
Store(0x81, SCIC)
Store(0x81, DBG8)
Store(One, CHET)
Or(0x01, \PTHR, \PTHR)
Notify(\_PR.CPU0, 0x80)
Sleep(0x64)
Notify(\_PR.CPU1, 0x80)
}
Method(_Q82) {
Store(0x82, SCIC)
Store(0x82, DBG8)
Store(One, CHET)
And(0xfe, \PTHR, \PTHR)
Notify(\_PR.CPU0, 0x80)
Sleep(0x64)
Notify(\_PR.CPU1, 0x80)
}
Method(_Q83) {
Store(0x83, SCIC)
Store(0x83, DBG8)
Store(0x00, Local0)
Store(POWS, Local0)
If(LEqual(Local0, 0x01)) {
Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.ACP)
}
Else {
Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.ACP)
}
Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
Sleep(0x64)
If(\_OSI("Windows\x202006")) {
}
Else {
Store(0x8c, APMC)
}
}
Method(_Q84) {
Store(0x84, SCIC)
Store(0x84, DBG8)
Notify(\_SB.PCI0.SBRG.EC.LID0, 0x80)
}
Method(_QBD) {
Store(0xbd, SCIC)
Store(0xbd, DBG8)
Notify(\_SB.SLPB, 0x80)
}
Method(_Q85) {
Store(0x85, SCIC)
Store(0x85, DBG8)
}
Method(_Q86) {
Store(0x86, SCIC)
Store(0x86, DBG8)
}
Method(_Q87) {
Store(0x87, SCIC)
Store(0x87, DBG8)
Store(0x00, Local0)
Store(MBTS, Local0)
If(LEqual(Local0, 0x01)) {
Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
If(LEqual(MRCH, 0x00)) {
If(LEqual(MRCL, 0x00)) {
Store(0x01, \_SB.PCI0.SBRG.EC.BAT1.FLG)
Store(0x01, \_SB.PCI0.SBRG.EC.BSFL)
}
}
If(LEqual(\_SB.PCI0.SBRG.EC.BAT1.FLG, 0x00)) {
Store(MRCH, Local0)
Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT1)
Store(MRCL, Local0)
Store(Local0, \_SB.PCI0.SBRG.EC.BAT1.SBT2)
}
Else {
Store(\_SB.PCI0.SBRG.EC.BAT1.SBT1, Local0)
Store(Local0, MRCH)
Store(\_SB.PCI0.SBRG.EC.BAT1.SBT2, Local0)
Store(Local0, MRCL)
Store(0x00, \_SB.PCI0.SBRG.EC.BAT1.FLG)
}
Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x80)
Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
}
Else {
Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
}
Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
}
Method(_Q77) {
Store(0x77, SCIC)
Store(0x77, DBG8)
Store(0x00, Local0)
Store(MBTS, Local0)
If(LEqual(Local0, 0x01)) {
Store(0x01, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x80)
}
Else {
Store(0x00, \_SB.PCI0.SBRG.EC.ADP1.BFLG)
Notify(\_SB.PCI0.SBRG.EC.BAT1, 0x81)
}
Notify(\_SB.PCI0.SBRG.EC.ADP1, 0x80)
}
Method(_Q88) {
Store(0x88, SCIC)
Store(0x88, DBG8)
}
Method(_Q89) {
Store(0x89, SCIC)
Store(0x89, DBG8)
}
Method(_Q8A) {
Store(0x8a, SCIC)
Store(0x8a, DBG8)
Store(0x01, \_SB.PCI0.SBRG.EC.CTSD)
Notify(\_TZ.THRM, 0x80)
}
Method(_Q8B) {
Store(0x8b, SCIC)
Store(0x8b, DBG8)
}
Method(_Q8C) {
Store(0x8c, SCIC)
Store(0x8c, DBG8)
}
Method(_Q90) {
Store(0x90, SCIC)
Store(0x90, DBG8)
}
Method(_QB4) {
Store(0xb4, SCIC)
Store(0xb4, DBG8)
If(LEqual(\_SB.PCI0.IGD.SWIT, 0x00)) {
Store(0xb4, APMC)
Store(APMS, Local0)
Store(Local0, DBG8)
If(LEqual(\_SB.PCI0.IGD.GDTS, 0x00)) {
If(LEqual(Local0, 0x01)) {
If(LEqual(\_SB.PCI0.IGD.GDGS, 0x01)) {
Store(0x00, \_SB.PCI0.IGD.LCD._DGS)
Store(0x01, \_SB.PCI0.IGD.CRT._DGS)
}
If(LEqual(\_SB.PCI0.IGD.GDGS, 0x02)) {
Store(0x01, \_SB.PCI0.IGD.LCD._DGS)
Store(0x01, \_SB.PCI0.IGD.CRT._DGS)
}
If(LEqual(\_SB.PCI0.IGD.GDGS, 0x03)) {
Store(0x01, \_SB.PCI0.IGD.LCD._DGS)
Store(0x00, \_SB.PCI0.IGD.CRT._DGS)
}
If(LNot(LLess(\_SB.PCI0.IGD.GDGS, 0x03))) {
Store(0x01, \_SB.PCI0.IGD.GDGS)
}
Else {
Add(0x01, \_SB.PCI0.IGD.GDGS,
\_SB.PCI0.IGD.GDGS)
}
}
Notify(\_SB.PCI0.IGD, 0x80)
}
}
}
Method(_QB5) {
Store(0xb5, SCIC)
Store(0xb5, DBG8)
}
Method(_QB6) {
Store(0xb6, SCIC)
Store(0xb6, DBG8)
}
Method(_QB7) {
Store(0xb7, SCIC)
Store(0xb7, DBG8)
If(\_OSI("Windows\x202006")) {
Notify(\_SB.PCI0.IGD.LCD, 0x87)
}
Else {
If(LNot(LEqual(BRLV, 0x00))) {
Store(BRLV, Local0)
Decrement(Local0)
Store(Local0, BRLV)
}
}
}
Method(_QB8) {
Store(0xb8, SCIC)
Store(0xb8, DBG8)
If(\_OSI("Windows\x202006")) {
Notify(\_SB.PCI0.IGD.LCD, 0x86)
}
Else {
If(LNot(LEqual(BRLV, 0x08))) {
Store(BRLV, Local0)
Increment(Local0)
Store(Local0, BRLV)
}
}
}
Method(_QB9) {
Store(0xb9, SCIC)
Store(0xb9, DBG8)
Store(0x00, \_SB.PCI0.SBRG.EC.HSTT)
}
OperationRegion(LP4D, SystemIO, 0x4d, 0x02)
Field(LP4D, WordAcc, NoLock, Preserve) {
IO4D, 16
}
OperationRegion(LP4F, SystemIO, 0x4f, 0x01)
Field(LP4F, ByteAcc, NoLock, Preserve) {
IO4F, 8
}
OperationRegion(IO, SystemIO, 0x62, 0x05)
Field(IO, ByteAcc, Lock, Preserve) {
DAT1, 8,
Offset(0x4),
CMD1, 8
}
Field(IO, ByteAcc, Lock, Preserve) {
Offset(0x4),
OUTS, 1,
INPS, 1
}
Method(IRDY, 0, Serialized) {
Return(LNot(INPS))
}
Method(ORDY, 0, Serialized) {
Return(OUTS)
}
Method(WATI, 0, Serialized) {
Store(0x32, Local0)
While(LAnd(Local0, LNot(IRDY()))) {
Sleep(0x01)
Decrement(Local0)
}
Return(IRDY())
}
Method(WATO, 0, Serialized) {
Store(0x32, Local0)
While(LAnd(Local0, LNot(ORDY()))) {
Sleep(0x01)
Decrement(Local0)
}
Return(ORDY())
}
Method(CLRB, 0, Serialized) {
While(WATO()) {
Store(DAT1, Local0)
}
}
Method(RDEC, 1, Serialized) {
If(WATI()) {
Store(0x80, CMD1)
If(WATI()) {
Store(Arg0, DAT1)
If(WATO()) {
Return(DAT1)
}
}
}
Return(Zero)
}
Method(WREC, 2, Serialized) {
Noop
}
Method(QREC, 0, Serialized) {
Noop
}
Method(_QC0) {
Store(0xc0, \_SB.PCI0.SBRG.EC.SCM0.TDED)
Store(0xc0, DBG8)
Notify(SCM0, 0xc0)
}
Device(SCM0) {
Name(_HID, "pnp0c14")
Name(_UID, 0x00)
Name(TDVR, 0x12)
Name(_WDG, Buffer(0xc8) {0x6a, 0x8d, 0x41, 0x24, 0x79,
0xa, 0x4c, 0x52, 0x9a, 0xb1, 0x18, 0xb7, 0x8c, 0xa6, 0x8c, 0xe7,
0x41, 0x41, 0x22, 0x1, 0x6b, 0xd5, 0xfb, 0x4a, 0x91, 0x9f, 0x49,
0x8f, 0x81, 0xf5, 0x99, 0x5b, 0xa7, 0x38, 0x22, 0xaf, 0x41, 0x42,
0x2, 0x1, 0x6c, 0xba, 0x3c, 0x2d, 0x9c, 0x1c, 0x41, 0x7f, 0xb5, 0x4c,
0xf5, 0xd5, 0xd5, 0x80, 0xd4, 0x82, 0x41, 0x43, 0x1, 0x1, 0x6d, 0x2,
0xba, 0x40, 0x5d, 0x7, 0x4a, 0xcd, 0x97, 0x10, 0xf7, 0xc5, 0x73,
0x47, 0xca, 0xc9, 0x41, 0x44, 0xf, 0x1, 0x6e, 0xcf, 0xbc, 0x8d, 0xb4,
0x9d, 0x46, 0xe, 0xa3, 0xf2, 0x99, 0xaf, 0xaa, 0xa7, 0x7a, 0x7a,
0x41, 0x45, 0xd, 0x1, 0x6f, 0x21, 0x2a, 0xbd, 0xb9, 0x2f, 0x40, 0xa6,
0xb8, 0x7, 0xdd, 0xdb, 0xad, 0x65, 0x68, 0x91, 0x41, 0x46, 0x13, 0x1,
0x7a, 0xec, 0xc3, 0x1e, 0x9b, 0x1e, 0x4a, 0xe7, 0x90, 0x26, 0xcf,
0x12, 0x2b, 0xb, 0xbd, 0x21, 0x41, 0x47, 0x12, 0x1, 0x7b, 0x3d, 0x75,
0xa1, 0x21, 0xb6, 0x4a, 0xde, 0xb4, 0x1a, 0x55, 0x71, 0x6a, 0xe,
0xce, 0x7a, 0x41, 0x48, 0x15, 0x1, 0x7c, 0x3d, 0x75, 0xa1, 0x21,
0xb6, 0x4a, 0xde, 0xb4, 0x1a, 0x55, 0x71, 0x6a, 0xe, 0xce, 0x7a,
0x41, 0x49, 0x8, 0x1, 0x8a, 0xc3, 0x3c, 0x5b, 0xd9, 0x40, 0x45, 0x72,
0x8a, 0xe6, 0x11, 0x45, 0xb7, 0x51, 0xbe, 0x3f, 0xc0, 0x0, 0x1, 0x9 })
OperationRegion(EC, EmbeddedControl, 0x00, 0x0100)
Field(EC, ByteAcc, NoLock, Preserve) {
Offset(0x2d),
T2D0, 1,
T2D1, 4,
T2D5, 3,
TD2E, 8,
TD2F, 8,
TD30, 8,
TD31, 8,
TD32, 8,
TD33, 8,
Offset(0x35),
TD35, 8,
TD36, 8,
Offset(0x38),
TD38, 16,
TD3A, 16,
TD3C, 16,
TD3E, 16,
TD40, 16,
TD42, 16,
TD44, 16,
TD46, 16,
TD48, 16,
TD4A, 16,
TD4C, 16,
Offset(0x50),
TD50, 16,
TD52, 16,
TD54, 16,
TD56, 16,
TD58, 16,
TD5A, 16,
TD5C, 16,
TD5E, 16,
TD60, 16,
TD62, 16,
TD64, 16,
Offset(0x68),
TD68, 8,
TD69, 8,
TD6A, 8,
TD6B, 8,
TD6C, 8,
TD6D, 8,
TD6E, 8,
TD6F, 8,
TD70, 8,
TD71, 8,
TD72, 8,
TD73, 8,
TD74, 8,
TD75, 8,
TD76, 8,
TD77, 8,
TD78, 8,
TD79, 8,
Offset(0x80),
TD80, 8,
TD81, 8,
TD82, 8,
TD83, 8,
TD84, 8,
TD85, 8,
TD86, 8,
TD87, 8,
TD88, 8,
TD89, 8,
TD8A, 8,
TD8B, 8,
TD8C, 8,
TD8D, 8,
TD8E, 8,
TD8F, 8,
TD90, 8,
Offset(0xa0),
TDA0, 8,
TDA1, 8,
TDA2, 8,
TDA3, 8,
TDA4, 8,
TDA5, 8,
TDA6, 8,
TDA7, 8,
TDA8, 8,
TDA9, 8,
TDAA, 8,
TDAB, 8,
TDAC, 8,
TDAD, 8,
TDAE, 8,
TDAF, 8,
TDB0, 8,
TDB1, 8,
TDB2, 8,
TDB3, 8,
TDB4, 8,
TDB5, 8,
TDB6, 8,
TDB7, 8,
TDB8, 8,
TDB9, 8,
TDBA, 8,
TDBB, 8,
Offset(0xc8),
TDC8, 8,
TDC9, 8,
TDCA, 8,
TDCB, 8,
TDCC, 8,
TDCD, 8,
TDCE, 8,
TDCF, 8,
Offset(0xe0),
TDE0, 8,
Offset(0xe3),
TDE3, 8,
TE40, 3,
TE43, 5,
TDE5, 8,
TDE6, 8,
TDE7, 8,
TDE8, 8,
TDE9, 8,
Offset(0xed),
TDED, 8,
TDEE, 8,
Offset(0xf0),
TDF0, 8,
TDF1, 8,
TDF2, 8,
TDF3, 8,
TDF4, 8,
TDF5, 8,
TDF6, 8,
TDF7, 8,
TDF8, 8,
TDF9, 8,
TDFA, 8,
TDFB, 8,
TDFC, 8,
TDFD, 8,
TDFE, 8,
TDFF, 8
}
Method(WQAA, 1) {
If(LEqual(Arg0, 0x00)) {
Store(T2D0, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(T2D1, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TDEE, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(T2D5, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TDE5, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TDE6, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TDA0, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TDA1, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TDA2, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TDA3, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TDA4, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TDA5, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TDA6, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0d)) {
Store(TDA7, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0e)) {
Store(TDA8, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0f)) {
Store(TDA9, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x10)) {
Store(TDAA, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x11)) {
Store(TDAB, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x12)) {
Store(TDAC, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x13)) {
Store(TDAD, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x14)) {
Store(TDAE, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x15)) {
Store(TDAF, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x16)) {
Store(TDB0, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x17)) {
Store(TDB1, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x18)) {
Store(TDB2, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x19)) {
Store(TDB3, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1a)) {
Store(TDB4, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1b)) {
Store(TDB5, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1c)) {
Store(TDB6, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1d)) {
Store(TDB7, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1e)) {
Store(TDB8, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x1f)) {
Store(TDB9, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x20)) {
Store(TDBA, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x21)) {
Store(TDBB, Local0)
Return(Local0)
}
}
Method(WQAB, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD2E, Local1)
Return(Local1)
}
If(LEqual(Arg0, 0x01)) {
Store(TD2F, Local1)
Return(Local1)
}
}
Method(WQAC, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD30, Local2)
Return(Local2)
}
}
Method(WQAD, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD31, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TD38, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TD3A, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TD3C, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TD3E, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TD40, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TD42, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TD44, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TD46, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TD48, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TD4A, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TD4C, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TDE8, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0d)) {
Store(TD35, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0e)) {
Store(TD36, Local0)
Return(Local0)
}
}
Method(WQAE, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD32, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TD50, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TD52, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TD54, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TD56, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TD58, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TD5A, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TD5C, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TD5E, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TD60, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TD62, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TD64, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TDE9, Local0)
Return(Local0)
}
}
Method(WQAF, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD33, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TD68, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TD71, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TD70, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TD69, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TD6A, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TD6B, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TD6C, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TD6D, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TD6E, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TD6F, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TD72, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TD73, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0d)) {
Store(TD74, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0e)) {
Store(TD75, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0f)) {
Store(TD76, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x10)) {
Store(TD77, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x11)) {
Store(TD78, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x12)) {
Store(TD79, Local0)
Return(Local0)
}
}
Method(WQAG, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TD33, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TD80, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TD89, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TD88, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TD81, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TD82, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TD83, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TD84, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TD85, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TD86, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TD87, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TD8A, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TD8B, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0d)) {
Store(TD8C, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0e)) {
Store(TD8D, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0f)) {
Store(TD8E, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x10)) {
Store(TD8F, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x11)) {
Store(TD90, Local0)
Return(Local0)
}
}
Method(WQAH, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TE40, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TE43, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TDE7, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TDF0, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TDF1, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TDFE, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TDFF, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TDF2, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x08)) {
Store(TDF3, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x09)) {
Store(TDF4, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0a)) {
Store(TDF5, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0b)) {
Store(TDF6, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0c)) {
Store(TDF7, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0d)) {
Store(TDF8, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0e)) {
Store(TDF9, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x0f)) {
Store(TDFA, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x10)) {
Store(TDFB, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x11)) {
Store(TDFC, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x12)) {
Store(TDFD, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x13)) {
Store(TDE0, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x14)) {
Store(TDE3, Local0)
Return(Local0)
}
}
Method(WQAI, 1) {
If(LEqual(Arg0, 0x00)) {
Store(TDCF, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x01)) {
Store(TDVR, TDCE)
Store(TDCE, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x02)) {
Store(TDCD, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x03)) {
Store(TDCC, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x04)) {
Store(TDCB, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x05)) {
Store(TDCA, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x06)) {
Store(TDC9, Local0)
Return(Local0)
}
If(LEqual(Arg0, 0x07)) {
Store(TDC8, Local0)
Return(Local0)
}
}
Method(WSAA, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, T2D0)
Return(T2D0)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, T2D1)
Return(T2D1)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TDEE)
Return(TDEE)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, T2D5)
Return(T2D5)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TDE5)
Return(TDE5)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TDE6)
Return(TDE6)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TDA0)
Return(TDA0)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TDA1)
Return(TDA1)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TDA2)
Return(TDA2)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TDA3)
Return(TDA3)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TDA4)
Return(TDA4)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TDA5)
Return(TDA5)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TDA6)
Return(TDA6)
}
If(LEqual(Arg0, 0x0d)) {
Store(Arg1, TDA7)
Return(TDA7)
}
If(LEqual(Arg0, 0x0e)) {
Store(Arg1, TDA8)
Return(TDA8)
}
If(LEqual(Arg0, 0x0f)) {
Store(Arg1, TDA9)
Return(TDA9)
}
If(LEqual(Arg0, 0x10)) {
Store(Arg1, TDAA)
Return(TDAA)
}
If(LEqual(Arg0, 0x11)) {
Store(Arg1, TDAB)
Return(TDAB)
}
If(LEqual(Arg0, 0x12)) {
Store(Arg1, TDAC)
Return(TDAC)
}
If(LEqual(Arg0, 0x13)) {
Store(Arg1, TDAD)
Return(TDAD)
}
If(LEqual(Arg0, 0x14)) {
Store(Arg1, TDAE)
Return(TDAE)
}
If(LEqual(Arg0, 0x15)) {
Store(Arg1, TDAF)
Return(TDAF)
}
If(LEqual(Arg0, 0x16)) {
Store(Arg1, TDB0)
Return(TDB0)
}
If(LEqual(Arg0, 0x17)) {
Store(Arg1, TDB1)
Return(TDB1)
}
If(LEqual(Arg0, 0x18)) {
Store(Arg1, TDB2)
Return(TDB2)
}
If(LEqual(Arg0, 0x19)) {
Store(Arg1, TDB3)
Return(TDB3)
}
If(LEqual(Arg0, 0x1a)) {
Store(Arg1, TDB4)
Return(TDB4)
}
If(LEqual(Arg0, 0x1b)) {
Store(Arg1, TDB5)
Return(TDB5)
}
If(LEqual(Arg0, 0x1c)) {
Store(Arg1, TDB6)
Return(TDB6)
}
If(LEqual(Arg0, 0x1d)) {
Store(Arg1, TDB7)
Return(TDB7)
}
If(LEqual(Arg0, 0x1e)) {
Store(Arg1, TDB8)
Return(TDB8)
}
If(LEqual(Arg0, 0x1f)) {
Store(Arg1, TDB9)
Return(TDB9)
}
If(LEqual(Arg0, 0x20)) {
Store(Arg1, TDBA)
Return(TDBA)
}
If(LEqual(Arg0, 0x21)) {
Store(Arg1, TDBB)
Return(TDBB)
}
}
Method(WSAB, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD2E)
Return(TD2E)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TD2F)
Return(TD2F)
}
}
Method(WSAC, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD30)
Return(TD30)
}
}
Method(WSAD, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD31)
Return(TD31)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TD38)
Return(TD38)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TD3A)
Return(TD3A)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TD3C)
Return(TD3C)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TD3E)
Return(TD3E)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TD40)
Return(TD40)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TD42)
Return(TD42)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TD44)
Return(TD44)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TD46)
Return(TD46)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TD48)
Return(TD48)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TD4A)
Return(TD4A)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TD4C)
Return(TD4C)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TDE8)
Return(TDE8)
}
If(LEqual(Arg0, 0x0d)) {
Store(Arg1, TD35)
Return(TD35)
}
If(LEqual(Arg0, 0x0e)) {
Store(Arg1, TD36)
Return(TD36)
}
}
Method(WSAE, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD32)
Return(TD32)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TD50)
Return(TD50)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TD52)
Return(TD52)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TD54)
Return(TD54)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TD56)
Return(TD56)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TD58)
Return(TD58)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TD5A)
Return(TD5A)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TD5C)
Return(TD5C)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TD5E)
Return(TD5E)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TD60)
Return(TD60)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TD62)
Return(TD62)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TD64)
Return(TD64)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TDE9)
Return(TDE9)
}
}
Method(WSAF, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD33)
Return(TD33)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TD68)
Return(TD68)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TD71)
Return(TD71)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TD70)
Return(TD70)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TD69)
Return(TD69)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TD6A)
Return(TD6A)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TD6B)
Return(TD6B)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TD6C)
Return(TD6C)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TD6D)
Return(TD6D)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TD6E)
Return(TD6E)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TD6F)
Return(TD6F)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TD72)
Return(TD72)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TD73)
Return(TD73)
}
If(LEqual(Arg0, 0x0d)) {
Store(Arg1, TD74)
Return(TD74)
}
If(LEqual(Arg0, 0x0e)) {
Store(Arg1, TD75)
Return(TD75)
}
If(LEqual(Arg0, 0x0f)) {
Store(Arg1, TD76)
Return(TD76)
}
If(LEqual(Arg0, 0x10)) {
Store(Arg1, TD77)
Return(TD77)
}
If(LEqual(Arg0, 0x11)) {
Store(Arg1, TD78)
Return(TD78)
}
If(LEqual(Arg0, 0x12)) {
Store(Arg1, TD79)
Return(TD79)
}
}
Method(WSAG, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TD33)
Return(TD33)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TD80)
Return(TD80)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TD89)
Return(TD89)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TD88)
Return(TD88)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TD81)
Return(TD81)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TD82)
Return(TD82)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TD83)
Return(TD83)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TD84)
Return(TD84)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TD85)
Return(TD85)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TD86)
Return(TD86)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TD87)
Return(TD87)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TD8A)
Return(TD8A)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TD8B)
Return(TD8B)
}
If(LEqual(Arg0, 0x0d)) {
Store(Arg1, TD8C)
Return(TD8C)
}
If(LEqual(Arg0, 0x0e)) {
Store(Arg1, TD8D)
Return(TD8D)
}
If(LEqual(Arg0, 0x0f)) {
Store(Arg1, TD8E)
Return(TD8E)
}
If(LEqual(Arg0, 0x10)) {
Store(Arg1, TD8F)
Return(TD8F)
}
If(LEqual(Arg0, 0x11)) {
Store(Arg1, TD90)
Return(TD90)
}
}
Method(WSAH, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TE40)
Return(TE40)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TE43)
Return(TE43)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TDE7)
Return(TDE7)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TDF0)
Return(TDF0)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TDF1)
Return(TDF1)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TDFE)
Return(TDFE)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TDFF)
Return(TDFF)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TDF2)
Return(TDF2)
}
If(LEqual(Arg0, 0x08)) {
Store(Arg1, TDF3)
Return(TDF3)
}
If(LEqual(Arg0, 0x09)) {
Store(Arg1, TDF4)
Return(TDF4)
}
If(LEqual(Arg0, 0x0a)) {
Store(Arg1, TDF5)
Return(TDF5)
}
If(LEqual(Arg0, 0x0b)) {
Store(Arg1, TDF6)
Return(TDF6)
}
If(LEqual(Arg0, 0x0c)) {
Store(Arg1, TDF7)
Return(TDF7)
}
If(LEqual(Arg0, 0x0d)) {
Store(Arg1, TDF8)
Return(TDF8)
}
If(LEqual(Arg0, 0x0e)) {
Store(Arg1, TDF9)
Return(TDF9)
}
If(LEqual(Arg0, 0x0f)) {
Store(Arg1, TDFA)
Return(TDFA)
}
If(LEqual(Arg0, 0x10)) {
Store(Arg1, TDFB)
Return(TDFB)
}
If(LEqual(Arg0, 0x11)) {
Store(Arg1, TDFC)
Return(TDFC)
}
If(LEqual(Arg0, 0x12)) {
Store(Arg1, TDFD)
Return(TDFD)
}
If(LEqual(Arg0, 0x13)) {
Store(Arg1, TDE0)
Return(TDE0)
}
If(LEqual(Arg0, 0x14)) {
Store(Arg1, TDE3)
Return(TDE3)
}
}
Method(WSAI, 2) {
If(LEqual(Arg0, 0x00)) {
Store(Arg1, TDCF)
Return(TDCF)
}
If(LEqual(Arg0, 0x01)) {
Store(Arg1, TDCE)
Return(TDCE)
}
If(LEqual(Arg0, 0x02)) {
Store(Arg1, TDCD)
Return(TDCD)
}
If(LEqual(Arg0, 0x03)) {
Store(Arg1, TDCC)
Return(TDCC)
}
If(LEqual(Arg0, 0x04)) {
Store(Arg1, TDCB)
Return(TDCB)
}
If(LEqual(Arg0, 0x05)) {
Store(Arg1, TDCA)
Return(TDCA)
}
If(LEqual(Arg0, 0x06)) {
Store(Arg1, TDC9)
Return(TDC9)
}
If(LEqual(Arg0, 0x07)) {
Store(Arg1, TDC8)
Return(TDC8)
}
}
Method(_WED, 1) {
If(LEqual(Arg0, 0xc0)) {
Name(EVRT, Buffer(0x02) {0x0, 0x0 })
Name(TMPB, 0x00)
Store(TDEE, TMPB)
Store(TMPB, Index(EVRT, 0x00, ))
If(LEqual(TMPB, 0x08)) {
Store(TE43, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x56)) {
Store(TD2E, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x57)) {
Store(TD2E, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x5f)) {
Store(TD2E, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x60)) {
Store(TE40, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x62)) {
Store(TDF1, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x63)) {
Store(TDF1, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x73)) {
Store(TE43, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0x79)) {
Store(TE43, Index(EVRT, 0x01, ))
}
If(LEqual(TMPB, 0xb4)) {
Store(TE43, Index(EVRT, 0x01, ))
}
Store(0x00, TDEE)
Return(EVRT)
}
Return(0x00)
}
}
}
}
Name(\_S0, Package(0x04) {
0x00,
0x00,
0x00,
0x00,
})
If(SS1) {
Name(\_S1, Package(0x04) {
0x01,
0x00,
0x00,
0x00,
})
}
If(SS3) {
Name(\_S3, Package(0x04) {
0x05,
0x00,
0x00,
0x00,
})
}
If(SS4) {
Name(\_S4, Package(0x04) {
0x06,
0x00,
0x00,
0x00,
})
}
Name(\_S5, Package(0x04) {
0x07,
0x00,
0x00,
0x00,
})
Method(PTS, 1) {
If(Arg0) {
\_SB.PCI0.NPTS(Arg0)
\_SB.PCI0.SBRG.SPTS(Arg0)
}
}
Method(WAK, 1) {
\_SB.PCI0.NWAK(Arg0)
\_SB.PCI0.SBRG.SWAK(Arg0)
}
}
/*
APIC: Length=92, Revision=2, Checksum=242,
OEMID=LGE, OEM Table ID=LGPC, OEM Revision=0x6222004,
Creator ID=MSFT, Creator Revision=0x10013
*/
/*
SSDT: Length=1230, Revision=2, Checksum=220,
OEMID=PmRef, OEM Table ID=CpuPm, OEM Revision=0x3000,
Creator ID=INTL, Creator Revision=0x20051117
*/
/*
SSDT: Length=562, Revision=2, Checksum=247,
OEMID=PmRef, OEM Table ID=Cpu0Tst, OEM Revision=0x3000,
Creator ID=INTL, Creator Revision=0x20051117
*/
/*
SSDT: Length=160, Revision=2, Checksum=183,
OEMID=PmRef, OEM Table ID=Cpu1Tst, OEM Revision=0x3000,
Creator ID=INTL, Creator Revision=0x20051117
*/
Regards,
Dave
>How-To-Repeat:
(As above.)
>Fix:
Unknown
>Release-Note:
>Audit-Trail:
Responsible-Changed-From-To: gnats-admin->kern-bug-people
Responsible-Changed-By: dholland@NetBSD.org
Responsible-Changed-When: Sat, 15 Aug 2009 18:47:25 +0000
Responsible-Changed-Why:
Sort out mangled PR.
>Unformatted:
(Contact us)
$NetBSD: query-full-pr,v 1.43 2018/01/16 07:36:43 maya Exp $
$NetBSD: gnats_config.sh,v 1.9 2014/08/02 14:16:04 spz Exp $
Copyright © 1994-2017
The NetBSD Foundation, Inc. ALL RIGHTS RESERVED.