On Tue, 29 Jun 2010 13:52:25 +0200, TorbjC8rn H. Orskaug
<[email protected]> wrote:
> On Tue, Jun 29, 2010 at 8:47 AM, [B&G-Consulting] Elmar Bschorer
> <[email protected]> wrote:
>> Hi list,
>>
>> i have a samsung p28 laptop running openbsd 4.7.
>> unfortunately apm as well as sysctl | grep acpi do not show up any
>> information about the battery state.
>> i guess samsung just shipped a crap acpi ;-) anyway - do you know any
>> solution how to get battery states from samsung acpi?
>>
>>
>> tia
>>
>> elmar
>>
>>
> 
> Without a dmesg and the output of apcidump, we can't really diagnose
> your problem any further.

et voilC :

dmesg:
------                                                                    
OpenBSD 4.7 (GENERIC) #558: Wed Mar 17 20:46:15 MDT 2010
[email protected]:/usr/src/sys/arch/i386/compile/GENERIC
cpu0: Intel(R) Pentium(R) M processor 1.60GHz ("GenuineIntel" 686-class)
1.61 GHz
cpu0:
FPU,V86,DE,PSE,TSC,MSR,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,CFLUSH,DS,ACPI,MMX,FXSR,SSE,SSE2,SS,TM,SBF,EST,TM2
real mem  = 804265984 (767MB)
avail mem = 770547712 (734MB)
mainbus0 at root
bios0 at mainbus0: AT/286+ BIOS, date 09/06/04, BIOS32 rev. 0 @ 0xfd710,
SMBIOS rev. 2.31 @ 0xe0010 (22 entries)
bios0: vendor SAMSUNG ELECTRONICS CO.,LTD version "D6OA.20040906.3032.HJU"
date 09/06/2004
bios0: SAMSUNG ELECTRONICS CO.,LTD P28
apm0 at bios0: Power Management spec V1.2 (BIOS management disabled)
apm0: APM power management enable: unrecognized device ID (9)
apm0: APM engage (device 1): power management disabled (1)
apm0: battery life expectancy 100%
apm0: AC on, battery charge high
acpi at bios0 function 0x0 not configured
pcibios0 at bios0: rev 2.1 @ 0xfd710/0x8f0
pcibios0: PCI IRQ Routing Table rev 1.0 @ 0xfdf20/192 (10 entries)
pcibios0: no compatible PCI ICU found: ICU vendor 0x1002 product 0x434c
pcibios0: Warning, unable to fix up PCI interrupt routing
pcibios0: PCI bus #3 is the last bus
bios0: ROM list: 0xc0000/0x10000 0xd0000/0x4000 0xd4000/0x1000
cpu0 at mainbus0: (uniprocessor)
cpu0: Enhanced SpeedStep 1601 MHz: speeds: 1600, 1400, 1200, 1000, 800, 600
MHz
pci0 at mainbus0 bus 0: configuration mode 1 (bios)
pchb0 at pci0 dev 0 function 0 "ATI RS300_100 Host" rev 0x02
agp at pchb0 not configured
ppb0 at pci0 dev 1 function 0 "ATI Radeon IGP 9100 AGP" rev 0x00
pci1 at ppb0 bus 1
vga1 at pci1 dev 5 function 0 "ATI Radeon Mobility M10" rev 0x00
wsdisplay0 at vga1 mux 1: console (80x25, vt100 emulation)
wsdisplay0: screen 1-5 added (80x25, vt100 emulation)
radeondrm0 at vga1: irq 10
drm0 at radeondrm0
ohci0 at pci0 dev 19 function 0 "ATI SB200 USB" rev 0x01: irq 9, version
1.0, legacy support
piixpm0 at pci0 dev 20 function 0 "ATI SB200 SMBus" rev 0x18: SMI
iic0 at piixpm0
admtemp0 at iic0 addr 0x4c: adm1032
spdmem0 at iic0 addr 0x50: 256MB DDR SDRAM non-parity PC2700CL2.5
spdmem1 at iic0 addr 0x51: 512MB DDR SDRAM non-parity PC2700CL2.5
pciide0 at pci0 dev 20 function 1 "ATI SB200 IDE" rev 0x00: DMA, channel 0
configured to compatibility, channel 1 configured to compatibility
wd0 at pciide0 channel 0 drive 0: <FUJITSU MHT2060AT>
wd0: 16-sector PIO, LBA, 57231MB, 117210240 sectors
wd0(pciide0:0:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 5
atapiscsi0 at pciide0 channel 1 drive 0
scsibus0 at atapiscsi0: 2 targets
cd0 at scsibus0 targ 0 lun 0: <TEAC, DV-W28E, S.0A> ATAPI 5/cdrom removable
cd0(pciide0:1:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 2
pcib0 at pci0 dev 20 function 3 "ATI SB200 ISA" rev 0x00
ppb1 at pci0 dev 20 function 4 "ATI SB200 PCI" rev 0x00
pci2 at ppb1 bus 2
mem address conflict 0x30000000/0x1000
io address conflict 0x5800/0x8
vendor "AT&T/Lucent", unknown product 0xab30 (class network subclass
miscellaneous, rev 0x00) at pci2 dev 3 function 0 not configured
cbb0 at pci2 dev 4 function 0 "Ricoh 5C475 CardBus" rev 0x81: couldn't map
interrupt
bce0 at pci2 dev 5 function 0 "Broadcom BCM4401B1" rev 0x02: irq 11,
address 00:00:f0:74:97:32
bmtphy0 at bce0 phy 1: BCM4401 10/100baseTX PHY, rev. 0
ohci1 at pci2 dev 6 function 0 "NEC USB" rev 0x43: irq 9, version 1.0,
legacy support
ohci2 at pci2 dev 6 function 1 "NEC USB" rev 0x43: irq 11, version 1.0,
legacy support
ehci0 at pci2 dev 6 function 2 "NEC USB" rev 0x04: irq 5
usb0 at ehci0: USB revision 2.0
uhub0 at usb0 "NEC EHCI root hub" rev 2.00/1.00 addr 1
usb1 at ohci1: USB revision 1.0
uhub1 at usb1 "NEC OHCI root hub" rev 1.00/1.00 addr 1
usb2 at ohci2: USB revision 1.0
uhub2 at usb2 "NEC OHCI root hub" rev 1.00/1.00 addr 1
auixp0 at pci0 dev 20 function 5 "ATI SB200 AC97" rev 0x00: irq 5
auixp0: soft resetting aclink
"ATI SB200 Modem" rev 0x01 at pci0 dev 20 function 6 not configured
usb3 at ohci0: USB revision 1.0
uhub3 at usb3 "ATI OHCI root hub" rev 1.00/1.00 addr 1
isa0 at pcib0
isadma0 at isa0
pckbc0 at isa0 port 0x60/5
pckbd0 at pckbc0 (kbd slot)
pckbc0: using irq 1 for kbd slot
wskbd0 at pckbd0: console keyboard, using wsdisplay0
pms0 at pckbc0 (aux slot)
pckbc0: using irq 12 for aux slot
wsmouse0 at pms0 mux 0
pcppi0 at isa0 port 0x61
midi0 at pcppi0: <PC speaker>
spkr0 at pcppi0
npx0 at isa0 port 0xf0/16: reported by CPUID; using exception 16
biomask effd netmask effd ttymask ffff
mtrr: Pentium Pro MTRR support
vscsi0 at root
scsibus1 at vscsi0: 256 targets
softraid0 at root
root on wd0a swap on wd0b dump on wd0b
ac97: codec id 0x41445374 (Analog Devices AD1981B)
ac97: codec features headphone, 20 bit DAC, No 3D Stereo
audio0 at auixp0



acpidump
--------
/*
RSD PTR: Checksum=38, OEMID=PTLTD, RsdtAddress=0x2ff7bb32
*/
/*
RSDT: Length=48, Revision=1, Checksum=30,
        OEMID=SEC, OEM Table ID=  MAGIC, OEM Revision=0x6040000,
        Creator ID= TPL, Creator Revision=0x0
*/
/*
        Entries={ 0x2ff7ecc0, 0x2ff7ed34, 0x2ff7ee51 }
*/
/*
        DSDT=0x2ff7bb62
        INT_MODEL=PIC
        SCI_INT=9
        SMI_CMD=0xb0, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0x0
        PM1a_EVT_BLK=0x8000-0x8003
        PM1a_CNT_BLK=0x8004-0x8005
        PM2_CNT_BLK=0x8050-0x8050
        PM2_TMR_BLK=0x8008-0x800a
        PM2_GPE0_BLK=0x8020-0x8027
        P_LVL2_LAT=18ms, P_LVL3_LAT=83ms
        FLUSH_SIZE=0, FLUSH_STRIDE=0
        DUTY_OFFSET=2, DUTY_WIDTH=2
        DAY_ALRM=13, MON_ALRM=0, CENTURY=72
        Flags={WBINVD,PROC_C1,SLP_BUTTON,TMR_VAL_EXT}
*/
/*
DSDT: Length=12638, Revision=1, Checksum=179,
        OEMID=SEC, OEM Table ID=MAGIC, OEM Revision=0x6040000,
        Creator ID=MSFT, Creator Revision=0x100000e
*/
DefinitionBlock (
"acpi_dsdt.aml",        //Output filename
"DSDT",                 //Signature
0x1,                    //DSDT Revision
"SEC",                  //OEMID
"MAGIC",                //TABLE ID
0x6040000                       //OEM Revision
)

{
Name(Z000, 0x1)
Name(Z001, 0x2)
Name(Z002, 0x4)
Name(Z003, 0x8)
Name(Z004, 0x0)
Name(Z005, 0xf)
Name(Z006, 0xd)
Name(Z007, 0xb)
Name(Z008, 0x9)
Scope(\_PR_) {
Processor(CPU0, 0, 0x8010, 0x6) {
}
}
Name(ACPS, 0x1)
Name(_S0_, Package(0x4) {
0x0,
0x0,
0x0,
0x0,
})
Name(_S3_, Package(0x4) {
0x3,
0x3,
0x0,
0x0,
})
Name(_S4_, Package(0x4) {
0x4,
0x4,
0x0,
0x0,
})
Name(_S5_, Package(0x4) {
0x5,
0x5,
0x0,
0x0,
})
OperationRegion(\DEBG, SystemIO, 0x1080, 0x1)
Field(\DEBG, ByteAcc, NoLock, Preserve) {
DBGP,   8
}
Method(_PTS, 1) {
\_SB_.PCI0.LPC0.PHS_(0x85)
If(LEqual(Arg0, 0x4)) {
\_SB_.PCI0.LPC0.PHS_(0x8e)
}
}
Method(_WAK, 1) {
If(LEqual(Arg0, 0x4)) {
Notify(\_SB_.PWRB, 0x2)
}
Store(\_SB_.PCI0.LPC0.H_EC.ACEX, \PWRS)
}
Scope(\_SI_) {
Method(_SST, 1) {
If(LEqual(Arg0, 0x1)) {
Store("===== SST Working =====", Debug)
}
If(LEqual(Arg0, 0x2)) {
Store("===== SST Waking =====", Debug)
}
If(LEqual(Arg0, 0x3)) {
Store("===== SST Sleeping =====", Debug)
}
If(LEqual(Arg0, 0x4)) {
Store("===== SST Sleeping S4 =====", Debug)
}
}
}
Scope(\_SB_) {
Name(OSTB, Ones)
OperationRegion(OSTY, SystemMemory, 0x2ff7ff4c, 0x00000001)
Field(OSTY, AnyAcc, NoLock, Preserve) {
TPOS,   8
}
Method(OSTP) {
If(LEqual(^OSTB, Ones)) {
If(CondRefOf(\_OSI, Local0)) {
If(\_OSI) {
"Windows 2001.1"
Store(0x20, ^OSTB)
Store(0x20, ^TPOS)
}
Else {
If(\_OSI) {
"Windows 2001 SP1"
Store(0x10, ^OSTB)
Store(0x10, ^TPOS)
}
Else {
If(\_OSI) {
"Windows 2001"
Store(0x8, ^OSTB)
Store(0x8, ^TPOS)
}
Else {
Store(0x0, ^OSTB)
Store(0x0, ^TPOS)
}
}
}
}
Else {
If(CondRefOf(\_OS_, Local0)) {
If(^SEQL(\_OS_, "Microsoft Windows")) {
Store(0x1, ^OSTB)
Store(0x1, ^TPOS)
}
Else {
If(^SEQL(\_OS_, "Microsoft WindowsME: Millennium Edition")) {
Store(0x2, ^OSTB)
Store(0x2, ^TPOS)
}
Else {
If(^SEQL(\_OS_, "Microsoft Windows NT")) {
Store(0x4, ^OSTB)
Store(0x4, ^TPOS)
}
Else {
Store(0x0, ^OSTB)
Store(0x0, ^TPOS)
}
}
}
}
Else {
Store(0x0, ^OSTB)
Store(0x0, ^TPOS)
}
}
}
Return(^OSTB)
}
Method(SEQL, 2, Serialized) {
Store(SizeOf(Arg0), Local0)
Store(SizeOf(Arg1), Local1)
If(LNot(LEqual(Local0, Local1))) {
Return(Zero)
}
Name(BUF0, Buffer(Local0) { })
Store(Arg0, BUF0)
Name(BUF1, Buffer(Local0) { })
Store(Arg1, BUF1)
Store(Zero, Local2)
While(LLess(Local2, Local0)) {
Store(DerefOf(Index(BUF0, Local2)), Local3)
Store(DerefOf(Index(BUF1, Local2)), Local4)
If(LNot(LEqual(Local3, Local4))) {
Return(Zero)
}
Increment(Local2)
}
Return(One)
}
}
Name(FWSO, "FWSO")
Name(_PSC, 0x0)
Method(_PS0) {
Store(_PSC, Local0)
Store(0x0, _PSC)
If(LEqual(Local0, 0x3)) {
Store(0x1, \_SB_.PCI0.LPC0.INF_)
While(\_SB_.PCI0.LPC0.INF_) {
Store(0x20, \_SB_.PCI0.LPC0.BCMD)
Store(Zero, \_SB_.PCI0.LPC0.SMIC)
If(LAnd(LEqual(\_SB_.PCI0.LPC0.INF_, 0x1), LNot(LLess(\_SB_.OSTB, 0x4)))) {
Sleep(0x01f4)
}
}
}
}
Method(_PS3) {
Store(0x3, _PSC)
}
Name(\GPIC, 0x0)
Name(\DSEN, 0x1)
Name(\ECON, 0x0)
Name(\CTYP, 0x0)
Name(\PDC0, 0x80000000)
Name(\PDC1, 0x80000000)
Name(\CADL, 0xffff)
Name(\PADL, 0xffff)
Name(\P80D, 0xffffffff)
Name(\CSTE, 0xffff)
Name(\NSTE, 0xffff)
Name(\SSTE, 0xffff)
Name(\LIDS, 0x1)
Name(\PWRS, 0x1)
Name(\C3EN, 0x1)
Method(\_PIC, 1) {
}
Method(HKDS, 1, Serialized) {
If(LEqual(0x0, DSEN)) {
Store(\_SB_.PCI0.LPC0.PHS5(0x80, Arg0, CADL, CSTE, NSTE), Local0)
If(LEqual(Local0, 0x0)) {
If(LNot(LEqual(CADL, PADL))) {
Store(CADL, PADL)
If(LNot(LLess(\_SB_.OSTB, 0x8))) {
Notify(\_SB_.PCI0, 0x0)
}
Else {
Notify(\_SB_.PCI0.AGP_.ATIM, 0x0)
}
Sleep(0x02ee)
}
Notify(\_SB_.PCI0.AGP_.ATIM, 0x80)
}
}
If(LEqual(0x1, DSEN)) {
Store(Increment(Arg0), Local1)
Store(\_SB_.PCI0.LPC0.PHS5(0x80, Local1, CADL, CSTE, NSTE), Local0)
If(LEqual(Local0, 0x0)) {
Notify(\_SB_.PCI0.AGP_.ATIM, 0x81)
}
}
}
Method(P8XH, 2, Serialized) {
If(LEqual(Arg0, 0x0)) {
Store(Or(And(P80D, 0xffffff00), Arg1), P80D)
}
If(LEqual(Arg0, 0x1)) {
Store(Or(And(P80D, 0xffff00ff), ShiftLeft(Arg1, 0x8)), P80D)
}
If(LEqual(Arg0, 0x2)) {
Store(Or(And(P80D, 0xff00ffff), ShiftLeft(Arg1, 0x10)), P80D)
}
If(LEqual(Arg0, 0x3)) {
Store(Or(And(P80D, 0x00ffffff), ShiftLeft(Arg1, 0x18)), P80D)
}
}
Scope(\_SB_) {
Device(BAT1) {
Name(_HID, 0x0a0cd041)
Name(_UID, 0x1)
Name(BATI, Package(0xd) {
0x1,
0xffffffff,
0xffffffff,
0x1,
0xffffffff,
0x3,
0xa,
0x1,
0x1,
"Unknown",
"Unknown",
"Unknown",
"Unknown",
})
Method(_BIF) {
If(LEqual(\ECON, 0x0)) {
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xb0, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x1))
}
Else {
Store(Local0, Index(BATI, 0x1))
}
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xb2, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x2))
}
Else {
Store(Local0, Index(BATI, 0x2))
}
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xb4, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x4))
}
Else {
Store(Local0, Index(BATI, 0x4))
}
Store(0x0, Index(BATI, 0x5))
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xb6, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(Zero, Index(BATI, 0x6))
}
Else {
Store(Local0, Index(BATI, 0x6))
}
}
Else {
Store(\_SB_.PCI0.LPC0.H_EC.B1AF, Local3)
Store(\_SB_.PCI0.LPC0.H_EC.B1VL, Local4)
Store(Local3, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x1))
}
Else {
Store(Local0, Index(BATI, 0x1))
}
Store(Local3, Local0)
ShiftRight(Local0, 0x10, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x2))
}
Else {
Store(Local0, Index(BATI, 0x2))
}
Store(Local4, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x4))
}
Else {
Store(Local0, Index(BATI, 0x4))
}
Store(0x0, Index(BATI, 0x5))
Store(Local4, Local0)
ShiftRight(Local0, 0x10, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(BATI, 0x6))
}
Else {
Store(Local0, Index(BATI, 0x6))
}
}
Store("", Index(BATI, 0x9))
Store("", Index(BATI, 0xa))
Store("LION", Index(BATI, 0xb))
Store("SAMSUNG Electronics", Index(BATI, 0xc))
Return(BATI)
}
Name(STAT, Package(0x4) {
0x0,
0x0,
0x0,
0x0,
})
Method(_BST) {
If(LEqual(\ECON, 0x0)) {
Store(\_SB_.PCI0.LPC0.PHS2(0x87, 0x84, 0x0), Local0)
If(LAnd(LNot(LEqual(Local0, 0x0)), LNot(LEqual(Local0, 0x5)))) {
If(LEqual(\PWRS, 0x1)) {
Store(0x2, Local0)
}
Else {
Store(0x1, Local0)
}
}
Store(Local0, Index(STAT, 0x0))
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xa4, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x1))
}
Else {
If(LNot(LLess(Local0, 0x8000))) {
XOr(Local0, 0xffff, Local0)
Increment(Local0)
}
Store(Local0, Index(STAT, 0x1))
}
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xa2, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x2))
}
Else {
Store(Local0, Index(STAT, 0x2))
}
Store(\_SB_.PCI0.LPC0.PHS2(0x88, 0xa6, 0x0), Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x3))
}
Else {
Store(Local0, Index(STAT, 0x3))
}
}
Else {
Store(\_SB_.PCI0.LPC0.H_EC.B1RR, Local3)
Store(\_SB_.PCI0.LPC0.H_EC.B1PV, Local4)
Store(Local3, Local0)
And(Local0, 0xff, Local0)
If(LAnd(LNot(LEqual(Local0, 0x0)), LNot(LEqual(Local0, 0x5)))) {
If(LEqual(\PWRS, 0x1)) {
Store(0x2, Local0)
}
Else {
Store(0x1, Local0)
}
}
Store(Local0, Index(STAT, 0x0))
Store(Local4, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x1))
}
Else {
If(LNot(LLess(Local0, 0x8000))) {
XOr(Local0, 0xffff, Local0)
Increment(Local0)
}
Store(Local0, Index(STAT, 0x1))
}
Store(Local3, Local0)
ShiftRight(Local0, 0x10, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x2))
}
Else {
Store(Local0, Index(STAT, 0x2))
}
Store(Local4, Local0)
ShiftRight(Local0, 0x10, Local0)
And(Local0, 0xffff, Local0)
ShiftLeft(Local0, 0x8, Local1)
And(Local1, 0xff00, Local1)
ShiftRight(Local0, 0x8, Local0)
Or(Local0, Local1, Local0)
If(LEqual(Local0, 0xffff)) {
Store(0xffffffff, Index(STAT, 0x3))
}
Else {
Store(Local0, Index(STAT, 0x3))
}
}
Return(STAT)
}
Method(_STA) {
If(LEqual(\ECON, 0x0)) {
If(LEqual(\_SB_.PCI0.LPC0.PHS1(0x81, 0x0), 0x1)) {
Store(0x1f, Local0)
}
Else {
Store(0xf, Local0)
}
}
Else {
If(LEqual(\_SB_.PCI0.LPC0.H_EC.B1EX, 0x1)) {
Store(0x1f, Local0)
}
Else {
Store(0xf, Local0)
}
}
Return(Local0)
}
Method(_PCL) {
Return(\_SB_)
}
}
Device(ADP1) {
Name(_HID, "ACPI0003")
Method(_PSR) {
If(LEqual(\ECON, 0x0)) {
Store(\_SB_.PCI0.LPC0.PHS1(0x81, 0x2), Local0)
}
Else {
Store(\_SB_.PCI0.LPC0.H_EC.ACEX, Local0)
}
Return(Local0)
}
Method(_PCL) {
Return(\_SB_)
}
Method(_STA) {
If(LEqual(\ECON, 0x0)) {
Store(\_SB_.PCI0.LPC0.PHS1(0x81, 0x2), Local0)
If(Local0) {
Store(0x1f, Local0)
}
Else {
Store(0xf, Local0)
}
}
Else {
Store(\_SB_.PCI0.LPC0.H_EC.ACEX, Local0)
If(Local0) {
Store(0x1f, Local0)
}
Else {
Store(0xf, Local0)
}
}
Return(Local0)
}
}
Device(PWRB) {
Name(_HID, 0x0c0cd041)
Name(_PRW, Package(0x2) {
0x5,
0x4,
})
}
Device(SLPB) {
Name(_HID, 0x0e0cd041)
}
Device(LID0) {
Name(_HID, 0x0d0cd041)
Method(_LID) {
Return(LIDS)
}
}
Device(PCI0) {
Name(_HID, 0x030ad041)
Name(_ADR, 0x0)
Name(_UID, 0x1)
Name(_BBN, 0x0)
Method(_INI) {
\_SB_.OSTP()
Store(\_SB_.PCI0.LPC0.PHS2(0x80, 0x0, 0x0), Local0)
Store(Local0, CADL)
Store(Local0, PADL)
Store(\_SB_.PCI0.LPC0.PHS1(0x81, 0x2), PWRS)
Store(\_SB_.PCI0.LPC0.PHS1(0x93, 0x2), C3EN)
}
Method(_S1D) {
Return(0x1)
}
Method(_S3D) {
Return(0x2)
}
Method(_S4D) {
Return(0x2)
}
OperationRegion(MREG, PCI_Config, 0x92, 0x2)
Field(MREG, ByteAcc, NoLock, Preserve) {
TOML,   8,
TOMH,   8
}
Method(TOM_) {
Multiply(TOML, 0x00010000, Local0)
Multiply(TOMH, 0x01000000, Local1)
Add(Local0, Local1, Local0)
Return(Local0)
}
OperationRegion(REGS, PCI_Config, 0x59, 0x8)
Field(REGS, ByteAcc, NoLock, Preserve) {
SR59,   8,
SR5A,   8,
SR5B,   8,
SR5C,   8,
SR5D,   8,
SR5E,   8,
SR5F,   8
}
Name(RSRC, Buffer(0x014b) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0,
0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0,
0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0,
0x0, 0x0, 0x80, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0,
0x0, 0xc0, 0xc, 0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40,
0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0,
0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40,
0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0,
0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd,
0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0,
0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0,
0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87,
0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
0xff, 0xfd, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1,
0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0,
0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc,
0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
Method(_CRS, 0, Serialized) {
CreateBitField(RSRC, 0x0188, C0RW)
CreateDWordField(RSRC, 0x42, C0LN)
Store(One, C0RW)
If(LEqual(SR5A, 0x1)) {
Store(Zero, C0RW)
}
Store(0x4000, C0LN)
If(And(SR5A, 0x3)) {
Store(0x0, C0LN)
}
CreateBitField(RSRC, 0x0260, C4RW)
CreateDWordField(RSRC, 0x5d, C4LN)
Store(One, C4RW)
If(LEqual(SR5A, 0x10)) {
Store(Zero, C4RW)
}
Store(0x4000, C4LN)
If(And(SR5A, 0x30)) {
Store(0x0, C4LN)
}
CreateBitField(RSRC, 0x0338, C8RW)
CreateDWordField(RSRC, 0x78, C8LN)
Store(One, C8RW)
If(LEqual(SR5B, 0x1)) {
Store(Zero, C8RW)
}
Store(0x4000, C8LN)
If(And(SR5B, 0x3)) {
Store(0x0, C8LN)
}
CreateBitField(RSRC, 0x0410, CCRW)
CreateDWordField(RSRC, 0x93, CCLN)
Store(One, CCRW)
If(LEqual(SR5B, 0x10)) {
Store(Zero, CCRW)
}
Store(0x4000, CCLN)
If(And(SR5B, 0x30)) {
Store(0x0, CCLN)
}
CreateBitField(RSRC, 0x04e8, D0RW)
CreateDWordField(RSRC, 0xae, D0LN)
Store(One, D0RW)
If(LEqual(SR5C, 0x1)) {
Store(Zero, D0RW)
}
Store(0x4000, D0LN)
If(And(SR5C, 0x3)) {
Store(0x0, D0LN)
}
CreateBitField(RSRC, 0x05c0, D4RW)
CreateDWordField(RSRC, 0xc9, D4LN)
Store(One, D4RW)
If(LEqual(SR5C, 0x10)) {
Store(Zero, D4RW)
}
Store(0x4000, D4LN)
If(And(SR5C, 0x30)) {
Store(0x0, D4LN)
}
CreateBitField(RSRC, 0x0698, D8RW)
CreateDWordField(RSRC, 0xe4, D8LN)
Store(One, D8RW)
If(LEqual(SR5D, 0x1)) {
Store(Zero, D8RW)
}
Store(0x4000, D8LN)
If(And(SR5D, 0x3)) {
Store(0x0, D8LN)
}
CreateBitField(RSRC, 0x0770, DCRW)
CreateDWordField(RSRC, 0xff, DCLN)
Store(One, DCRW)
If(LEqual(SR5D, 0x10)) {
Store(Zero, DCRW)
}
Store(0x4000, DCLN)
If(And(SR5D, 0x30)) {
Store(0x0, DCLN)
}
CreateDWordField(RSRC, 0x010e, BTMN)
CreateDWordField(RSRC, 0x0112, BTMX)
CreateDWordField(RSRC, 0x011a, BTLN)
Store(\_SB_.PCI0.TOM_(), BTMN)
Subtract(0xfec00000, BTMN, BTLN)
Subtract(Add(BTMN, BTLN), 0x1, BTMX)
Return(RSRC)
}
Method(_PRT) {
If(GPIC) {
Return(Package(0x5) {
Package(0x4) {
0x0013ffff,
0x0,
0x0,
0x13,
},
Package(0x4) {
0x0014ffff,
0x0,
0x0,
0x10,
},
Package(0x4) {
0x0014ffff,
0x1,
0x0,
0x11,
},
Package(0x4) {
0x0014ffff,
0x2,
0x0,
0x12,
},
Package(0x4) {
0x0014ffff,
0x3,
0x0,
0x13,
},
})
}
Else {
Return(Package(0x5) {
Package(0x4) {
0x0013ffff,
0x0,
\_SB_.PCI0.LPC0.LNK3,
0x0,
},
Package(0x4) {
0x0014ffff,
0x0,
\_SB_.PCI0.LPC0.LNK0,
0x0,
},
Package(0x4) {
0x0014ffff,
0x1,
\_SB_.PCI0.LPC0.LNK1,
0x0,
},
Package(0x4) {
0x0014ffff,
0x2,
\_SB_.PCI0.LPC0.LNK2,
0x0,
},
Package(0x4) {
0x0014ffff,
0x3,
\_SB_.PCI0.LPC0.LNK3,
0x0,
},
})
}
}
OperationRegion(BAR1, PCI_Config, 0x14, 0x4)
Field(BAR1, ByteAcc, NoLock, Preserve) {
Z009,   32
}
Device(LPC0) {
Name(_ADR, 0x00140003)
OperationRegion(PIRQ, SystemIO, 0x0c00, 0x2)
Field(PIRQ, ByteAcc, NoLock, Preserve) {
PIID,   8,
PIDA,   8
}
IndexField(PIID, PIDA, ByteAcc, NoLock, Preserve) {
PIR0,   8,
PIR1,   8,
PIR2,   8,
PIR3,   8,
PIRS,   8
}
Name(IPRS, Buffer(0x6) {0x23, 0x0, 0x4, 0x18, 0x79, 0x0 })
Method(DSPI) {
Store(0x0, PIR0)
Store(0x0, PIR1)
Store(0x0, PIR2)
Store(0x0, PIR3)
Store(0x0, PIRS)
}
Device(LNK0) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x1)
Method(_STA) {
If(PIR0) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x4, 0x18, 0x79, 0x0 })
Method(_DIS) {
Store(0x0, PIR0)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x1, IRQ0)
ShiftLeft(0x1, PIR0, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x1, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIR0)
}
}
Device(LNK1) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x2)
Method(_STA) {
If(PIR1) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Name(_PRS, Buffer(0x6) {0x23, 0x20, 0x0, 0x18, 0x79, 0x0 })
Method(_DIS) {
Store(0x0, PIR1)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x1, IRQ0)
ShiftLeft(0x1, PIR1, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x1, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIR1)
}
}
Device(LNK2) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x3)
Method(_STA) {
If(PIR2) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Name(_PRS, Buffer(0x6) {0x23, 0x40, 0x0, 0x18, 0x79, 0x0 })
Method(_DIS) {
Store(0x0, PIR2)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x1, IRQ0)
ShiftLeft(0x1, PIR2, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x1, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIR2)
}
}
Device(LNK3) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x4)
Method(_STA) {
If(PIR3) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x8, 0x18, 0x79, 0x0 })
Method(_DIS) {
Store(0x0, PIR3)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x1, IRQ0)
ShiftLeft(0x1, PIR3, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x1, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIR3)
}
}
OperationRegion(LPCR, PCI_Config, 0x44, 0x2)
Field(LPCR, ByteAcc, NoLock, Preserve) {
CMA0,   1,
CMA1,   1,
CMA2,   1,
CMA3,   1,
CMA4,   1,
CMA5,   1,
CMA6,   1,
CMA7,   1,
CMB0,   1,
CMB1,   1,
CMB2,   1,
CMB3,   1,
CMB4,   1,
CMB5,   1,
CMB6,   1,
CMB7,   1
}
Device(DMAC) {
Name(_HID, 0x0002d041)
Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x20, 0x47,
0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x10, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1,
0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
}
Device(MATH) {
Name(_HID, 0x040cd041)
Name(_CRS, Buffer(0xe) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 0xf, 0x23,
0x0, 0x20, 0x1, 0x79, 0x0 })
}
Device(PIC_) {
Name(_HID, 0xd041)
Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x1, 0x2, 0x47,
0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x23, 0x4, 0x0, 0x1, 0x79, 0x0 })
}
Device(RTC_) {
Name(_HID, 0x000bd041)
Name(_CRS, Buffer(0xe) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x2, 0x23,
0x0, 0x1, 0x1, 0x79, 0x0 })
}
Device(SPKR) {
Name(_HID, 0x0008d041)
Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0x1, 0x79,
0x0 })
}
Device(TIME) {
Name(_HID, 0x0001d041)
Name(_CRS, Buffer(0xe) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x1, 0x4, 0x23,
0x1, 0x0, 0x1, 0x79, 0x0 })
}
Device(KBC0) {
Name(_HID, 0x0303d041)
Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x1, 0x1, 0x47,
0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x23, 0x2, 0x0, 0x1, 0x79, 0x0 })
}
Device(MSE0) {
Name(_HID, 0x130fd041)
Name(_CRS, Buffer(0x6) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 })
}
Device(SYSR) {
Name(_HID, 0x020cd041)
Name(_CRS, Buffer(0x92) {0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47,
0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x2, 0x47, 0x1, 0x80, 0x10, 0x80, 0x10,
0x1, 0x1, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x2, 0x47, 0x1, 0x92, 0x0,
0x92, 0x0, 0x1, 0x1, 0x47, 0x1, 0x20, 0x2, 0x20, 0x2, 0x1, 0x10, 0x47, 0x1,
0xb, 0x4, 0xb, 0x4, 0x1, 0x1, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2,
0x47, 0x1, 0xd6, 0x4, 0xd6, 0x4, 0x1, 0x1, 0x47, 0x1, 0x30, 0x5, 0x30, 0x5,
0x8, 0x8, 0x47, 0x1, 0x0, 0xc, 0x0, 0xc, 0x1, 0x2, 0x47, 0x1, 0x14, 0xc,
0x14, 0xc, 0x1, 0x1, 0x47, 0x1, 0x50, 0xc, 0x50, 0xc, 0x1, 0x3, 0x47, 0x1,
0x6c, 0xc, 0x6c, 0xc, 0x1, 0x1, 0x47, 0x1, 0x6f, 0xc, 0x6f, 0xc, 0x1, 0x1,
0x47, 0x1, 0xd6, 0xc, 0xd6, 0xc, 0x1, 0x2, 0x47, 0x1, 0x0, 0x80, 0x0, 0x80,
0x1, 0x60, 0x47, 0x1, 0x40, 0xf, 0x40, 0xf, 0x1, 0x8, 0x79, 0x0 })
}
Device(MEM_) {
Name(_HID, 0x010cd041)
Name(MSRC, Buffer(0x3e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x2, 0x0,
0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0xf0, 0x7, 0x86, 0x9,
0x0, 0x0, 0x0, 0x0, 0xf8, 0xff, 0x0, 0x0, 0x8, 0x0, 0x86, 0x9, 0x0, 0x1,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
Method(_CRS) {
CreateDWordField(MSRC, 0x20, EMLN)
Subtract(\_SB_.PCI0.TOM_(), 0x00100000, EMLN)
If(LNot(LLess(TPOS, 0x4))) {
CreateDWordField(MSRC, 0x34, BARX)
CreateDWordField(MSRC, 0x38, GALN)
Store(0x1000, GALN)
Store(\_SB_.PCI0.Z009, Local0)
And(Local0, 0xfffffff0, BARX)
}
Return(MSRC)
}
Method(_STA) {
Return(0xf)
}
}
OperationRegion(SMI0, SystemIO, 0x00000f40, 0x00000002)
Field(SMI0, AnyAcc, NoLock, Preserve) {
SMIC,   8
}
OperationRegion(SMI1, SystemMemory, 0x2ff7fdbc, 0x00000190)
Field(SMI1, AnyAcc, NoLock, Preserve) {
BCMD,   8,
DID_,   32,
INFO,   1024
}
Field(SMI1, AnyAcc, NoLock, Preserve) {
AccessAs(ByteAcc, 0),
Offset(0x5),
INF_,   8,
INF1,   8,
INF2,   8,
INF3,   8
}
Field(SMI1, AnyAcc, NoLock, Preserve) {
Offset(0x5),
INFW,   16
}
Field(SMI1, AnyAcc, NoLock, Preserve) {
Offset(0x5),
INFD,   32
}
Field(SMI1, AnyAcc, NoLock, Preserve) {
Offset(0x5),
DAT_,   8,
DAT0,   8,
DAT1,   16,
DAT2,   16,
DAT3,   16
}
Mutex(MPHS, 0)
Method(PHS_, 1, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(INF_, Local7)
Release(MPHS)
Return(Local7)
}
Method(PHSR, 1, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(INFD, Local7)
Release(MPHS)
Return(Local7)
}
Method(PHS1, 2, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Arg1, INF_)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(INF_, Local7)
Release(MPHS)
Return(Local7)
}
Method(PHS2, 3, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Arg1, INF_)
Store(Arg2, INF1)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(INFW, Local7)
Release(MPHS)
Return(Local7)
}
Method(PHS4, 5, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Arg1, INF_)
Store(Arg2, INF1)
Store(Arg3, INF2)
Store(Arg4, INF3)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(INFD, Local7)
Release(MPHS)
Return(Local7)
}
Method(PHS5, 5, Serialized) {
Acquire(MPHS, 0xffff)
Store(Arg0, BCMD)
Store(Arg1, DAT_)
Store(Arg2, DAT1)
Store(Arg3, DAT2)
Store(Arg4, DAT3)
Store(Zero, SMIC)
Store(0x0, BCMD)
Store(DAT_, Local7)
Store(DAT1, CADL)
Store(DAT2, CSTE)
Store(DAT3, NSTE)
Release(MPHS)
Return(Local7)
}
Device(H_EC) {
Name(_HID, 0x090cd041)
Name(_UID, 0x1)
Method(_CRS) {
Name(BFFR, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x0, 0x1, 0x47,
0x1, 0x66, 0x0, 0x66, 0x0, 0x0, 0x1, 0x79, 0x0 })
Return(BFFR)
}
OperationRegion(ECR_, EmbeddedControl, 0x0, 0xff)
Field(ECR_, DWordAcc, Lock, Preserve) {
Offset(0x80),
B1EX,   1,
B2EX,   1,
ACEX,   1,
Offset(0x81),
SWBE,   1,
DCBE,   1,
Offset(0x82),
WLST,   1,
SDIF,   1,
Offset(0x83),
LIDS,   1,
Offset(0x84),
B1ST,   8,
B2ST,   8,
BRIT,   8,
Offset(0xa0),
B1RR,   32,
B1PV,   32,
B2RR,   32,
B2PV,   32,
B1AF,   32,
B1VL,   32,
B2AF,   32,
B2VL,   32,
CTMP,   8,
Offset(0xd0),
B1TI,   16,
B1SE,   16,
B1CR,   16,
B1TM,   16,
B2TI,   16,
B2SE,   16,
B2CR,   16,
B2TM,   16
}
Method(_REG, 2) {
If(LAnd(LEqual(Arg0, 0x3), LEqual(Arg1, 0x1))) {
Store(0x1, ECON)
Store(\_SB_.PCI0.LPC0.H_EC.ACEX, \PWRS)
}
}
Name(_GPE, 0x6)
Method(_GLK, 1) {
Return(One)
}
Method(_Q50) {
Notify(\_SB_.PWRB, 0x80)
}
Method(_Q51) {
\_SB_.PCI0.LPC0.PHS_(0x90)
Notify(\_SB_.ADP1, 0x80)
Store(0x1, \PWRS)
If(LNot(LLess(\_SB_.OSTB, 0x4))) {
Notify(\_PR_.CPU0, 0x81)
}
}
Method(_Q52) {
\_SB_.PCI0.LPC0.PHS_(0x91)
Notify(\_SB_.ADP1, 0x80)
Store(0x0, \PWRS)
If(LNot(LLess(\_SB_.OSTB, 0x4))) {
Notify(\_PR_.CPU0, 0x81)
}
}
Method(_Q53) {
Notify(\_SB_.BAT1, 0x80)
Notify(\_SB_.BAT1, 0x81)
}
Method(_Q54) {
Notify(\_SB_.BAT1, 0x80)
Notify(\_SB_.BAT1, 0x81)
}
Method(_Q5B) {
Notify(\_SB_.SLPB, 0x80)
}
Method(_Q5C) {
\_SB_.PCI0.LPC0.PHS_(0x83)
}
Method(_Q5D) {
P8XH(0x0, 0x84)
HKDS(0xa)
}
Method(_Q5E) {
Store(LIDS, \LIDS)
Notify(\_SB_.LID0, 0x80)
}
Method(_Q5F) {
Store(LIDS, \LIDS)
Notify(\_SB_.LID0, 0x80)
}
Method(_Q60) {
If(LEqual(B1EX, 0x1)) {
Notify(\_SB_.BAT1, 0x1)
}
}
Method(_Q61) {
If(LEqual(B1EX, 0x1)) {
Notify(\_SB_.BAT1, 0x1)
}
}
Method(_Q63) {
\_SB_.PCI0.LPC0.PHS_(0x8a)
}
Method(_Q64) {
\_SB_.PCI0.LPC0.PHS_(0x8b)
}
Method(_Q65) {
\_SB_.PCI0.LPC0.PHS_(0x92)
}
Method(_Q66) {
Notify(\_SB_.BAT1, 0x80)
}
Method(_Q69) {
BreakPoint
}
Method(_Q72) {
\_SB_.PCI0.LPC0.PHS_(0x82)
}
Method(_Q73) {
\_SB_.PCI0.LPC0.PHS_(0x94)
}
Method(_Q74) {
\_SB_.PCI0.LPC0.PHS_(0x95)
}
Method(_Q75) {
\_SB_.PCI0.LPC0.PHS_(0x96)
}
Method(_Q76) {
\_SB_.PCI0.LPC0.PHS_(0x97)
}
Method(_Q77) {
\_SB_.PCI0.LPC0.PHS_(0x98)
}
Method(_Q78) {
\_SB_.PCI0.LPC0.PHS_(0x99)
}
Method(_Q7A) {
\_SB_.PCI0.LPC0.PHS_(0x9a)
}
Method(_Q7B) {
\_SB_.PCI0.LPC0.PHS_(0x9b)
}
Method(_Q7C) {
\_SB_.PCI0.LPC0.PHS_(0x9c)
}
Method(_Q7D) {
\_SB_.PCI0.LPC0.PHS_(0x9d)
}
Method(_Q7E) {
\_SB_.PCI0.LPC0.PHS_(0x9e)
}
}
}
Device(P2P_) {
Name(_ADR, 0x00140004)
Device(CDB0) {
Name(_ADR, 0x00040000)
OperationRegion(CBD0, PCI_Config, 0x0, 0xf0)
Field(CBD0, AnyAcc, NoLock, Preserve) {
Offset(0x3c),
CD3C,   8,
Offset(0x44),
CD44,   32,
Offset(0xe0),
PWST,   8,
PMES,   8
}
Method(_INI) {
Or(CD3C, 0xff, CD3C)
Store(0x0, CD44)
}
Method(_PS0) {
And(PWST, 0xfc, PWST)
}
Method(_PS3) {
Or(PWST, 0x3, PWST)
}
Name(_PRW, Package(0x2) {
0x4,
0x3,
})
}
Device(NIC0) {
Name(_ADR, 0x00050000)
Name(_PRW, Package(0x2) {
0x4,
0x3,
})
}
Method(_PRT) {
If(GPIC) {
Return(Package(0x6) {
Package(0x4) {
0x0003ffff,
0x0,
0x0,
0x12,
},
Package(0x4) {
0x0004ffff,
0x0,
0x0,
0x10,
},
Package(0x4) {
0x0005ffff,
0x0,
0x0,
0x12,
},
Package(0x4) {
0x0006ffff,
0x0,
0x0,
0x13,
},
Package(0x4) {
0x0006ffff,
0x1,
0x0,
0x12,
},
Package(0x4) {
0x0006ffff,
0x2,
0x0,
0x11,
},
})
}
Else {
Return(Package(0x6) {
Package(0x4) {
0x0003ffff,
0x0,
\_SB_.PCI0.LPC0.LNK2,
0x0,
},
Package(0x4) {
0x0004ffff,
0x0,
\_SB_.PCI0.LPC0.LNK0,
0x0,
},
Package(0x4) {
0x0005ffff,
0x0,
\_SB_.PCI0.LPC0.LNK2,
0x0,
},
Package(0x4) {
0x0006ffff,
0x0,
\_SB_.PCI0.LPC0.LNK3,
0x0,
},
Package(0x4) {
0x0006ffff,
0x1,
\_SB_.PCI0.LPC0.LNK2,
0x0,
},
Package(0x4) {
0x0006ffff,
0x2,
\_SB_.PCI0.LPC0.LNK1,
0x0,
},
})
}
}
}
Device(OHC1) {
Name(_ADR, 0x00130000)
}
Device(OHC2) {
Name(_ADR, 0x00130001)
}
Device(EHCI) {
Name(_ADR, 0x00130002)
}
Device(AUDO) {
Name(_ADR, 0x00140005)
}
Device(MODM) {
Name(_ADR, 0x00140006)
Name(_PRW, Package(0x2) {
0xc,
0x3,
})
}
Device(IDE_) {
Name(_ADR, 0x00140001)
Name(UDMT, Package(0x8) {
0x78,
0x5a,
0x3c,
0x2d,
0x1e,
0x14,
0x0,
0x0,
})
Name(PIOT, Package(0x6) {
0x0258,
0x0186,
0x010e,
0xb4,
0x78,
0x0,
})
Name(PITR, Package(0x6) {
0x99,
0x47,
0x34,
0x22,
0x20,
0x99,
})
Name(MDMT, Package(0x4) {
0x01e0,
0x96,
0x78,
0x0,
})
Name(MDTR, Package(0x4) {
0x77,
0x21,
0x20,
0xff,
})
OperationRegion(IDE_, PCI_Config, 0x40, 0x20)
Field(IDE_, WordAcc, NoLock, Preserve) {
PPIT,   16,
SPIT,   16,
PMDT,   16,
SMDT,   16,
PPIC,   8,
SPIC,   8,
PPIM,   8,
SPIM,   8,
Offset(0x14),
PUDC,   2,
SUDC,   2,
Offset(0x16),
PUDM,   8,
SUDM,   8
}
Method(GETT, 1) {
Store(And(Arg0, 0xf), Local0)
Store(ShiftRight(Arg0, 0x4), Local1)
Return(Multiply(0x1e, Add(Add(Local0, 0x1), Add(Local1, 0x1))))
}
Method(GTM_, 1) {
CreateByteField(Arg0, 0x0, PIT1)
CreateByteField(Arg0, 0x1, PIT0)
CreateByteField(Arg0, 0x2, MDT1)
CreateByteField(Arg0, 0x3, MDT0)
CreateByteField(Arg0, 0x4, PICX)
CreateByteField(Arg0, 0x5, UDCX)
CreateByteField(Arg0, 0x6, UDMX)
Name(BUF_, Buffer(0x14) {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0 })
CreateDWordField(BUF_, 0x0, PIO0)
CreateDWordField(BUF_, 0x4, DMA0)
CreateDWordField(BUF_, 0x8, PIO1)
CreateDWordField(BUF_, 0xc, DMA1)
CreateDWordField(BUF_, 0x10, FLAG)
If(And(PICX, 0x1)) {
Return(BUF_)
}
Store(GETT(PIT0), PIO0)
Store(GETT(PIT1), PIO1)
If(And(UDCX, 0x1)) {
Or(FLAG, 0x1, FLAG)
Store(DerefOf(Index(^UDMT, And(UDMX, 0xf))), DMA0)
}
Else {
Store(GETT(MDT0), DMA0)
}
If(And(UDCX, 0x2)) {
Or(FLAG, 0x4, FLAG)
Store(DerefOf(Index(^UDMT, ShiftRight(UDMX, 0x4))), DMA1)
}
Else {
Store(GETT(MDT1), DMA1)
}
Or(FLAG, 0x1a, FLAG)
Return(BUF_)
}
Method(STM_, 3) {
CreateDWordField(Arg0, 0x0, PIO0)
CreateDWordField(Arg0, 0x4, DMA0)
CreateDWordField(Arg0, 0x8, PIO1)
CreateDWordField(Arg0, 0xc, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
Name(BUF_, Buffer(0x7) {0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0 })
CreateByteField(BUF_, 0x0, PIT1)
CreateByteField(BUF_, 0x1, PIT0)
CreateByteField(BUF_, 0x2, MDT1)
CreateByteField(BUF_, 0x3, MDT0)
CreateByteField(BUF_, 0x4, PIMX)
CreateByteField(BUF_, 0x5, UDCX)
CreateByteField(BUF_, 0x6, UDMX)
Store(Match(^PIOT, MLE, PIO0, MTR, 0x0, 0x0), Local0)
Divide(Local0, 0x5, Local0)
Store(Match(^PIOT, MLE, PIO1, MTR, 0x0, 0x0), Local1)
Divide(Local1, 0x5, Local1)
Store(Or(ShiftLeft(Local1, 0x4), Local0), PIMX)
Store(DerefOf(Index(^PITR, Local0)), PIT0)
Store(DerefOf(Index(^PITR, Local1)), PIT1)
If(And(FLAG, 0x1)) {
Store(Match(^UDMT, MLE, DMA0, MTR, 0x0, 0x0), Local0)
Divide(Local0, 0x6, Local0)
Or(UDMX, Local0, UDMX)
Or(UDCX, 0x1, UDCX)
}
Else {
If(LNot(LEqual(DMA0, 0xffffffff))) {
Store(Match(^MDMT, MLE, DMA0, MTR, 0x0, 0x0), Local0)
Store(DerefOf(Index(^MDTR, Local0)), MDT0)
}
}
If(And(FLAG, 0x4)) {
Store(Match(^UDMT, MLE, DMA1, MTR, 0x0, 0x0), Local0)
Divide(Local0, 0x6, Local0)
Or(UDMX, ShiftLeft(Local0, 0x4), UDMX)
Or(UDCX, 0x2, UDCX)
}
Else {
If(LNot(LEqual(DMA1, 0xffffffff))) {
Store(Match(^MDMT, MLE, DMA1, MTR, 0x0, 0x0), Local0)
Store(DerefOf(Index(^MDTR, Local0)), MDT1)
}
}
Return(BUF_)
}
Method(GTF_, 2) {
CreateByteField(Arg1, 0x0, MDT1)
CreateByteField(Arg1, 0x1, MDT0)
CreateByteField(Arg1, 0x2, PIMX)
CreateByteField(Arg1, 0x3, UDCX)
CreateByteField(Arg1, 0x4, UDMX)
If(LEqual(Arg0, 0xa0)) {
Store(And(PIMX, 0xf), Local0)
Store(MDT0, Local1)
And(UDCX, 0x1, Local2)
Store(And(UDMX, 0xf), Local3)
}
Else {
Store(ShiftRight(PIMX, 0x4), Local0)
Store(MDT1, Local1)
And(UDCX, 0x2, Local2)
Store(ShiftRight(UDMX, 0x4), Local3)
}
Name(BUF_, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xef, 0x3, 0x0, 0x0,
0x0, 0x0, 0xff, 0xef })
CreateByteField(BUF_, 0x1, PMOD)
CreateByteField(BUF_, 0x8, DMOD)
CreateByteField(BUF_, 0x5, CMDA)
CreateByteField(BUF_, 0xc, CMDB)
Store(Arg0, CMDA)
Store(Arg0, CMDB)
Or(Local0, 0x8, PMOD)
If(Local2) {
Or(Local3, 0x40, DMOD)
}
Else {
Store(Match(^MDMT, MLE, GETT(Local1), MTR, 0x0, 0x0), Local4)
If(LLess(Local4, 0x3)) {
Or(0x20, Local4, DMOD)
}
}
Return(BUF_)
}
Device(PRID) {
Name(_ADR, 0x0)
Method(_GTM) {
Name(BUF_, Buffer(0x7) {0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VPIT)
CreateWordField(BUF_, 0x2, VMDT)
CreateByteField(BUF_, 0x4, VPIC)
CreateByteField(BUF_, 0x5, VUDC)
CreateByteField(BUF_, 0x6, VUDM)
Store(^^PPIT, VPIT)
Store(^^PMDT, VMDT)
Store(^^PPIC, VPIC)
Store(^^PUDC, VUDC)
Store(^^PUDM, VUDM)
Return(GTM_(BUF_))
}
Method(_STM, 3) {
Name(BUF_, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VPIT)
CreateWordField(BUF_, 0x2, VMDT)
CreateByteField(BUF_, 0x4, VPIM)
CreateByteField(BUF_, 0x5, VUDC)
CreateByteField(BUF_, 0x6, VUDM)
Store(STM_(Arg0, Arg1, Arg2), BUF_)
Store(VPIT, ^^PPIT)
Store(VMDT, ^^PMDT)
Store(VPIM, ^^PPIM)
Store(VUDC, ^^PUDC)
Store(VUDM, ^^PUDM)
CreateDWordField(Arg0, 0x4, PDMA)
CreateDWordField(Arg0, 0x10, SDMA)
CreateWordField(Arg1, 0x0, AIDM)
CreateWordField(Arg2, 0x0, AIDS)
Store(Zero, Local0)
If(LEqual(And(AIDM, 0xc000), 0x8000)) {
If(LAnd(LNot(LEqual(PDMA, 0x0)), LNot(LEqual(PDMA, Ones)))) {
Or(Local0, 0x1, Local0)
}
}
If(LEqual(And(AIDS, 0xc000), 0x8000)) {
If(LAnd(LNot(LEqual(SDMA, 0x0)), LNot(LEqual(SDMA, Ones)))) {
Or(Local0, 0x2, Local0)
}
}
}
Device(P_D0) {
Name(_ADR, 0x0)
Method(_GTF) {
Name(BUF_, Buffer(0x5) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VMDT)
CreateByteField(BUF_, 0x2, VPIM)
CreateByteField(BUF_, 0x3, VUDC)
CreateByteField(BUF_, 0x4, VUDM)
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
Return(GTF_(0xa0, BUF_))
}
}
Device(P_D1) {
Name(_ADR, 0x1)
Method(_GTF) {
Name(BUF_, Buffer(0x5) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VMDT)
CreateByteField(BUF_, 0x2, VPIM)
CreateByteField(BUF_, 0x3, VUDC)
CreateByteField(BUF_, 0x4, VUDM)
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
Return(GTF_(0xb0, BUF_))
}
}
}
Device(SECD) {
Name(_ADR, 0x1)
Method(_GTM) {
Name(BUF_, Buffer(0x7) {0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VPIT)
CreateWordField(BUF_, 0x2, VMDT)
CreateByteField(BUF_, 0x4, VPIC)
CreateByteField(BUF_, 0x5, VUDC)
CreateByteField(BUF_, 0x6, VUDM)
Store(^^SPIT, VPIT)
Store(^^SMDT, VMDT)
Store(^^SPIC, VPIC)
Store(^^SUDC, VUDC)
Store(^^SUDM, VUDM)
Return(GTM_(BUF_))
}
Method(_STM, 3) {
Name(BUF_, Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VPIT)
CreateWordField(BUF_, 0x2, VMDT)
CreateByteField(BUF_, 0x4, VPIM)
CreateByteField(BUF_, 0x5, VUDC)
CreateByteField(BUF_, 0x6, VUDM)
Store(STM_(Arg0, Arg1, Arg2), BUF_)
Store(VPIT, ^^SPIT)
Store(VMDT, ^^SMDT)
Store(VPIM, ^^SPIM)
Store(VUDC, ^^SUDC)
Store(VUDM, ^^SUDM)
CreateDWordField(Arg0, 0x4, PDMA)
CreateDWordField(Arg0, 0x10, SDMA)
CreateWordField(Arg1, 0x0, AIDM)
CreateWordField(Arg2, 0x0, AIDS)
Store(0x10, Local0)
If(LEqual(And(AIDM, 0xc000), 0x8000)) {
If(LAnd(LNot(LEqual(PDMA, 0x0)), LNot(LEqual(PDMA, Ones)))) {
Or(Local0, 0x1, Local0)
}
}
If(LEqual(And(AIDS, 0xc000), 0x8000)) {
If(LAnd(LNot(LEqual(SDMA, 0x0)), LNot(LEqual(SDMA, Ones)))) {
Or(Local0, 0x2, Local0)
}
}
}
Device(S_D0) {
Name(_ADR, 0x0)
Method(_GTF) {
Name(BUF_, Buffer(0x5) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VMDT)
CreateByteField(BUF_, 0x2, VPIM)
CreateByteField(BUF_, 0x3, VUDC)
CreateByteField(BUF_, 0x4, VUDM)
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
Return(GTF_(0xa0, BUF_))
}
}
Device(S_D1) {
Name(_ADR, 0x1)
Method(_GTF) {
Name(BUF_, Buffer(0x5) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateWordField(BUF_, 0x0, VMDT)
CreateByteField(BUF_, 0x2, VPIM)
CreateByteField(BUF_, 0x3, VUDC)
CreateByteField(BUF_, 0x4, VUDM)
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
Return(GTF_(0xb0, BUF_))
}
}
}
}
Device(AGP_) {
Name(_ADR, 0x00010000)
Device(ATIM) {
Name(_ADR, 0x00050000)
Method(_DOS, 1) {
Store(And(Arg0, 0x3), DSEN)
}
Method(_DOD) {
Name(PSIZ, 0x0)
Name(PPTR, 0x0)
\_SB_.PCI0.LPC0.PHS5(0x80, 0x2, CADL, CSTE, NSTE)
Store(CADL, Local0)
Store(CADL, Local1)
While(Local1) {
If(And(Local1, 0x1)) {
Increment(PSIZ)
}
ShiftRight(Local1, 0x1, Local1)
}
If(LOr(LEqual(PSIZ, 0x0), LGreater(PSIZ, 0x3))) {
Return(Package(0x1) {
0x00010110,
})
}
Else {
If(LEqual(PSIZ, 0x2)) {
Name(VID2, Package(0x2) {
0x00010110,
0x00010100,
})
If(And(Local0, 0x1)) {
Store(0x00010110, Index(VID2, PPTR))
Increment(PPTR)
}
If(And(Local0, 0x2)) {
Store(0x00010100, Index(VID2, PPTR))
Increment(PPTR)
}
If(And(Local0, 0x4)) {
Store(0x00010200, Index(VID2, PPTR))
Increment(PPTR)
}
Return(VID2)
}
If(LEqual(PSIZ, 0x3)) {
Name(VID3, Package(0x3) {
0x00010110,
0x00010100,
0x00010200,
})
If(And(Local0, 0x1)) {
Store(0x00010110, Index(VID3, PPTR))
Increment(PPTR)
}
If(And(Local0, 0x2)) {
Store(0x00010100, Index(VID3, PPTR))
Increment(PPTR)
}
If(And(Local0, 0x4)) {
Store(0x00010200, Index(VID3, PPTR))
Increment(PPTR)
}
Return(VID3)
}
Name(VID1, Package(0x1) {
0x00010110,
})
If(And(Local0, 0x1)) {
Store(0x00010110, Index(VID1, 0x0))
}
If(And(Local0, 0x2)) {
Store(0x00010100, Index(VID1, 0x0))
}
If(And(Local0, 0x4)) {
Store(0x00010200, Index(VID1, 0x0))
}
Return(VID1)
}
}
Device(CRT1) {
Name(_ADR, 0x0100)
Method(_DCS) {
\_SB_.PCI0.LPC0.PHS5(0x80, 0x1, CADL, CSTE, NSTE)
If(And(CSTE, 0x2)) {
Return(0x1f)
}
Return(0x1d)
}
Method(_DGS) {
If(And(NSTE, 0x2)) {
Return(0x1)
}
Return(0x0)
}
Method(_DSS, 1) {
If(LEqual(And(Arg0, 0xc0000000), 0xc0000000)) {
Store(NSTE, CSTE)
}
}
}
Device(LCD_) {
Name(_ADR, 0x0110)
Method(_DCS) {
\_SB_.PCI0.LPC0.PHS5(0x80, 0x1, CADL, CSTE, NSTE)
If(And(CSTE, 0x1)) {
Return(0x1f)
}
Return(0x1d)
}
Method(_DGS) {
If(And(NSTE, 0x1)) {
Return(0x1)
}
Return(0x0)
}
Method(_DSS, 1) {
If(LEqual(And(Arg0, 0xc0000000), 0xc0000000)) {
Store(NSTE, CSTE)
}
}
}
Device(TV__) {
Name(_ADR, 0x0200)
Method(_DCS) {
\_SB_.PCI0.LPC0.PHS5(0x80, 0x1, CADL, CSTE, NSTE)
If(And(CSTE, 0x4)) {
Return(0x1f)
}
Return(0x1d)
}
Method(_DGS) {
If(And(NSTE, 0x4)) {
Return(0x1)
}
Return(0x0)
}
Method(_DSS, 1) {
If(LEqual(And(Arg0, 0xc0000000), 0xc0000000)) {
Store(NSTE, CSTE)
}
}
}
}
Method(_PRT) {
If(GPIC) {
Return(Package(0x1) {
Package(0x4) {
0x0005ffff,
0x0,
0x0,
0x10,
},
})
}
Else {
Return(Package(0x1) {
Package(0x4) {
0x0005ffff,
0x0,
\_SB_.PCI0.LPC0.LNK0,
0x0,
},
})
}
}
}
}
}
Scope(\_GPE) {
Method(_L04) {
Notify(\_SB_.PCI0.P2P_, 0x2)
Notify(\_SB_.PWRB, 0x2)
}
Method(_L05) {
Notify(\_SB_.PWRB, 0x2)
}
Method(_L0C) {
Notify(\_SB_.PCI0.MODM, 0x2)
Notify(\_SB_.PWRB, 0x2)
}
}

}
/*
SSDT: Length=285, Revision=1, Checksum=239,
        OEMID=INTEL, OEM Table ID=CPUCSTC4, OEM Revision=0x6040000,
        Creator ID=INTL, Creator Revision=0x20030224
*/
/*
SSDT: Length=431, Revision=1, Checksum=123,
        OEMID=PTLTD, OEM Table ID=ACPIPST1, OEM Revision=0x6040000,
        Creator ID= LTP, Creator Revision=0x1
*/

Reply via email to