NetBSD Problem Report #42051

From www@NetBSD.org  Sat Sep 12 12:37:22 2009
Return-Path: <www@NetBSD.org>
Received: from mail.netbsd.org (mail.netbsd.org [204.152.190.11])
	by www.NetBSD.org (Postfix) with ESMTP id 2490D63BFE3
	for <gnats-bugs@gnats.netbsd.org>; Sat, 12 Sep 2009 12:37:22 +0000 (UTC)
Message-Id: <20090912123721.E53D463B877@www.NetBSD.org>
Date: Sat, 12 Sep 2009 12:37:21 +0000 (UTC)
From: arto.huusko@pp2.inet.fi
Reply-To: arto.huusko@pp2.inet.fi
To: gnats-bugs@NetBSD.org
Subject: lid switch works only once
X-Send-Pr-Version: www-1.0

>Number:         42051
>Category:       kern
>Synopsis:       lid switch works only once
>Confidential:   no
>Severity:       serious
>Priority:       high
>Responsible:    kern-bug-people
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Sat Sep 12 12:40:00 +0000 2009
>Last-Modified:  Mon Mar 09 05:20:00 +0000 2015
>Originator:     Arto Huusko
>Release:        NetBSD 5.99.16
>Organization:
>Environment:
NetBSD vasara.local 5.99.16 NetBSD 5.99.16 (MONOLITHAMD64) #1: Fri Sep 11 21:45:24 EEST 2009  root@maailma.local:/local/scratch/build/nbsd-current/amd64/obj/sys/arch/amd64/compile/MONOLITHAMD64 amd64

>Description:
On Acer Aspire 5530 laptop the lid switch becomes inactive after the machine has been suspended once via the lid switch.

I will append dmesg and acpidump soon
>How-To-Repeat:
1. power up computer and boot NetBSD
2. close lid
3. powerd script lid_switch suspends the computer (calls sleep_button script)
4. open lid and press power button to resume
5. computer resumes
6. close lid again
7. nothing happens

I didn't test whether the lid switch becomes inactive if I suspend the machine otherwise.
>Fix:
not known

>Audit-Trail:
From: Arto Huusko <arto.huusko@pp2.inet.fi>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/42051
Date: Mon, 14 Sep 2009 21:09:13 +0300

 dmesg and ACPI dump of the machine attached.

 I did some further testing:

   - suspending the machine by setting machdep.sleep_state=3
     from command line does not break lid switch. After suspending,
     and resuming, the lid switch works, but only once again.

   - After suspending via lid switch, and then resuming, the
     machine can be suspended and resumed again by manually
     setting machdep.sleep_state. So even though lid switch
     does not work anymore, suspend/resume in general is not
     broken.

   - After suspending and resuming via lid switch, powerd process
     wchan is kqueue. From a quick look at the code, it seems that
     the lid_switch script returns normally after resume, and powerd
     resumes waiting for more events.

 So it seems that after using lid switch once, the kernel no longer
 reports further lid switch events to powerd.

From: Arto Huusko <arto.huusko@pp2.inet.fi>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/42051
Date: Mon, 14 Sep 2009 21:09:51 +0300

 This is a multi-part message in MIME format.
 --------------020902030803040906090409
 Content-Type: text/plain; charset=ISO-8859-1; format=flowed
 Content-Transfer-Encoding: 7bit

 > dmesg and ACPI dump of the machine attached.

 For real this time.

 --------------020902030803040906090409
 Content-Type: text/plain;
  name="acer5530.acpi"
 Content-Transfer-Encoding: quoted-printable
 Content-Disposition: inline;
  filename="acer5530.acpi"

 /*
 RSD PTR: Checksum=3D2, OEMID=3DACRSYS, RsdtAddress=3D0xafed1755
  */
 /*
 RSDT: Length=3D64, Revision=3D1, Checksum=3D116,
 	OEMID=3DACRSYS, OEM Table ID=3DACRPRDCT, OEM Revision=3D0x6040000,
 	Creator ID=3D LTP, Creator Revision=3D0x0
  */
 /*
 	Entries=3D{ 0xafedb965, 0xafedb9d9, 0xafedbb4f, 0xafedbe03, 0xafedbe61, =
 0xafedbe9d, 0xafedbed5 }
  */
 /*
 	DSDT=3D0xafed17f1
 	INT_MODEL=3DPIC
 	SCI_INT=3D9
 	SMI_CMD=3D0xb0, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1, S4BIOS_REQ=3D0x=
 0
 	PM1a_EVT_BLK=3D0x8000-0x8003
 	PM1a_CNT_BLK=3D0x8004-0x8005
 	PM2_CNT_BLK=3D0x8200-0x8200
 	PM2_TMR_BLK=3D0x8008-0x800b
 	PM2_GPE0_BLK=3D0x8020-0x8027
 	P_LVL2_LAT=3D101ms, P_LVL3_LAT=3D1001ms
 	FLUSH_SIZE=3D0, FLUSH_STRIDE=3D0
 	DUTY_OFFSET=3D1, DUTY_WIDTH=3D3
 	DAY_ALRM=3D13, MON_ALRM=3D0, CENTURY=3D0
 	Flags=3D{WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,TMR_VAL_EXT,DCK_CAP}
  */
 /*
 DSDT: Length=3D41088, Revision=3D1, Checksum=3D252,
 	OEMID=3DAcer, OEM Table ID=3DSB700, OEM Revision=3D0x6040000,
 	Creator ID=3DMSFT, Creator Revision=3D0x3000000
  */
 DefinitionBlock ("acpi_dst.aml", "DSDT", 0x1, "Acer", "SB700", 0x6040000)=

 {
 Name(Z000, 0x01)
 Name(Z001, 0x02)
 Name(Z002, 0x04)
 Name(Z003, 0x08)
 Name(Z004, 0x00)
 Name(Z005, 0x0f)
 Name(Z006, 0x0d)
 Name(Z007, 0x0b)
 Name(Z008, 0x09)
 Scope(\_PR) {
     Processor(CPU0, 0, 0x8010, 0x6) {
     }
     Processor(CPU1, 1, 0x0, 0x0) {
     }
 }
 Name(_S0, Package(0x04) {
     0x00,
     0x00,
     0x00,
     0x00,
 })
 Name(_S3, Package(0x04) {
     0x03,
     0x03,
     0x00,
     0x00,
 })
 Name(_S4, Package(0x04) {
     0x04,
     0x04,
     0x00,
     0x00,
 })
 Name(_S5, Package(0x04) {
     0x05,
     0x05,
     0x00,
     0x00,
 })
 Name(CRTS, 0x00)
 OperationRegion(\DEB2, SystemIO, 0x80, 0x02)
 Field(\DEB2, WordAcc, NoLock, Preserve) {
     P80H,	16
 }
 OperationRegion(\PMIO, SystemIO, 0x0cd6, 0x02)
 Field(\PMIO, ByteAcc, NoLock, Preserve) {
     PIDX,	8,
     PDAT,	8
 }
 OperationRegion(\P01, SystemIO, 0x8001, 0x01)
 Field(\P01, ByteAcc, NoLock, Preserve) {
     PST1,	8
 }
 OperationRegion(MNVS, SystemMemory, 0xafedde74, 0xaa55)
 Field(MNVS, AnyAcc, Lock, Preserve) {
     OSYS,	16,
     SMIF,	8,
     PRM0,	8,
     PRM1,	8,
     SCIF,	8,
     PRM2,	8,
     PRM3,	8,
     LCKF,	8,
     PRM4,	8,
     PRM5,	8,
     P80D,	32,
     LIDS,	8,
     UMAS,	8,
     CPUS,	8,
     PTYP,	8,
     KBTP,	8,
     PJID,	8,
     SFIR,	8,
     SBTH,	8,
     EBID,	8
 }
 Name(HTTX, 0x00)
 Method(_PTS, 1) {
     If(LNot(LGreater(\_SB.PCI0.SMB.RVID, 0x13))) {
         Store(Zero, \_SB.PCI0.SMB.PWDE)
     }
     If(LEqual(Arg0, 0x05)) {
         Store(0x05, P80H)
         Store(One, \_SB.PCI0.SMB.SLPS)
     }
     If(LEqual(Arg0, 0x04)) {
         Store(0x04, P80H)
         \_SB.PCI0.LPC0.PHSS(0x0e)
         Store(One, \_SB.PCI0.SMB.SLPS)
     }
     If(LEqual(Arg0, 0x03)) {
         Store(0x03, P80H)
         Store(Zero, \_SB.PCI0.SMB.RSTU)
         Store(One, \_SB.PCI0.SMB.SLPS)
     }
 }
 Method(_WAK, 1) {
     Store(0xe0, P80H)
     \_GPE._L1A()
     Store(0xe1, P80H)
     If(LEqual(\_SB.TPOS, 0x80)) {
         Store(0xe2, P80H)
         Store(One, \_SB.PCI0.SMB.MT3A)
     }
     Store(\_SB.PCI0.SMB.PEWS, \_SB.PCI0.SMB.PEWS)
     Store(One, \_SB.PCI0.SMB.HECO)
     Store(0xe3, P80H)
     Store(0x81, \_SB.PCI0.LPC0.BCMD)
     Store(Zero, \_SB.PCI0.LPC0.SMIC)
     Store(0xe4, P80H)
     If(LEqual(Arg0, 0x03)) {
         Store(0x13, P80H)
         If(LOr(LEqual(PJID, 0x00), LEqual(PJID, 0x02))) {
             Notify(\_SB.PCI0.PB9, 0x00)
         }
         Store(0x23, P80H)
         Store(One, \_SB.PCI0.SMB.RSTU)
         Store(One, \_SB.PCI0.SMB.IR9S)
         Store(One, \_SB.PCI0.SMB.IR9E)
         Store(0x33, P80H)
         If(LEqual(\_SB.TPOS, 0x40)) {
             Notify(\_SB.PWRB, 0x02)
         }
         Store(0x63, P80H)
     }
     If(LEqual(Arg0, 0x04)) {
         Store(0x14, P80H)
         \_SB.PCI0.LPC0.PHSS(0x0f)
         Store(0x24, P80H)
         If(GPIC) {
             Store(0x34, P80H)
             \_SB.PCI0.LPC0.DSPI()
         }
         Store(0x44, P80H)
         Notify(\_SB.PWRB, 0x02)
         Store(0x64, P80H)
     }
     Notify(\_SB.PCI0, 0x00)
 }
 Scope(\_SI) {
     Method(_SST, 1) {
         If(LEqual(Arg0, 0x01)) {
             Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Working\x20\x3d\x3d\x3d=
 \x3d\x3d", Debug)
         }
         If(LEqual(Arg0, 0x02)) {
             Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Waking\x20\x3d\x3d\x3d\=
 x3d\x3d", Debug)
         }
         If(LEqual(Arg0, 0x03)) {
             Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Sleeping\x20\x3d\x3d\x3=
 d\x3d\x3d", Debug)
         }
         If(LEqual(Arg0, 0x04)) {
             Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Sleeping\x20S4\x20\x3d\=
 x3d\x3d\x3d\x3d", Debug)
         }
     }
 }
 Scope(\_SB) {
     Name(LINX, 0x00)
     Name(OSSP, 0x00)
     Name(OSTB, Ones)
     OperationRegion(OSTY, SystemMemory, 0xafedddfc, 0x00000001)
     Field(OSTY, AnyAcc, NoLock, Preserve) {
         TPOS,	8
     }
     Method(OSTP) {
         If(LEqual(^OSTB, Ones)) {
             If(CondRefOf(\_OSI, Local0)) {
                 Store(0x00, ^OSTB)
                 Store(0x00, ^TPOS)
                 If(\_OSI("Windows\x202001")) {
                     Store(0x08, ^OSTB)
                     Store(0x08, ^TPOS)
                 }
                 If(\_OSI("Windows\x202001.1")) {
                     Store(0x20, ^OSTB)
                     Store(0x20, ^TPOS)
                 }
                 If(\_OSI("Windows\x202001\x20SP1")) {
                     Store(0x10, ^OSTB)
                     Store(0x10, ^TPOS)
                 }
                 If(\_OSI("Windows\x202001\x20SP2")) {
                     Store(0x11, ^OSTB)
                     Store(0x11, ^TPOS)
                 }
                 If(\_OSI("Windows\x202001\x20SP3")) {
                     Store(0x12, ^OSTB)
                     Store(0x12, ^TPOS)
                 }
                 If(\_OSI("Windows\x202006")) {
                     Store(0x40, ^OSTB)
                     Store(0x40, ^TPOS)
                     Store(0x40, OSYS)
                 }
                 If(\_OSI("Windows\x202006\x20SP1")) {
                     Store(0x01, OSSP)
                     Store(0x40, ^OSTB)
                     Store(0x40, ^TPOS)
                 }
                 If(\_OSI("Linux")) {
                     Store(0x01, LINX)
                     Store(0x80, ^OSTB)
                     Store(0x80, ^TPOS)
                 }
             }
             Else {
                 If(CondRefOf(\_OS, Local0)) {
                     If(^SEQL(\_OS, "Microsoft\x20Windows")) {
                         Store(0x01, ^OSTB)
                         Store(0x01, ^TPOS)
                     }
                     Else {
                         If(^SEQL(\_OS, "Microsoft\x20WindowsME\x3a\x20Mil=
 lennium\x20Edition")) {
                             Store(0x02, ^OSTB)
                             Store(0x02, ^TPOS)
                         }
                         Else {
                             If(^SEQL(\_OS, "Microsoft\x20Windows\x20NT"))=
  {
                                 Store(0x04, ^OSTB)
                                 Store(0x04, ^TPOS)
                             }
                             Else {
                                 Store(0x00, ^OSTB)
                                 Store(0x00, ^TPOS)
                             }
                         }
                     }
                 }
                 Else {
                     Store(0x00, ^OSTB)
                     Store(0x00, ^TPOS)
                 }
             }
             Store(0xb0, \_SB.PCI0.LPC0.BCMD)
             Store(Zero, \_SB.PCI0.LPC0.SMIC)
             If(LEqual(TPOS, 0x80)) {
                 Store(One, \_SB.PCI0.SMB.MT3A)
             }
         }
         Return(^OSTB)
     }
     Method(OSHT) {
         \_SB.OSTP()
         Store(0x48, \_SB.PCI0.LPC0.BCMD)
         Store(Zero, \_SB.PCI0.LPC0.SMIC)
     }
     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(\GPIC, 0x00)
 Method(\_PIC, 1) {
     Store(Arg0, GPIC)
     If(Arg0) {
         \_SB.PCI0.LPC0.DSPI()
     }
 }
 Scope(\_SB) {
     Device(PWRB) {
         Name(_HID, 0x0c0cd041)
     }
     Device(SLPB) {
         Name(_HID, 0x0e0cd041)
     }
     Device(LID) {
         Name(_HID, 0x0d0cd041)
         Method(_LID) {
             Return(LNot(\_SB.PCI0.SMB.GM4C))
         }
     }
     Device(WMID) {
         Name(_HID, "PNP0C14")
         Name(_UID, 0x00)
         Name(ERRD, 0x00010000)
         Name(BUFF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 })
         CreateByteField(BUFF, 0x00, BF00)
         CreateByteField(BUFF, 0x01, BF01)
         CreateByteField(BUFF, 0x02, BF02)
         CreateByteField(BUFF, 0x03, BF03)
         CreateByteField(BUFF, 0x04, BF04)
         Name(BUF1, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
         Name(AADS, Buffer(0x04) {0x0 })
         CreateField(AADS, 0x00, 0x04, AS00)
         CreateField(AADS, 0x04, 0x01, AS01)
         CreateField(AADS, 0x05, 0x01, AS02)
         CreateField(AADS, 0x10, 0x10, AS03)
         Name(BAEF, 0x00)
         Name(BADF, 0x00)
         Name(BADG, Package(0x0d) {
             0x01,
             0x01,
             0x00,
             0x00,
             0x00,
             0x00,
             0x00,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00,
             0x00010000,
         })
         Name(WLDS, 0x00)
         Name(WLED, 0x00)
         Name(BTDS, 0x00)
         Name(BTED, 0x00)
         Name(BLDS, 0x00)
         Name(BLED, 0x00)
         Name(NTDC, 0x00)
         Name(NTDV, 0x00)
         Name(WLSD, 0x0100)
         Name(WLSE, 0x0101)
         Name(BLTD, 0x0200)
         Name(BLTE, 0x0201)
         Name(LBL0, 0x0300)
         Name(LBL1, 0x0301)
         Name(LBL2, 0x0302)
         Name(LBL3, 0x0303)
         Name(LBL4, 0x0304)
         Name(LBL5, 0x0305)
         Name(LBL6, 0x0306)
         Name(LBL7, 0x0307)
         Name(LBL8, 0x0308)
         Name(LBL9, 0x0309)
         Name(LBLA, 0x030a)
         Name(LBLB, 0x030b)
         Name(LBLC, 0x030c)
         Name(LBLD, 0x030d)
         Name(LBLE, 0x030e)
         Name(LBLF, 0x030f)
         Name(VAPO, 0x0600)
         Name(VAPI, 0x0601)
         Name(CADI, 0x0401)
         Name(CADO, 0x0400)
         Name(GSEE, 0x0501)
         Name(GSED, 0x0502)
         Name(WBBO, 0x0701)
         Name(WBBI, 0x0700)
         Name(G3MD, 0x0800)
         Name(G3ME, 0x0801)
         Name(LANI, 0x0900)
         Name(LANO, 0x0901)
         Name(LDOF, 0x0a00)
         Name(LDON, 0x0a01)
         Name(BBSB, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
         CreateField(BBSB, 0x00, 0x10, BBD0)
         CreateField(BBSB, 0x10, 0x10, BBD1)
         Name(TLS0, 0x00)
         Name(TLS1, 0x01)
         Name(TLS2, 0x02)
         Name(TLS3, 0x03)
         Name(TLS4, 0x04)
         Name(TLS5, 0x05)
         Name(TLS6, 0x06)
         Name(TLS7, 0x07)
         Name(BCDS, Package(0x0d) {
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
         })
         Name(BDDS, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
         CreateField(BDDS, 0x00, 0x10, BDD0)
         CreateField(BDDS, 0x10, 0x10, BDD1)
         Name(DSY0, Buffer(0x28) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
 x0, 0x0, 0x0 })
         Name(DSY1, Buffer(0x18) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
 , 0x0 })
         Name(DSY2, Buffer(0x10) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
         Name(DSY3, Buffer(0x18) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
 , 0x0 })
         Name(DSY4, Buffer(0x10) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
         Name(DSY5, Buffer(0x28) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
 x0, 0x0, 0x0 })
         CreateField(DSY0, 0x00, 0x40, DY00)
         CreateField(DSY0, 0x40, 0x40, DY01)
         CreateField(DSY0, 0x80, 0x40, DY02)
         CreateField(DSY0, 0xc0, 0x40, DY03)
         CreateField(DSY0, 0x0100, 0x40, DY04)
         CreateField(DSY1, 0x00, 0x40, DY10)
         CreateField(DSY1, 0x40, 0x40, DY11)
         CreateField(DSY1, 0x80, 0x40, DY12)
         CreateField(DSY2, 0x00, 0x40, DY20)
         CreateField(DSY2, 0x40, 0x10, DY21)
         CreateField(DSY2, 0x50, 0x10, DY22)
         CreateField(DSY0, 0x00, 0xc0, DSX4)
         Name(BEDS, Package(0x13) {
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
             0x00010000,
         })
         Name(WIT0, 0x00)
         Name(DSY6, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
         CreateField(DSY6, 0x00, 0x20, DY60)
         CreateField(DSY6, 0x20, 0x20, DY61)
         CreateField(DSY6, 0x40, 0x20, DY62)
         CreateField(DSY6, 0x60, 0x20, DY63)
         CreateField(DSY6, 0x80, 0x20, DY64)
         Name(WPRW, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
         CreateField(WPRW, 0x00, 0x08, WWD0)
         CreateField(WPRW, 0x08, 0x08, WWD1)
         CreateField(WPRW, 0x10, 0x08, WWD2)
         CreateField(WPRW, 0x18, 0x08, WWD3)
         CreateField(WPRW, 0x20, 0x08, WWD4)
         CreateField(WPRW, 0x28, 0x20, WWD5)
         Name(WPCI, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
         CreateField(WPCI, 0x00, 0x08, WPIR)
         CreateField(WPCI, 0x08, 0x03, WPIF)
         CreateField(WPCI, 0x0b, 0x05, WPID)
         CreateField(WPCI, 0x10, 0x08, WPIB)
         Name(BFDS, Package(0x04) {
             0x02,
             0x02,
             0x02,
             0x02,
         })
         Name(GSTS, 0x00)
         Name(BFEF, 0x00)
         Name(BGEF, 0x00)
         Name(BGDS, Package(0x01) {
             0x01,
         })
         Method(AAF1) {
             Store(\_SB.PCI0.LPC0.EC0.WLEX, AS00)
             Store(\_SB.PCI0.LPC0.EC0.BTEX, AS01)
             Store(0x00, AS02)
             Store(0x00, AS03)
         }
         Method(Z009, 1) {
             Store(\_SB.PCI0.LPC0.EC0.WLAT, Local0)
             Store(Local0, Index(BADG, 0x00, ))
             Store(\_SB.PCI0.LPC0.EC0.BTAT, Local0)
             Store(Local0, Index(BADG, 0x01, ))
             Store(\_SB.PCI0.LPC0.EC0.BRTS, Local0)
             Store(Local0, Index(BADG, 0x02, ))
             Store(0x01, Local0)
             Store(Local0, Index(BADG, 0x07, ))
             Store(0x00, Local0)
             Store(Local0, Index(BADG, 0x08, ))
             Store(\_SB.PCI0.LPC0.EC0.LANC, Local0)
             Store(Local0, Index(BADG, 0x0b, ))
             If(LOr(LEqual(PJID, 0x02), LEqual(PJID, 0x03))) {
                 Store(ERRD, Index(BADG, 0x0b, ))
             }
             Store(\_SB.PCI0.LPC0.EC0.LCDS, Local0)
             Store(Local0, Index(BADG, 0x0c, ))
         }
         Method(Z00A, 2) {
             Store(Arg1, BUFF)
             Store(Arg0, Local0)
             Store(BF00, Local1)
             Store(Local0, Debug)
             Store(Local1, Debug)
             Store(0x00, Local2)
             While(One) {
                 Name(_T_0, 0x00)
                 Store(Local1, _T_0)
                 If(LEqual(_T_0, 0x00)) {
                     While(One) {
                         Name(_T_1, 0x00)
                         Store(Local0, _T_1)
                         If(LEqual(_T_1, 0x04)) {
                             Store(0x00, \_SB.PCI0.LPC0.EC0.WLAT)
                         }
                         Else {
                             If(LEqual(_T_1, 0x05)) {
                                 Store(0x00, \_SB.PCI0.LPC0.EC0.BTAT)
                             }
                             Else {
                                 If(LEqual(_T_1, 0x06)) {
                                     Store(0x00, \_SB.PCI0.LPC0.EC0.BRTS)
                                 }
                                 Else {
                                     If(LEqual(_T_1, 0x07)) {
                                         Store(0x00, BAEF)
                                     }
                                     Else {
                                         Store(0x01, Local2)
                                     }
                                 }
                             }
                         }
                         Break
                     }
                 }
                 Else {
                     While(One) {
                         Name(_T_2, 0x00)
                         Store(Local0, _T_2)
                         If(LEqual(_T_2, 0x04)) {
                             Store(0x01, \_SB.PCI0.LPC0.EC0.WLAT)
                             Store(0x00, Index(BADG, 0x03, ))
                         }
                         Else {
                             If(LEqual(_T_2, 0x05)) {
                                 Store(0x01, \_SB.PCI0.LPC0.EC0.BTAT)
                                 Store(0x00, Index(BADG, 0x04, ))
                             }
                             Else {
                                 If(LEqual(_T_2, 0x06)) {
                                     Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS=
 )
                                     Store(0x00, Index(BADG, 0x05, ))
                                 }
                                 Else {
                                     If(LEqual(_T_2, 0x07)) {
                                         Store(0x01, BAEF)
                                         Store(0x00, Index(BADG, 0x06, ))
                                     }
                                     Else {
                                         Store(0x01, Local2)
                                     }
                                 }
                             }
                         }
                         Break
                     }
                 }
                 Break
             }
             If(LEqual(Local2, 0x01)) {
                 While(One) {
                     Name(_T_3, 0x00)
                     Store(Local0, _T_3)
                     If(LEqual(_T_3, 0x04)) {
                         Store(0x02, Index(BADG, 0x03, ))
                     }
                     Else {
                         If(LEqual(_T_3, 0x05)) {
                             Store(0x03, Index(BADG, 0x03, ))
                         }
                         Else {
                             If(LEqual(_T_3, 0x06)) {
                                 Store(0x04, Index(BADG, 0x03, ))
                             }
                         }
                     }
                     Break
                 }
             }
         }
         Method(Z00B) {
             If(LEqual(BGEF, 0x01)) {
                 Store(NTDV, Local0)
                 If(LNot(LEqual(Local0, 0x00))) {
                     Store(0x00, NTDV)
                     Return(Local0)
                 }
             }
             If(LEqual(BAEF, 0x01)) {
                 Store(NTDC, Local0)
                 If(LNot(LEqual(Local0, 0x00))) {
                     Store(0x00, NTDC)
                     Return(Local0)
                 }
             }
             If(LEqual(BFEF, 0x01)) {
             }
         }
         Method(Z00C, 2) {
             Store(Arg0, Local0)
             Store(Arg1, BUFF)
             Store(0x00, BBSB)
             If(LEqual(Local0, 0x01)) {
                 Store(SBTH, BBD0)
             }
             Else {
                 If(LEqual(Local0, 0x02)) {
                     Store(BF00, SBTH)
                 }
                 Else {
                     Store(ERRD, BBSB)
                 }
             }
         }
         Method(Z00D, 2) {
             Store(Arg1, BUFF)
             Store(ERRD, Index(BCDS, BF00, ))
         }
         Method(Z00E, 1) {
             Store(DSY5, DSY0)
             Store(Arg0, Local0)
             Store(\_SB.PHWM(0x00, Arg0), Local2)
             Store(Local2, DSY6)
             Store(DY60, DY00)
             Store(DY61, DY01)
             Store(DY62, DY02)
             Store(DY63, DY03)
         }
         Method(Z00F, 1) {
             Store(DSY3, DSY1)
             Store(Arg0, DY00)
             Store(\_SB.PHWM(0x01, Arg0), Local2)
             Store(Local2, DSY6)
             Store(DY60, DY10)
             Store(DY61, DY11)
             Store(0x00, WIT0)
             Store(WIT0, DY12)
         }
         Method(Z00G, 1) {
             Store(DSY3, DSY1)
             Store(\_SB.PHWM(0x02, Arg0), Local2)
             Store(Local2, DSY6)
             Store(DY60, DY10)
             Store(DY61, DY11)
             Store(0x00, WIT0)
             Store(WIT0, DY12)
         }
         Method(Z00H, 2) {
             Store(0x00010000, Index(BCDS, 0x09, ))
         }
         Method(Z00I) {
             Store(\_SB.PCI0.LPC0.EC0.THFN, Local0)
             Multiply(Local0, 0x64, Local1)
             Store(Local1, Index(BCDS, 0x0a, ))
         }
         Method(Z00J) {
             Store(\_SB.PCI0.LPC0.EC0.CTMP, Index(BCDS, 0x0b, ))
         }
         Method(Z00K, 1) {
             Store(Arg0, Local0)
             Store(\_SB.PHWM(0x03, Arg0), Local2)
             Store(Local2, DY20)
             Store(Local2, DSY6)
             Store(DSY4, DSY2)
             Store(DY60, DY20)
         }
         Method(Z00L, 1) {
             Store(Arg0, Local0)
             Store(Arg0, DY20)
             Store(\_SB.PHWM(0x04, Arg0), Local2)
             Store(Local2, DSY6)
             Store(DY61, BUFF)
         }
         Method(Z00M) {
             Store(\_SB.PHWM(0x05, 0x00), Local2)
             Store(Local2, BUFF)
             Store(BUFF, Index(BCDS, 0x0c, ))
         }
         Method(PCID, 1) {
             Store(\_SB.PHWM(0x03, Arg0), Local2)
             Store(Local2, DSY6)
         }
         Method(Z00N, 2) {
             Store(Arg0, Local0)
             Store(Arg1, BUFF)
             If(LEqual(\_SB.PCI0.LPC0.EC0.BDC0, 0x00)) {
                 Store(0x00020000, Local1)
                 Decrement(Local0)
                 Store(Local1, Index(BEDS, Local0, ))
             }
             Else {
                 While(One) {
                     Name(_T_0, 0x00)
                     Store(Local0, _T_0)
                     If(LEqual(_T_0, 0x01)) {
                         Store(0x00, Index(BEDS, 0x00, ))
                     }
                     Else {
                         If(LEqual(_T_0, 0x02)) {
                             Store(\_SB.PCI0.LPC0.EC0.BPTC, Index(BEDS, 0x=
 01, ))
                         }
                         Else {
                             If(LEqual(_T_0, 0x03)) {
                                 Store(\_SB.PCI0.LPC0.EC0.BPV0, Index(BEDS=
 , 0x02, ))
                             }
                             Else {
                                 If(LEqual(_T_0, 0x04)) {
                                     Store(\_SB.PCI0.LPC0.EC0.BSCU, Index(=
 BEDS, 0x03, ))
                                 }
                                 Else {
                                     If(LEqual(_T_0, 0x05)) {
                                         Store(\_SB.PCI0.LPC0.EC0.BRC0, In=
 dex(BEDS, 0x04, ))
                                     }
                                     Else {
                                         If(LEqual(_T_0, 0x06)) {
                                             Store(\_SB.PCI0.LPC0.EC0.BFC0=
 , Index(BEDS, 0x05, ))
                                         }
                                         Else {
                                             If(LEqual(_T_0, 0x07)) {
                                                 Store(\_SB.PCI0.LPC0.EC0.=
 BSCY, Index(BEDS, 0x06, ))
                                             }
                                             Else {
                                                 If(LEqual(_T_0, 0x08)) {
                                                     Store(\_SB.PCI0.LPC0.=
 EC0.BDC0, Index(BEDS, 0x07, ))
                                                 }
                                                 Else {
                                                     If(LEqual(_T_0, 0x09)=
 ) {
                                                         Store(\_SB.PCI0.L=
 PC0.EC0.BDV0, Index(BEDS, 0x08, ))
                                                     }
                                                     Else {
                                                         If(LEqual(_T_0, 0=
 x0a)) {
                                                             Store(\_SB.PC=
 I0.LPC0.EC0.BDAD, Index(BEDS, 0x09, ))
                                                         }
                                                         Else {
                                                             If(LEqual(_T_=
 0, 0x0b)) {
                                                                 Store(\_S=
 B.PCI0.LPC0.EC0.BSN0, Index(BEDS, 0x0a, ))
                                                             }
                                                             Else {
                                                                 If(LEqual=
 (_T_0, 0x0c)) {
                                                                     If(LE=
 qual(\_SB.PCI0.LPC0.EC0.ACIS, 0x01)) {
                                                                         S=
 tore(0x00, \_SB.PCI0.LPC0.EC0.PSRC)
                                                                         S=
 tore(0x01, Index(BEDS, 0x0b, ))
                                                                     }
                                                                     Else =
 {
                                                                         S=
 tore(0x00020000, Index(BEDS, 0x0b, ))
                                                                     }
                                                                 }
                                                                 Else {
                                                                     If(LE=
 qual(_T_0, 0x0d)) {
                                                                         S=
 tore(Local1, \_SB.PCI0.LPC0.EC0.BTMA)
                                                                         S=
 tore(0x01, \_SB.PCI0.LPC0.EC0.SCCF)
                                                                         S=
 tore(0x01, Index(BEDS, 0x0c, ))
                                                                     }
                                                                     Else =
 {
                                                                         I=
 f(LEqual(_T_0, 0x0e)) {
                                                                          =
    Store(Local1, \_SB.PCI0.LPC0.EC0.BTPV)
                                                                          =
    Store(0x00, \_SB.PCI0.LPC0.EC0.SCHG)
                                                                          =
    Store(0x01, \_SB.PCI0.LPC0.EC0.SCPF)
                                                                          =
    Store(0x01, Index(BEDS, 0x0d, ))
                                                                         }=

                                                                         E=
 lse {
                                                                          =
    If(LEqual(_T_0, 0x0f)) {
                                                                          =
        Store(\_SB.PCI0.LPC0.EC0.BDFC, Index(BEDS, 0x0e, ))
                                                                          =
    }
                                                                          =
    Else {
                                                                          =
        If(LEqual(_T_0, 0x10)) {
                                                                          =
            Store(\_SB.PCI0.LPC0.EC0.BDME, Index(BEDS, 0x0f, ))
                                                                          =
        }
                                                                          =
        Else {
                                                                          =
            If(LEqual(_T_0, 0x11)) {
                                                                          =
                Store(0x03e8, Index(BEDS, 0x10, ))
                                                                          =
            }
                                                                          =
            Else {
                                                                          =
                If(LEqual(_T_0, 0x12)) {
                                                                          =
                    Store(0x0100, Index(BEDS, 0x11, ))
                                                                          =
                }
                                                                          =
                Else {
                                                                          =
                    If(LEqual(_T_0, 0x13)) {
                                                                          =
                        Store(BF00, Local1)
                                                                          =
                        Store(BF04, BF00)
                                                                          =
                        Store(Local1, BF04)
                                                                          =
                        While(One) {
                                                                          =
                            Name(_T_1, 0x00)
                                                                          =
                            Store(BF04, _T_1)
                                                                          =
                            If(LEqual(_T_1, 0x03)) {
                                                                          =
                                Store(\_SB.PCI0.LPC0.EC0.BATM, Index(BEDS,=
  0x12, ))
                                                                          =
                            }
                                                                          =
                            Else {
                                                                          =
                                If(LEqual(_T_1, 0x08)) {
                                                                          =
                                    Store(\_SB.PCI0.LPC0.EC0.BTTC, Index(B=
 EDS, 0x12, ))
                                                                          =
                                }
                                                                          =
                                Else {
                                                                          =
                                    If(LEqual(_T_1, 0x09)) {
                                                                          =
                                        Store(\_SB.PCI0.LPC0.EC0.BPV0, Ind=
 ex(BEDS, 0x12, ))
                                                                          =
                                    }
                                                                          =
                                    Else {
                                                                          =
                                        If(LEqual(_T_1, 0x0a)) {
                                                                          =
                                            Store(\_SB.PCI0.LPC0.EC0.BSCU,=
  Index(BEDS, 0x12, ))
                                                                          =
                                        }
                                                                          =
                                        Else {
                                                                          =
                                            If(LEqual(_T_1, 0x17)) {
                                                                          =
                                                Store(\_SB.PCI0.LPC0.EC0.B=
 SCY, Index(BEDS, 0x12, ))
                                                                          =
                                            }
                                                                          =
                                            Else {
                                                                          =
                                                If(LEqual(_T_1, 0x18)) {
                                                                          =
                                                    Store(\_SB.PCI0.LPC0.E=
 C0.BDC0, Index(BEDS, 0x12, ))
                                                                          =
                                                }
                                                                          =
                                                Else {
                                                                          =
                                                    If(LEqual(_T_1, 0x19))=
  {
                                                                          =
                                                        Store(\_SB.PCI0.LP=
 C0.EC0.BDV0, Index(BEDS, 0x12, ))
                                                                          =
                                                    }
                                                                          =
                                                    Else {
                                                                          =
                                                        If(LEqual(_T_1, 0x=
 1b)) {
                                                                          =
                                                            Store(\_SB.PCI=
 0.LPC0.EC0.BDAD, Index(BEDS, 0x12, ))
                                                                          =
                                                        }
                                                                          =
                                                        Else {
                                                                          =
                                                        }
                                                                          =
                                                    }
                                                                          =
                                                }
                                                                          =
                                            }
                                                                          =
                                        }
                                                                          =
                                    }
                                                                          =
                                }
                                                                          =
                            }
                                                                          =
                            Break
                                                                          =
                        }
                                                                          =
                    }
                                                                          =
                    Else {
                                                                          =
                    }
                                                                          =
                }
                                                                          =
            }
                                                                          =
        }
                                                                          =
    }
                                                                         }=

                                                                     }
                                                                 }
                                                             }
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                     Break
                 }
             }
         }
         Method(Z00O) {
             Store(0x01, GSTS)
             Return(GSTS)
         }
         Method(Z00P, 1) {
         }
         Method(Z00Q, 1) {
         }
         Method(Z00R, 1) {
         }
         Method(Z00S, 1) {
         }
         Method(Z00T, 1) {
             Store(Arg0, Local0)
             If(LEqual(Local0, 0x01)) {
                 Store(0x01, BGEF)
             }
             Else {
                 Store(0x00, BGEF)
             }
             Store(0x00, Index(BGDS, 0x00, ))
         }
         Name(_WDG, Buffer(0xdc) {0x9, 0x4e, 0x76, 0x95, 0x56, 0xfb, 0x83,=
  0x4e, 0xb3, 0x1a, 0x37, 0x76, 0x1f, 0x60, 0x99, 0x4a, 0x41, 0x41, 0x1, 0=
 x1, 0x58, 0xf2, 0xf4, 0x6a, 0x1, 0xb4, 0xfd, 0x42, 0xbe, 0x91, 0x3d, 0x4a=
 , 0xc2, 0xd7, 0xc0, 0xd3, 0x42, 0x41, 0x1, 0x2, 0xac, 0x61, 0x1a, 0xcc, 0=
 x56, 0x42, 0xa3, 0x41, 0xb9, 0xe0, 0x5, 0xa4, 0x45, 0xad, 0xe2, 0xf5, 0x8=
 0, 0x0, 0x1, 0x8, 0x53, 0x44, 0x8c, 0xe7, 0x27, 0x2, 0x61, 0x48, 0x9e, 0x=
 de, 0xf5, 0x60, 0xb, 0x4a, 0x3d, 0x39, 0x42, 0x42, 0x1, 0x2, 0x7b, 0x4f, =
 0xe0, 0xaa, 0xc5, 0xb3, 0x65, 0x48, 0x95, 0xd6, 0x9f, 0xac, 0x7f, 0xf3, 0=
 xe9, 0x2b, 0x42, 0x43, 0x1, 0x2, 0x79, 0x4c, 0xf9, 0xcf, 0x77, 0x6c, 0xf7=
 , 0x4a, 0xac, 0x56, 0x7d, 0xd0, 0xce, 0x1, 0xc9, 0x97, 0x42, 0x44, 0x1, 0=
 x2, 0xc5, 0x2e, 0x77, 0x79, 0xb1, 0x4, 0xfd, 0x4b, 0x84, 0x3c, 0x61, 0xe7=
 , 0xf7, 0x7b, 0x6c, 0xc9, 0x42, 0x45, 0x1, 0x2, 0xb7, 0xa0, 0xc9, 0xa7, 0=
 x9d, 0x4c, 0x72, 0x4c, 0x83, 0xbb, 0x53, 0xa3, 0x45, 0x91, 0x71, 0xdf, 0x=
 42, 0x46, 0x1, 0x2, 0x4f, 0x6, 0x3a, 0x65, 0x3a, 0xa2, 0x5f, 0x48, 0xb3, =
 0xd9, 0x13, 0xf6, 0x53, 0x2a, 0x1, 0x82, 0x42, 0x47, 0x1, 0x2, 0xa7, 0xb1=
 , 0x85, 0xdb, 0x9a, 0x6, 0xbb, 0x4a, 0xa2, 0xb5, 0xd1, 0x86, 0xa2, 0x1b, =
 0x80, 0xf1, 0x81, 0x0, 0x1, 0x8, 0x91, 0x6b, 0x91, 0x36, 0x64, 0x1a, 0x83=
 , 0x45, 0x84, 0xd0, 0x53, 0x83, 0xf, 0xb9, 0x10, 0x8d, 0x82, 0x0, 0x1, 0x=
 8 })
         Method(WQAA, 1) {
             AAF1()
             Store(AADS, BUFF)
             Return(BUFF)
         }
         Method(WMBA, 3) {
             While(One) {
                 Name(_T_0, 0x00)
                 Store(Arg1, _T_0)
                 If(LNot(LEqual(Match(Package(0x08) {
                     0x01,
                     0x02,
                     0x03,
                     0x08,
                     0x09,
                     0x0a,
                     0x0c,
                     0x0d,
                 }, MEQ, _T_0, MTR, 0x00, 0x00), Ones))) {
                     Store(0x00, Local0)
                 }
                 Else {
                     If(LNot(LEqual(Match(Package(0x05) {
                         0x04,
                         0x05,
                         0x06,
                         0x07,
                         0x0b,
                     }, MEQ, _T_0, MTR, 0x00, 0x00), Ones))) {
                         If(LEqual(Arg1, 0x07)) {
                             Store(Arg2, BUFF)
                             If(BF00) {
                                 Store(0x01, BAEF)
                             }
                         }
                         Store(0x01, Local0)
                     }
                 }
                 Break
             }
             If(Local0) {
                 Z00A(Arg1, Arg2)
             }
             Else {
                 Z009(Arg1)
             }
             Store(DerefOf(Index(BADG, Subtract(Arg1, 0x01, ), )), BUFF)
             Return(BUFF)
         }
         Method(_WED, 1) {
             If(LNot(LLess(Arg0, 0x80))) {
                 If(LLess(Arg0, 0x83)) {
                     Return(Z00B())
                 }
             }
         }
         Method(WMBB, 3) {
             Z00C(Arg1, Arg2)
             If(LEqual(Arg1, 0x01)) {
                 Store(BBSB, BUFF)
             }
             If(LEqual(Arg1, 0x02)) {
                 Store(BBD1, BUFF)
             }
             Return(BUFF)
         }
         Method(WMBC, 3) {
             Z00D(Arg1, Arg2)
             If(LLess(Arg1, 0x0a)) {
                 Subtract(Arg1, 0x01, Local0)
                 Store(DerefOf(Index(BCDS, Subtract(Arg1, 0x01, ), )), BUF=
 F)
             }
             Else {
                 ShiftRight(DerefOf(Index(BCDS, Subtract(Arg1, 0x0a, ), ))=
 , 0x10, BUFF)
             }
             Return(BUFF)
         }
         Method(WMBD, 3) {
             If(LEqual(Arg1, 0x01)) {
                 Store(Arg2, BUFF)
                 Store(BUFF, Local0)
                 Store(Arg2, WIT0)
                 Z00E(WIT0)
                 Return(DSY0)
             }
             If(LEqual(Arg1, 0x02)) {
                 Store(Arg2, Local0)
                 Z00F(Arg2)
                 Return(DSY1)
             }
             If(LEqual(Arg1, 0x03)) {
                 Store(Arg2, Local0)
                 Z00G(Arg2)
                 Return(DSY1)
             }
             If(LEqual(Arg1, 0x04)) {
                 Z00H(Arg1, Arg2)
                 ShiftRight(DerefOf(Index(BCDS, Add(Arg1, 0x05, ), )), 0x1=
 0, BUFF)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x05)) {
                 Z00H(Arg1, Arg2)
                 Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x06)) {
                 Z00I()
                 Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x07)) {
                 Z00J()
                 Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x08)) {
                 Store(Arg2, WPRW)
                 Store(WWD1, WPIR)
                 Store(WWD2, WPIF)
                 Store(WWD3, WPID)
                 Store(WWD4, WPIB)
                 Concatenate(WPCI, WWD0, Local0)
                 Z00K(Local0)
                 Return(DSY2)
             }
             If(LEqual(Arg1, 0x09)) {
                 Store(Arg2, DSY6)
                 Store(DY60, Local0)
                 Store(Arg2, DSY0)
                 Store(DY01, WPRW)
                 Store(WWD1, WPIR)
                 Store(WWD2, WPIF)
                 Store(WWD3, WPID)
                 Store(WWD4, WPIB)
                 Store(WPCI, Local1)
                 Concatenate(DY60, WPCI, Local0)
                 Concatenate(Local0, WWD0, Local1)
                 Z00L(Local1)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x0a)) {
                 Z00M()
                 Store(DerefOf(Index(BCDS, Add(Arg1, 0x02, ), )), BUFF)
                 Return(BUFF)
             }
             If(LEqual(Arg1, 0x0b)) {
                 PCID(Arg2)
                 Return(DSY6)
             }
         }
         Method(WMBE, 3) {
             Z00N(Arg1, Arg2)
             Store(BUFF, Debug)
             Store(BEDS, Debug)
             Store(DerefOf(Index(BEDS, Subtract(Arg1, 0x01, ), )), BUFF)
             Store(BUFF, Debug)
             Return(BUFF)
         }
         Method(WMBF, 3) {
             If(LGreater(Arg1, 0x04)) {
                 Store(0x02, BF00)
                 Store(0x00, BF01)
                 Store(0x00, BF02)
                 Store(0x00, BF03)
                 Return(BUFF)
             }
             If(Z00O()) {
                 Store(Arg2, BUFF)
                 If(LEqual(Arg1, 0x01)) {
                     Z00P(BF00)
                 }
                 Else {
                     If(LEqual(Arg1, 0x02)) {
                         Z00Q(BF00)
                     }
                     Else {
                         If(LEqual(Arg1, 0x03)) {
                             Z00R(BF00)
                         }
                         Else {
                             Z00S(BF00)
                         }
                     }
                 }
                 Store(DerefOf(Index(BFDS, Subtract(Arg1, 0x01, ), )), BUF=
 F)
                 Store(BUFF, Debug)
             }
             Else {
                 Store(0x03, BF00)
                 Store(0x00, BF01)
                 Store(0x00, BF02)
                 Store(0x00, BF03)
             }
             Return(BUFF)
         }
         Method(WMBG, 3) {
             Store(Arg2, BUFF)
             Z00T(BF00)
             Store(DerefOf(Index(BGDS, Subtract(Arg1, 0x01, ), )), BUFF)
             Store(BUFF, Debug)
             Return(BUFF)
         }
     }
     OperationRegion(SMI2, SystemMemory, 0xafeddcdc, 0x00000120)
     Field(SMI2, AnyAcc, NoLock, Preserve) {
         WCMD,	8,
         WDID,	32,
         TPID,	8,
         DI00,	320
     }
     Field(SMI2, AnyAcc, NoLock, Preserve) {
         Offset(0x6),
         D000,	32,
         D001,	32,
         D002,	32,
         D003,	32,
         D004,	32
     }
     Method(PHWM, 2) {
         Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
         Store(0xe0, WCMD)
         Store(0x57, TPID)
         Store(Arg0, WDID)
         Store(Arg1, DI00)
         Store(Zero, \_SB.PCI0.LPC0.SMIC)
         Store(DI00, Local0)
         Release(\_SB.PCI0.LPC0.PSMX)
         Return(Local0)
     }
     Device(PCI0) {
         Name(_HID, 0x080ad041)
         Name(_CID, 0x030ad041)
         Name(_ADR, 0x00)
         Name(_UID, 0x01)
         Name(_BBN, 0x00)
         Name(SUPP, 0x00)
         Name(CTRL, 0x00)
         Method(XOSC, 4) {
             CreateDWordField(Arg3, 0x00, CDW1)
             CreateDWordField(Arg3, 0x04, CDW2)
             CreateDWordField(Arg3, 0x08, CDW3)
             If(LEqual(Arg0, Buffer(0x10) {0x5b, 0x4d, 0xdb, 0x33, 0xf7, 0=
 x1f, 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)
                 }
                 And(CTRL, 0x1d, CTRL)
                 If(Not(And(CDW1, 0x01, ), )) {
                     If(And(CTRL, 0x01, )) {
                     }
                     If(And(CTRL, 0x04, )) {
                         Store(One, \_SB.PCI0.SMB.EPNM)
                         Store(One, \_SB.PCI0.SMB.DPPF)
                         Store(One, \_SB.PCI0.SMB.FNGS)
                     }
                     Else {
                         Store(0x00, \_SB.PCI0.SMB.EPNM)
                         Store(0x00, \_SB.PCI0.SMB.DPPF)
                         Store(0x00, \_SB.PCI0.SMB.FNGS)
                     }
                 }
                 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)
             }
         }
         Method(_INI) {
             Store(0xf1, P80H)
             \_SB.OSTP()
             \_SB.PCI0.LPC0.PHSS(0x76)
             If(LLess(PJID, 0x02)) {
                 \_SB.PCI0.AMD3.HTCS()
             }
             \_GPE._L1A()
             If(LOr(LEqual(PJID, 0x00), LEqual(PJID, 0x02))) {
                 \_SB.PCI0.LPC0.PHSS(0x5a)
                 Notify(\_SB.PCI0.PB9, 0x00)
             }
             If(LAnd(LNot(LLess(TPOS, 0x04)), LLess(TPOS, 0x40))) {
                 Store(And(\_SB.PCI0.SMB.GM4C, 0x01, ), Local0)
                 Store(Local0, \_SB.PCI0.LPC0.INFO)
                 Store(0x8f, \_SB.PCI0.LPC0.BCMD)
                 Store(Zero, \_SB.PCI0.LPC0.SMIC)
             }
         }
         OperationRegion(NBRV, PCI_Config, 0x08, 0x01)
         Field(NBRV, ByteAcc, NoLock, Preserve) {
             PREV,	8
         }
         OperationRegion(NBBR, PCI_Config, 0x1c, 0x08)
         Field(NBBR, DWordAcc, NoLock, Preserve) {
             BR3L,	32,
             BR3H,	32
         }
         OperationRegion(NBBI, PCI_Config, 0x84, 0x04)
         Field(NBBI, DWordAcc, NoLock, Preserve) {
             PARB,	32
         }
         OperationRegion(NBMS, PCI_Config, 0x60, 0x08)
         Field(NBMS, DWordAcc, NoLock, Preserve) {
             MIDX,	32,
             MIDR,	32
         }
         Mutex(NBMM, 0)
         Method(NBMR, 1) {
             Acquire(NBMM, 0xffff)
             And(Arg0, 0x7f, Local0)
             Store(Local0, MIDX)
             Store(MIDR, Local0)
             Store(0x7f, MIDX)
             Release(NBMM)
             Return(Local0)
         }
         Method(NBMW, 2) {
             Acquire(NBMM, 0xffff)
             And(Arg0, 0x7f, Local0)
             Or(Local0, 0x80, Local0)
             Store(Local0, MIDX)
             Store(Arg1, MIDR)
             Store(And(Local0, 0x7f, Local0), MIDX)
             Release(NBMM)
         }
         OperationRegion(NBXP, PCI_Config, 0xe0, 0x08)
         Field(NBXP, DWordAcc, NoLock, Preserve) {
             NBXI,	32,
             NBXD,	32
         }
         Mutex(NBXM, 0)
         Method(NBXR, 1) {
             Acquire(NBXM, 0xffff)
             Store(Arg0, NBXI)
             Store(NBXD, Local0)
             Store(0x00, NBXI)
             Release(NBXM)
             Return(Local0)
         }
         Method(NBXW, 2) {
             Acquire(NBXM, 0xffff)
             Store(Arg0, NBXI)
             Store(Arg1, NBXD)
             Store(0x00, NBXI)
             Release(NBXM)
         }
         Method(GFXM) {
             Store(NBMR(0x08), Local0)
             And(Local0, 0x0f, Local0)
             Return(Local0)
         }
         Method(GPPM) {
             Store(NBMR(0x31), Local0)
             And(Local0, 0x0f, Local0)
             Return(Local0)
         }
         Method(XPTR, 2) {
             If(LAnd(LLess(Arg0, 0x02), LGreater(Arg0, 0x07))) {
                 Return(0x00)
             }
             Else {
                 Store(0x01, Local0)
                 If(LLess(Arg0, 0x04)) {
                     Add(Arg0, 0x02, Local1)
                 }
                 Else {
                     Add(Arg0, 0x11, Local1)
                 }
                 ShiftLeft(Local0, Local1, Local0)
                 Store(NBMR(0x08), Local2)
                 If(Arg1) {
                     And(Local2, Not(Local0, ), Local2)
                 }
                 Else {
                     Or(Local2, Local0, Local2)
                 }
                 NBMW(0x08, Local2)
                 Return(Ones)
             }
         }
         Name(PX3L, 0x80000000)
         Name(PX3H, 0x80000000)
         Name(PX3S, 0x10000000)
         Name(PX3K, 0xf0000000)
         Mutex(BR3X, 0)
         Method(BR3M) {
             Store(PARB, Local0)
             ShiftRight(Local0, 0x10, Local0)
             And(Local0, 0x07, Local0)
             If(Local0) {
                 ShiftLeft(0x01, Local0, Local1)
                 Subtract(0x1000, Local1, Local1)
                 ShiftLeft(Local1, 0x14, Local1)
                 Store(Local1, PX3K)
                 ShiftRight(0x00100000, Local0, Local0)
                 Store(Local0, PX3S)
             }
             Acquire(BR3X, 0xffff)
             Store(NBMR(0x00), Local0)
             And(Local0, 0xfffffff7, Local0)
             NBMW(0x00, Local0)
             Store(BR3L, Local0)
             And(Local0, PX3K, Local0)
             Store(Local0, PX3L)
             Store(BR3H, Local0)
             And(Local0, 0xff, Local0)
             Store(Local0, PX3H)
             Store(NBMR(0x00), Local0)
             Or(Local0, 0x08, Local0)
             NBMW(0x00, Local0)
             Release(BR3X)
             Return(PX3L)
         }
         OperationRegion(K8ST, SystemMemory, 0xafeddf74, 0x00000048)
         Field(K8ST, AnyAcc, NoLock, Preserve) {
             C0_0,	16,
             C2_0,	16,
             C4_0,	16,
             C6_0,	16,
             C8_0,	16,
             CA_0,	16,
             CC_0,	16,
             CE_0,	16,
             D0_0,	16,
             D2_0,	16,
             D4_0,	16,
             D6_0,	16,
             D8_0,	16,
             DA_0,	16,
             DC_0,	16,
             DE_0,	16,
             E0_0,	16,
             E2_0,	16,
             E4_0,	16,
             E6_0,	16,
             E8_0,	16,
             EA_0,	16,
             EC_0,	16,
             EE_0,	16,
             F0_0,	16,
             F2_0,	16,
             F4_0,	16,
             F6_0,	16,
             F8_0,	16,
             FA_0,	16,
             FC_0,	16,
             FE_0,	16,
             TOML,	32,
             TOMH,	32
         }
         Name(RSRC, Buffer(0x0316) {0x88, 0xe, 0x0, 0x2, 0xe, 0x0, 0x0, 0x=
 0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0x=
 e, 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, 0x1f, 0xc, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x20, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x5f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x60, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, =
 0x0, 0x80, 0xc, 0x0, 0xff, 0x9f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20,=
  0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, =
 0xa0, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0,=
  0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0,=
  0xc, 0x0, 0xff, 0xdf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0,=
  0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0, 0xc,=
  0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,=
  0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, =
 0xff, 0x1f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87,=
  0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0xd, 0x0, 0xff,=
  0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18=
 , 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x5f=
 , 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0=
 , 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x60, 0xd, 0x0, 0xff, 0x7f, 0xd=
 , 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0=
 , 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0x9f, 0xd, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe=
 , 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1=
 , 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xdf, 0xd, 0x0, 0x0, 0x0=
 , 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0xe0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0=
 , 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0=
 , 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0xff, 0x1f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0,=
  0x0, 0x0, 0x20, 0xe, 0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0,=
  0x0, 0x40, 0xe, 0x0, 0xff, 0x5f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20=
 , 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x60, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0=
 , 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80=
 , 0xe, 0x0, 0xff, 0x9f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0=
 , 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xe=
 , 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0=
 , 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0=
 , 0xff, 0xdf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x8=
 7, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0, 0xe, 0x0, 0xf=
 f, 0xff, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x=
 18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, =
 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, =
 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, 0=
 xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0=
 x0, 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)
             Store(0x2000, C0LN)
             If(And(C0_0, 0x1818, )) {
                 Store(0x00, C0LN)
             }
             CreateBitField(RSRC, 0x0260, C2RW)
             CreateDWordField(RSRC, 0x5d, C2LN)
             Store(One, C2RW)
             Store(0x2000, C2LN)
             If(And(C2_0, 0x1818, )) {
                 Store(0x00, C2LN)
             }
             CreateBitField(RSRC, 0x0338, C4RW)
             CreateDWordField(RSRC, 0x78, C4LN)
             Store(One, C4RW)
             Store(0x2000, C4LN)
             If(And(C4_0, 0x1818, )) {
                 Store(0x00, C4LN)
             }
             CreateBitField(RSRC, 0x0410, C6RW)
             CreateDWordField(RSRC, 0x93, C6LN)
             Store(One, C6RW)
             Store(0x2000, C6LN)
             If(And(C6_0, 0x1818, )) {
                 Store(0x00, C6LN)
             }
             CreateBitField(RSRC, 0x04e8, C8RW)
             CreateDWordField(RSRC, 0xae, C8LN)
             Store(One, C8RW)
             Store(0x2000, C8LN)
             If(And(C8_0, 0x1818, )) {
                 Store(0x00, C8LN)
             }
             CreateBitField(RSRC, 0x05c0, CARW)
             CreateDWordField(RSRC, 0xc9, CALN)
             Store(One, CARW)
             Store(0x2000, CALN)
             If(And(CA_0, 0x1818, )) {
                 Store(0x00, CALN)
             }
             CreateBitField(RSRC, 0x0698, CCRW)
             CreateDWordField(RSRC, 0xe4, CCLN)
             Store(One, CCRW)
             Store(0x2000, CCLN)
             If(And(CC_0, 0x1818, )) {
                 Store(0x00, CCLN)
             }
             CreateBitField(RSRC, 0x0770, CERW)
             CreateDWordField(RSRC, 0xff, CELN)
             Store(One, CERW)
             Store(0x2000, CELN)
             If(And(CE_0, 0x1818, )) {
                 Store(0x00, CELN)
             }
             CreateBitField(RSRC, 0x0848, D0RW)
             CreateDWordField(RSRC, 0x011a, D0LN)
             Store(One, D0RW)
             Store(0x2000, D0LN)
             If(And(D0_0, 0x1818, )) {
                 Store(0x00, D0LN)
             }
             CreateBitField(RSRC, 0x0920, D2RW)
             CreateDWordField(RSRC, 0x0135, D2LN)
             Store(One, D2RW)
             Store(0x2000, D2LN)
             If(And(D2_0, 0x1818, )) {
                 Store(0x00, D2LN)
             }
             CreateBitField(RSRC, 0x09f8, D4RW)
             CreateDWordField(RSRC, 0x0150, D4LN)
             Store(One, D4RW)
             Store(0x2000, D4LN)
             If(And(D4_0, 0x1818, )) {
                 Store(0x00, D4LN)
             }
             CreateBitField(RSRC, 0x0ad0, D6RW)
             CreateDWordField(RSRC, 0x016b, D6LN)
             Store(One, D6RW)
             Store(0x2000, D6LN)
             If(And(D6_0, 0x1818, )) {
                 Store(0x00, D6LN)
             }
             CreateBitField(RSRC, 0x0ba8, D8RW)
             CreateDWordField(RSRC, 0x0186, D8LN)
             Store(One, D8RW)
             Store(0x2000, D8LN)
             If(And(D8_0, 0x1818, )) {
                 Store(0x00, D8LN)
             }
             CreateBitField(RSRC, 0x0c80, DARW)
             CreateDWordField(RSRC, 0x01a1, DALN)
             Store(One, DARW)
             Store(0x2000, DALN)
             If(And(DA_0, 0x1818, )) {
                 Store(0x00, DALN)
             }
             CreateBitField(RSRC, 0x0d58, DCRW)
             CreateDWordField(RSRC, 0x01bc, DCLN)
             Store(One, DCRW)
             Store(0x2000, DCLN)
             If(And(DC_0, 0x1818, )) {
                 Store(0x00, DCLN)
             }
             CreateBitField(RSRC, 0x0e30, DERW)
             CreateDWordField(RSRC, 0x01d7, DELN)
             Store(One, DERW)
             Store(0x2000, DELN)
             If(And(DE_0, 0x1818, )) {
                 Store(0x00, DELN)
             }
             CreateBitField(RSRC, 0x0f08, E0RW)
             CreateDWordField(RSRC, 0x01f2, E0LN)
             Store(One, E0RW)
             Store(0x2000, E0LN)
             If(And(E0_0, 0x1818, )) {
                 Store(0x00, E0LN)
             }
             CreateBitField(RSRC, 0x0fe0, E2RW)
             CreateDWordField(RSRC, 0x020d, E2LN)
             Store(One, E2RW)
             Store(0x2000, E2LN)
             If(And(E2_0, 0x1818, )) {
                 Store(0x00, E2LN)
             }
             CreateBitField(RSRC, 0x10b8, E4RW)
             CreateDWordField(RSRC, 0x0228, E4LN)
             Store(One, E4RW)
             Store(0x2000, E4LN)
             If(And(E4_0, 0x1818, )) {
                 Store(0x00, E4LN)
             }
             CreateBitField(RSRC, 0x1190, E6RW)
             CreateDWordField(RSRC, 0x0243, E6LN)
             Store(One, E6RW)
             Store(0x2000, E6LN)
             If(And(E6_0, 0x1818, )) {
                 Store(0x00, E6LN)
             }
             CreateBitField(RSRC, 0x1268, E8RW)
             CreateDWordField(RSRC, 0x025e, E8LN)
             Store(One, E8RW)
             Store(0x2000, E8LN)
             If(And(E8_0, 0x1818, )) {
                 Store(0x00, E8LN)
             }
             CreateBitField(RSRC, 0x1340, EARW)
             CreateDWordField(RSRC, 0x0279, EALN)
             Store(One, EARW)
             Store(0x2000, EALN)
             If(And(EA_0, 0x1818, )) {
                 Store(0x00, EALN)
             }
             CreateBitField(RSRC, 0x1418, ECRW)
             CreateDWordField(RSRC, 0x0294, ECLN)
             Store(One, ECRW)
             Store(0x2000, ECLN)
             If(And(EC_0, 0x1818, )) {
                 Store(0x00, ECLN)
             }
             CreateBitField(RSRC, 0x14f0, EERW)
             CreateDWordField(RSRC, 0x02af, EELN)
             Store(One, EERW)
             Store(0x2000, EELN)
             If(And(EE_0, 0x1818, )) {
                 Store(0x00, EELN)
             }
             CreateDWordField(RSRC, 0x02be, BT1S)
             CreateDWordField(RSRC, 0x02c2, BT1M)
             CreateDWordField(RSRC, 0x02ca, BT1L)
             CreateDWordField(RSRC, 0x02d9, BT2S)
             CreateDWordField(RSRC, 0x02dd, BT2M)
             CreateDWordField(RSRC, 0x02e5, BT2L)
             Store(BR3M(), Local0)
             Store(PX3H, Local2)
             Store(PX3S, Local1)
             If(Local2) {
                 Store(0x00, Local1)
                 Store(TOML, Local0)
             }
             Store(TOML, BT1S)
             Store(Subtract(Local0, 0x01, ), BT1M)
             Subtract(Local0, TOML, BT1L)
             Store(Add(Local0, Local1, ), BT2S)
             Store(Add(Subtract(BT2M, BT2S, ), 0x01, ), BT2L)
             Return(RSRC)
         }
         Device(MEMR) {
             Name(_HID, 0x020cd041)
             Name(MEM1, Buffer(0x26) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, =
 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
 0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x79, 0x0 })
             Method(_CRS) {
                 CreateDWordField(MEM1, 0x04, MB01)
                 CreateDWordField(MEM1, 0x08, ML01)
                 CreateDWordField(MEM1, 0x10, MB02)
                 CreateDWordField(MEM1, 0x14, ML02)
                 CreateDWordField(MEM1, 0x1c, MB03)
                 CreateDWordField(MEM1, 0x20, ML03)
                 If(GPIC) {
                     Store(0xfec00000, MB01)
                     Store(0xfec10000, MB02)
                     Store(0xfee00000, MB03)
                     Store(0x1000, ML01)
                     Store(0x1000, ML02)
                     Store(0x1000, ML03)
                 }
                 Return(MEM1)
             }
         }
         Method(_PRT) {
             If(GPIC) {
                 Return(Package(0x16) {
                     Package(0x04) {
                         0x0001ffff,
                         0x00,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0001ffff,
                         0x01,
                         0x00,
                         0x13,
                     },
                     Package(0x04) {
                         0x0002ffff,
                         0x00,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0003ffff,
                         0x00,
                         0x00,
                         0x13,
                     },
                     Package(0x04) {
                         0x0004ffff,
                         0x00,
                         0x00,
                         0x10,
                     },
                     Package(0x04) {
                         0x0005ffff,
                         0x00,
                         0x00,
                         0x11,
                     },
                     Package(0x04) {
                         0x0006ffff,
                         0x00,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0007ffff,
                         0x00,
                         0x00,
                         0x13,
                     },
                     Package(0x04) {
                         0x0009ffff,
                         0x00,
                         0x00,
                         0x11,
                     },
                     Package(0x04) {
                         0x000affff,
                         0x00,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0011ffff,
                         0x00,
                         0x00,
                         0x16,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x00,
                         0x00,
                         0x10,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x01,
                         0x00,
                         0x11,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x02,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x00,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x01,
                         0x00,
                         0x13,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x02,
                         0x00,
                         0x10,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x05,
                         0x00,
                         0x11,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x00,
                         0x00,
                         0x10,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x01,
                         0x00,
                         0x11,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x02,
                         0x00,
                         0x12,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x03,
                         0x00,
                         0x13,
                     },
                 })
             }
             Else {
                 Return(Package(0x15) {
                     Package(0x04) {
                         0x0001ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0001ffff,
                         0x01,
                         \_SB.PCI0.LPC0.LNKD,
                         0x00,
                     },
                     Package(0x04) {
                         0x0002ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0003ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKD,
                         0x00,
                     },
                     Package(0x04) {
                         0x0004ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKA,
                         0x00,
                     },
                     Package(0x04) {
                         0x0005ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKB,
                         0x00,
                     },
                     Package(0x04) {
                         0x0006ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0007ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKD,
                         0x00,
                     },
                     Package(0x04) {
                         0x0009ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKB,
                         0x00,
                     },
                     Package(0x04) {
                         0x000affff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0011ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKG,
                         0x00,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKA,
                         0x00,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x01,
                         \_SB.PCI0.LPC0.LNKB,
                         0x00,
                     },
                     Package(0x04) {
                         0x0012ffff,
                         0x02,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKA,
                         0x00,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x01,
                         \_SB.PCI0.LPC0.LNKB,
                         0x00,
                     },
                     Package(0x04) {
                         0x0013ffff,
                         0x02,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x00,
                         \_SB.PCI0.LPC0.LNKA,
                         0x00,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x01,
                         \_SB.PCI0.LPC0.LNKB,
                         0x00,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x02,
                         \_SB.PCI0.LPC0.LNKC,
                         0x00,
                     },
                     Package(0x04) {
                         0x0014ffff,
                         0x03,
                         \_SB.PCI0.LPC0.LNKD,
                         0x00,
                     },
                 })
             }
         }
         OperationRegion(BAR1, PCI_Config, 0x14, 0x04)
         Field(BAR1, ByteAcc, NoLock, Preserve) {
             Z00U,	32
         }
         Name(HTLV, 0x56)
         Device(AMD3) {
             Name(_ADR, 0x00180003)
             OperationRegion(HTCR, PCI_Config, 0x64, 0x04)
             Field(HTCR, ByteAcc, NoLock, Preserve) {
                 HTCE,	1,
                 Offset(0x2),
                 HTL,	7,
                 Offset(0x3),
                 HHL,	4
             }
             Method(HTCS) {
                 Store(HTLV, Local0)
                 Add(Local0, HHL, HTL)
                 Store(One, HTCE)
             }
         }
         Device(PB2) {
             Name(_ADR, 0x00020000)
             OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
             Field(XPCB, ByteAcc, NoLock, Preserve) {
                 Offset(0x10),
                 LKCN,	16,
                 LKST,	16,
                 Offset(0x1a),
                 SLST,	16
             }
             OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
             Field(XPRI, ByteAcc, NoLock, Preserve) {
                 XPIR,	32,
                 XPID,	32
             }
             OperationRegion(XPEX, SystemMemory, 0xe0010100, 0x0100)
             Field(XPEX, DWordAcc, NoLock, Preserve) {
                 Offset(0x28),
                 VC02,	32
             }
             Method(XPDL) {
                 If(And(VC02, 0x00020000, )) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Method(XPRD, 1) {
                 Store(Arg0, XPIR)
                 Store(XPID, Local0)
                 Store(0x00, XPIR)
                 Return(Local0)
             }
             Method(XPWR, 2) {
                 Store(Arg0, XPIR)
                 Store(Arg1, XPID)
                 Store(0x00, XPIR)
             }
             Method(XPRT) {
                 Store(XPRD(0xa2), Local0)
                 And(Local0, Not(0x07, ), Local0)
                 ShiftRight(Local0, 0x04, Local1)
                 And(Local1, 0x07, Local1)
                 Or(Local0, Local1, Local0)
                 Or(Local0, 0x0100, Local0)
                 XPWR(0xa2, Local0)
             }
             Method(XPLP, 1) {
                 Store(0x0101, Local1)
                 Store(\_SB.PCI0.NBXR(0x65), Local2)
                 If(Arg0) {
                     And(Local2, Not(Local1, ), Local2)
                 }
                 Else {
                     Or(Local2, Local1, Local2)
                 }
                 \_SB.PCI0.NBXW(0x65, Local2)
             }
             Method(XPR2) {
                 Store(LKCN, Local0)
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 Or(Local0, 0x20, Local0)
                 Store(Local0, LKCN)
                 Store(0x64, Local1)
                 Store(0x01, Local2)
                 While(LAnd(Local1, Local2)) {
                     Sleep(0x01)
                     Store(LKST, Local3)
                     If(And(Local3, 0x0800, )) {
                         Decrement(Local1)
                     }
                     Else {
                         Store(0x00, Local2)
                     }
                 }
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 If(LNot(Local2)) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Device(DGFX) {
                 Name(_ADR, 0x00)
                 OperationRegion(PCFG, PCI_Config, 0x00, 0x50)
                 Field(PCFG, DWordAcc, NoLock, Preserve) {
                     DVID,	32,
                     Offset(0x2c),
                     SVID,	32,
                     Offset(0x4c),
                     SMID,	32
                 }
                 Name(SWIT, 0x01)
                 Name(CRTA, 0x01)
                 Name(LCDA, 0x01)
                 Name(TVAA, 0x01)
                 Name(DVIA, 0x01)
                 Name(VLDF, 0x01)
                 Method(_STA) {
                     Return(0x0f)
                 }
                 Name(_PSC, 0x00)
                 Method(_PS0) {
                     Store(0x00, _PSC)
                 }
                 Method(_PS1) {
                     Store(0x01, _PSC)
                 }
                 Method(_PS3) {
                     Store(0x03, _PSC)
                 }
                 Method(_DOS, 1) {
                     Store(And(Arg0, 0x03, ), SWIT)
                 }
                 Method(_DOD) {
                     Return(Package(0x04) {
                         0x00010100,
                         0x00010110,
                         0x0200,
                         0x0210,
                     })
                 }
                 Device(CRT) {
                     Method(_ADR) {
                         Return(0x0100)
                     }
                 }
                 Device(LCD) {
                     Method(_ADR) {
                         Return(0x0110)
                     }
                     Method(_BCL) {
                         Store(0xc0, P80H)
                         Return(Package(0x0c) {
                             0x64,
                             0x46,
                             0x0a,
                             0x14,
                             0x1e,
                             0x28,
                             0x32,
                             0x3c,
                             0x46,
                             0x50,
                             0x5a,
                             0x64,
                         })
                     }
                     Method(_BCM, 1) {
                         Store(0xc1, P80H)
                         Divide(Arg0, 0x0a, Local0, Local1)
                         Decrement(Local1)
                         Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS)
                     }
                     Method(_BQC) {
                         Store(0xc2, P80H)
                         Multiply(\_SB.PCI0.LPC0.EC0.BRTS, 0x0a, Local0)
                         Add(Local0, 0x01, Local0)
                         Sleep(0x64)
                         Return(Local0)
                     }
                 }
                 Device(TV) {
                     Method(_ADR) {
                         Return(0x0200)
                     }
                 }
                 Device(DVI) {
                     Method(_ADR) {
                         Return(0x0210)
                     }
                 }
             }
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(PB3) {
             Name(_ADR, 0x00030000)
             OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
             Field(XPCB, ByteAcc, NoLock, Preserve) {
                 Offset(0x10),
                 LKCN,	16,
                 LKST,	16,
                 Offset(0x1a),
                 SLST,	16
             }
             OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
             Field(XPRI, ByteAcc, NoLock, Preserve) {
                 XPIR,	32,
                 XPID,	32
             }
             OperationRegion(XPEX, SystemMemory, 0xe0018100, 0x0100)
             Field(XPEX, DWordAcc, NoLock, Preserve) {
                 Offset(0x28),
                 VC02,	32
             }
             Method(XPDL) {
                 If(And(VC02, 0x00020000, )) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Method(XPRD, 1) {
                 Store(Arg0, XPIR)
                 Store(XPID, Local0)
                 Store(0x00, XPIR)
                 Return(Local0)
             }
             Method(XPWR, 2) {
                 Store(Arg0, XPIR)
                 Store(Arg1, XPID)
                 Store(0x00, XPIR)
             }
             Method(XPRT) {
                 Store(XPRD(0xa2), Local0)
                 And(Local0, Not(0x07, ), Local0)
                 ShiftRight(Local0, 0x04, Local1)
                 And(Local1, 0x07, Local1)
                 Or(Local0, Local1, Local0)
                 Or(Local0, 0x0100, Local0)
                 XPWR(0xa2, Local0)
             }
             Method(XPLP, 1) {
                 Store(0x0101, Local1)
                 Store(\_SB.PCI0.NBXR(0x65), Local2)
                 If(Arg0) {
                     And(Local2, Not(Local1, ), Local2)
                 }
                 Else {
                     Or(Local2, Local1, Local2)
                 }
                 \_SB.PCI0.NBXW(0x65, Local2)
             }
             Method(XPR2) {
                 Store(LKCN, Local0)
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 Or(Local0, 0x20, Local0)
                 Store(Local0, LKCN)
                 Store(0x64, Local1)
                 Store(0x01, Local2)
                 While(LAnd(Local1, Local2)) {
                     Sleep(0x01)
                     Store(LKST, Local3)
                     If(And(Local3, 0x0800, )) {
                         Decrement(Local1)
                     }
                     Else {
                         Store(0x00, Local2)
                     }
                 }
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 If(LNot(Local2)) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Device(DGFX) {
                 Name(_ADR, 0x00)
                 OperationRegion(PCFG, PCI_Config, 0x00, 0x50)
                 Field(PCFG, DWordAcc, NoLock, Preserve) {
                     DVID,	32,
                     Offset(0x2c),
                     SVID,	32,
                     Offset(0x4c),
                     SMID,	32
                 }
             }
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(PB4) {
             Name(_ADR, 0x00040000)
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                     })
                 }
             }
             OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
             Field(XPCB, ByteAcc, NoLock, Preserve) {
                 Offset(0x10),
                 LKCN,	16,
                 LKST,	16,
                 Offset(0x1a),
                 SLST,	16
             }
             OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
             Field(XPRI, ByteAcc, NoLock, Preserve) {
                 XPIR,	32,
                 XPID,	32
             }
             OperationRegion(XPEX, SystemMemory, 0xe0020100, 0x0100)
             Field(XPEX, DWordAcc, NoLock, Preserve) {
                 Offset(0x28),
                 VC0S,	32
             }
             Method(XPDL) {
                 Store(Zero, Local0)
                 If(And(VC0S, 0x00020000, )) {
                     Store(Ones, Local0)
                 }
                 Return(Local0)
             }
             Method(XPRD, 1) {
                 Store(Arg0, XPIR)
                 Store(XPID, Local0)
                 Store(0x00, XPIR)
                 Return(Local0)
             }
             Method(XPWR, 2) {
                 Store(Arg0, XPIR)
                 Store(Arg1, XPID)
                 Store(0x00, XPIR)
             }
             Method(XPRT) {
                 Store(XPRD(0xa2), Local0)
                 And(Local0, Not(0x07, ), Local0)
                 ShiftRight(Local0, 0x04, Local1)
                 And(Local1, 0x07, Local1)
                 Or(Local0, Local1, Local0)
                 Or(Local0, 0x0100, Local0)
                 XPWR(0xa2, Local0)
             }
             Method(XPLP, 1) {
                 Store(0x1010, Local1)
                 Store(\_SB.PCI0.NBXR(0x00010065), Local2)
                 If(Arg0) {
                     And(Local2, Not(Local1, ), Local2)
                 }
                 Else {
                     Or(Local2, Local1, Local2)
                 }
                 \_SB.PCI0.NBXW(0x00010065, Local2)
             }
             Method(XPR2) {
                 Store(LKCN, Local0)
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 Or(Local0, 0x20, Local0)
                 Store(Local0, LKCN)
                 Store(0x64, Local1)
                 Store(0x01, Local2)
                 While(LAnd(Local1, Local2)) {
                     Sleep(0x01)
                     Store(LKST, Local3)
                     If(And(Local3, 0x0800, )) {
                         Decrement(Local1)
                     }
                     Else {
                         Store(0x00, Local2)
                     }
                 }
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 If(LNot(Local2)) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Device(NCRD) {
                 Name(_ADR, 0x00)
                 OperationRegion(PCFG, PCI_Config, 0x00, 0x08)
                 Field(PCFG, DWordAcc, NoLock, Preserve) {
                     DVID,	32,
                     PCMS,	32
                 }
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
         }
         Device(PB5) {
             Name(_ADR, 0x00050000)
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(PB6) {
             Name(_ADR, 0x00060000)
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(PB7) {
             Name(_ADR, 0x00070000)
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(PB9) {
             Name(_ADR, 0x00090000)
             OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
             Field(XPCB, ByteAcc, NoLock, Preserve) {
                 Offset(0x10),
                 LKCN,	16,
                 LKST,	16,
                 Offset(0x1a),
                 SLST,	16
             }
             OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
             Field(XPRI, ByteAcc, NoLock, Preserve) {
                 XPIR,	32,
                 XPID,	32
             }
             OperationRegion(XPEX, SystemMemory, 0xe0038100, 0x0100)
             Field(XPEX, DWordAcc, NoLock, Preserve) {
                 Offset(0x28),
                 VC0S,	32
             }
             Method(XPDL) {
                 Store(Zero, Local0)
                 If(And(VC0S, 0x00020000, )) {
                     Store(Ones, Local0)
                 }
                 Return(Local0)
             }
             Method(XPRD, 1) {
                 Store(Arg0, XPIR)
                 Store(XPID, Local0)
                 Store(0x00, XPIR)
                 Return(Local0)
             }
             Method(XPWR, 2) {
                 Store(Arg0, XPIR)
                 Store(Arg1, XPID)
                 Store(0x00, XPIR)
             }
             Method(XPRT) {
                 Store(XPRD(0xa2), Local0)
                 And(Local0, Not(0x07, ), Local0)
                 ShiftRight(Local0, 0x04, Local1)
                 And(Local1, 0x07, Local1)
                 Or(Local0, Local1, Local0)
                 Or(Local0, 0x0100, Local0)
                 XPWR(0xa2, Local0)
             }
             Method(XPLP, 1) {
                 Store(0x8080, Local1)
                 Store(\_SB.PCI0.NBXR(0x00010065), Local2)
                 If(Arg0) {
                     And(Local2, Not(Local1, ), Local2)
                 }
                 Else {
                     Or(Local2, Local1, Local2)
                 }
                 \_SB.PCI0.NBXW(0x00010065, Local2)
             }
             Method(XPR2) {
                 Store(LKCN, Local0)
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 Or(Local0, 0x20, Local0)
                 Store(Local0, LKCN)
                 Store(0x64, Local1)
                 Store(0x01, Local2)
                 While(LAnd(Local1, Local2)) {
                     Sleep(0x01)
                     Store(LKST, Local3)
                     If(And(Local3, 0x0800, )) {
                         Decrement(Local1)
                     }
                     Else {
                         Store(0x00, Local2)
                     }
                 }
                 And(Local0, Not(0x20, ), Local0)
                 Store(Local0, LKCN)
                 If(LNot(Local2)) {
                     Return(Ones)
                 }
                 Else {
                     Return(Zero)
                 }
             }
             Device(J380) {
                 Name(_ADR, 0x00)
                 OperationRegion(PCFG, PCI_Config, 0x00, 0xff)
                 Field(PCFG, ByteAcc, NoLock, Preserve) {
                     DVID,	32,
                     Offset(0x2c),
                     SSID,	32,
                     Offset(0xac),
                     ,	6,
                     D3EF,	1,
                     Offset(0xb2),
                     LAT0,	8,
                     Offset(0xcf),
                     ATRB,	8,
                     Offset(0xd3),
                     PMC0,	8
                 }
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
             Device(J381) {
                 Name(_ADR, 0x01)
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
             Device(J382) {
                 Name(_ADR, 0x02)
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
             Device(J383) {
                 Name(_ADR, 0x03)
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
             Device(J384) {
                 Name(_ADR, 0x04)
                 Method(_RMV) {
                     Return(0x01)
                 }
             }
         }
         Device(PB10) {
             Name(_ADR, 0x000a0000)
             Name(_PRW, Package(0x02) {
                 0x18,
                 0x04,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(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,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x04) {
                         Package(0x04) {
                             0xffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x02,
                             \_SB.PCI0.LPC0.LNKA,
                             0x00,
                         },
                         Package(0x04) {
                             0xffff,
                             0x03,
                             \_SB.PCI0.LPC0.LNKB,
                             0x00,
                         },
                     })
                 }
             }
         }
         Scope(\_GPE) {
             Method(_L18) {
                 Notify(\_SB.PCI0.PB2, 0x02)
                 Notify(\_SB.PCI0.PB4, 0x02)
                 Notify(\_SB.PCI0.PB5, 0x02)
                 Notify(\_SB.PCI0.PB6, 0x02)
                 Notify(\_SB.PCI0.PB7, 0x02)
                 Notify(\_SB.PCI0.PB9, 0x02)
                 Notify(\_SB.PCI0.PB10, 0x02)
             }
         }
         Device(OHC0) {
             Name(_ADR, 0x00120000)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(OHC1) {
             Name(_ADR, 0x00120001)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(OHC2) {
             Name(_ADR, 0x00130000)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(OHC3) {
             Name(_ADR, 0x00130001)
         }
         Device(OHC4) {
             Name(_ADR, 0x00140005)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(EHC0) {
             Name(_ADR, 0x00120002)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(EHC1) {
             Name(_ADR, 0x00130002)
             Name(_PRW, Package(0x02) {
                 0x0b,
                 0x03,
             })
         }
         Device(SATA) {
             Name(_ADR, 0x00110000)
             Name(B5EN, 0x00)
             Name(BA_5, 0x00)
             Name(SBAR, 0xf0508000)
             OperationRegion(SATX, PCI_Config, 0x00, 0x28)
             Field(SATX, AnyAcc, NoLock, Preserve) {
                 VIDI,	32,
                 Offset(0x24),
                 BA05,	32
             }
             Method(GBAA, 0, Serialized) {
                 Store(BA05, BA_5)
                 If(LEqual(BA_5, 0xffffffff)) {
                     Store(0x00, B5EN)
                     Return(SBAR)
                 }
                 Else {
                     Store(0x01, B5EN)
                     Return(BA_5)
                 }
             }
             OperationRegion(BAR5, SystemMemory, GBAA, 0x1000)
             Field(BAR5, AnyAcc, NoLock, Preserve) {
                 Offset(0x120),
                 ,	7,
                 PMBY,	1,
                 Offset(0x128),
                 PMS0,	4,
                 Offset(0x129),
                 PMS1,	4,
                 Offset(0x12c),
                 DET0,	4,
                 Offset(0x130),
                 Offset(0x132),
                 PRC0,	1,
                 Offset(0x1a0),
                 ,	7,
                 SMBY,	1,
                 Offset(0x1a8),
                 SMS0,	4,
                 Offset(0x1a9),
                 SMS1,	4,
                 Offset(0x1ac),
                 DET1,	4,
                 Offset(0x1b0),
                 Offset(0x1b2),
                 PRC1,	1,
                 Offset(0x220),
                 ,	7,
                 PSBY,	1,
                 Offset(0x228),
                 PSS0,	4,
                 Offset(0x229),
                 PSS1,	4,
                 Offset(0x22c),
                 DET2,	4,
                 Offset(0x230),
                 Offset(0x232),
                 PRC2,	1,
                 Offset(0x2a0),
                 ,	7,
                 SSBY,	1,
                 Offset(0x2a8),
                 SSS0,	4,
                 Offset(0x2a9),
                 SSS1,	4,
                 Offset(0x2ac),
                 DET3,	4,
                 Offset(0x2b0),
                 Offset(0x2b2),
                 PRC3,	1
             }
             Method(_INI) {
                 GBAA()
             }
             Device(PRID) {
                 Name(_ADR, 0x00)
                 Name(SPTM, Buffer(0x14) {0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0=
 x0, 0x0, 0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x1f, 0x0, 0x0, 0x0 })
                 Method(_GTM) {
                     Return(SPTM)
                 }
                 Method(_STM, 3) {
                     Store(Arg0, SPTM)
                 }
                 Name(PRIS, 0x00)
                 Method(_PS0) {
                     GBAA()
                     If(LAnd(LOr(LEqual(TPOS, 0x40), LEqual(TPOS, 0x04)), =
 \_SB.PCI0.SATA.B5EN)) {
                         If(\_SB.PCI0.SATA.PMS1) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.PMBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         If(\_SB.PCI0.SATA.PSS1) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.PSBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                     }
                     Store(0x00, PRIS)
                 }
                 Method(_PS3) {
                     Store(0x03, PRIS)
                 }
                 Method(_PSC) {
                     Return(PRIS)
                 }
                 Device(P_D0) {
                     Name(_ADR, 0x00)
                     Method(_STA) {
                         GBAA()
                         If(LEqual(B5EN, 0x00)) {
                             Return(0x00)
                         }
                         If(Not(LEqual(\_SB.PCI0.SATA.PMS1, 0x00), )) {
                             Return(0x0f)
                         }
                         Else {
                             Return(0x00)
                         }
                     }
                     Name(S12P, 0x00)
                     Method(_PS0) {
                         GBAA()
                         If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
 l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.PMBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         Store(0x00, S12P)
                     }
                     Method(_PS3) {
                         Store(0x03, S12P)
                     }
                     Method(_PSC) {
                         Return(S12P)
                     }
                     Method(_GTF) {
                         Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
 0, 0xef }, Local0)
                         Return(Local0)
                     }
                 }
                 Device(P_D1) {
                     Name(_ADR, 0x01)
                     Method(_STA) {
                         GBAA()
                         If(LEqual(B5EN, 0x00)) {
                             Return(0x00)
                         }
                         If(Not(LEqual(\_SB.PCI0.SATA.SMS1, 0x00), )) {
                             Return(0x0f)
                         }
                         Else {
                             Return(0x00)
                         }
                     }
                     Name(S12P, 0x00)
                     Method(_PS0) {
                         GBAA()
                         If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
 l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.PSBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         Store(0x00, S12P)
                     }
                     Method(_PS3) {
                         Store(0x03, S12P)
                     }
                     Method(_PSC) {
                         Return(S12P)
                     }
                     Method(_GTF) {
                         Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
 0, 0xef }, Local0)
                         Return(Local0)
                     }
                 }
             }
             Device(SECD) {
                 Name(_ADR, 0x01)
                 Name(SPTM, Buffer(0x14) {0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0=
 x0, 0x0, 0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x1f, 0x0, 0x0, 0x0 })
                 Method(_GTM) {
                     Return(SPTM)
                 }
                 Method(_STM, 3) {
                     Store(Arg0, SPTM)
                 }
                 Name(SECS, 0x00)
                 Method(_PS0) {
                     GBAA()
                     If(LAnd(LOr(LEqual(TPOS, 0x40), LEqual(TPOS, 0x04)), =
 \_SB.PCI0.SATA.B5EN)) {
                         If(\_SB.PCI0.SATA.SMS1) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.SMBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         If(\_SB.PCI0.SATA.SSS1) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.SSBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                     }
                     Store(0x00, SECS)
                 }
                 Method(_PS3) {
                     Store(0x03, SECS)
                 }
                 Method(_PSC) {
                     Return(SECS)
                 }
                 Device(S_D0) {
                     Name(_ADR, 0x00)
                     Method(_STA) {
                         GBAA()
                         If(LEqual(B5EN, 0x00)) {
                             Return(0x00)
                         }
                         If(Not(LEqual(\_SB.PCI0.SATA.PSS1, 0x00), )) {
                             Return(0x0f)
                         }
                         Else {
                             Return(0x00)
                         }
                     }
                     Name(S12P, 0x00)
                     Method(_PS0) {
                         GBAA()
                         If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
 l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.SMBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         Store(0x00, S12P)
                     }
                     Method(_PS3) {
                         Store(0x03, S12P)
                     }
                     Method(_PSC) {
                         Return(S12P)
                     }
                     Method(_GTF) {
                         Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
 0, 0xef }, Local0)
                         Return(Local0)
                     }
                 }
                 Device(S_D1) {
                     Name(_ADR, 0x01)
                     Method(_STA) {
                         GBAA()
                         If(LEqual(B5EN, 0x00)) {
                             Return(0x00)
                         }
                         If(Not(LEqual(\_SB.PCI0.SATA.SSS0, 0x00), )) {
                             Return(0x0f)
                         }
                         Else {
                             Return(0x00)
                         }
                     }
                     Name(S12P, 0x00)
                     Method(_PS0) {
                         GBAA()
                         If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
 l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
                             Store(0x32, Local0)
                             While(LAnd(LEqual(\_SB.PCI0.SATA.SSBY, 0x01),=
  Local0)) {
                                 Sleep(0xfa)
                                 Decrement(Local0)
                             }
                         }
                         Store(0x00, S12P)
                     }
                     Method(_PS3) {
                         Store(0x03, S12P)
                     }
                     Method(_PSC) {
                         Return(S12P)
                     }
                     Method(_GTF) {
                         Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
 0, 0xef }, Local0)
                         Return(Local0)
                     }
                 }
             }
         }
         Device(SMB) {
             Name(_ADR, 0x00140000)
             OperationRegion(Z00V, PCI_Config, 0x08, 0x0100)
             Field(Z00V, AnyAcc, NoLock, Preserve) {
                 RVID,	8,
                 Offset(0xc),
                 HPBS,	32,
                 Offset(0x5a),
                 I1F,	1,
                 I12F,	1,
                 ,	2,
                 MT3A,	1,
                 Offset(0x5c),
                 ,	10,
                 HPET,	1,
                 Offset(0xf0),
                 EIDX,	8,
                 Offset(0xf4),
                 EDAT,	32
             }
             OperationRegion(WIDE, PCI_Config, 0xad, 0x01)
             Field(WIDE, AnyAcc, NoLock, Preserve) {
                 DUM1,	4,
                 SOPT,	1
             }
             OperationRegion(SMB2, SystemIO, 0x8040, 0x06)
             Field(SMB2, ByteAcc, NoLock, Preserve) {
                 Z00W,	8,
                 Z00X,	8,
                 Z00Y,	8,
                 Z00Z,	8,
                 Z010,	8,
                 Z011,	8
             }
             OperationRegion(PMIO, SystemIO, 0x0cd6, 0x02)
             Field(PMIO, ByteAcc, NoLock, Preserve) {
                 INPM,	8,
                 DAPM,	8
             }
             IndexField(INPM, DAPM, ByteAcc, NoLock, Preserve) {
                 ,	1,
                 TM1E,	1,
                 TM2E,	1,
                 Offset(0x1),
                 ,	1,
                 TM1S,	1,
                 TM2S,	1,
                 Offset(0x2),
                 ,	1,
                 IR9E,	1,
                 Offset(0x4),
                 ,	7,
                 SLPS,	1,
                 ,	1,
                 IR9S,	1,
                 Offset(0x7),
                 ,	7,
                 CLPS,	1,
                 Offset(0xd),
                 EV0S,	1,
                 EV1S,	1,
                 Offset(0x10),
                 ,	6,
                 PWDE,	1,
                 Offset(0x1c),
                 ,	3,
                 MKME,	1,
                 PI3E,	1,
                 PI2E,	1,
                 PI1E,	1,
                 PI0E,	1,
                 ,	3,
                 MKMS,	1,
                 PI3S,	1,
                 PI2S,	1,
                 PI1S,	1,
                 PI0S,	1,
                 Offset(0x20),
                 P1EB,	16,
                 Offset(0x36),
                 ,	5,
                 GE5C,	1,
                 GE6C,	1,
                 Offset(0x37),
                 EV0C,	1,
                 EV1C,	1,
                 ,	2,
                 GM1C,	1,
                 GM2C,	1,
                 GM3C,	1,
                 Offset(0x38),
                 ,	1,
                 GM4C,	1,
                 GM5C,	1,
                 ,	1,
                 GM6C,	1,
                 Offset(0x3a),
                 ,	4,
                 GM1S,	1,
                 GM2S,	1,
                 GM3S,	1,
                 Offset(0x3b),
                 ,	1,
                 GM4S,	1,
                 GM5S,	1,
                 ,	1,
                 GM6S,	1,
                 Offset(0x55),
                 SPRE,	1,
                 ,	1,
                 ,	1,
                 EPNM,	1,
                 DPPF,	1,
                 FNGS,	1,
                 ,	1,
                 HIHP,	1,
                 Offset(0x61),
                 ,	7,
                 R617,	1,
                 Offset(0x65),
                 ,	4,
                 RSTU,	1,
                 Offset(0x68),
                 ,	3,
                 TPDE,	1,
                 ,	1,
                 Offset(0x7c),
                 ,	2,
                 BLNK,	2,
                 Offset(0x92),
                 ,	5,
                 GE5S,	1,
                 GE6S,	1,
                 GV7S,	1,
                 Offset(0x94),
                 GP8O,	1,
                 GP9O,	1,
                 GP8E,	1,
                 GP9E,	1,
                 GP8I,	1,
                 GP9I,	1,
                 GP8L,	1,
                 GP9L,	1,
                 Offset(0x9a),
                 ,	7,
                 HECO,	1,
                 Offset(0xa8),
                 PI4E,	1,
                 PI5E,	1,
                 PI6E,	1,
                 PI7E,	1,
                 Offset(0xa9),
                 PI4S,	1,
                 PI5S,	1,
                 PI6S,	1,
                 PI7S,	1
             }
             OperationRegion(P1E0, SystemIO, P1EB, 0x04)
             Field(P1E0, ByteAcc, NoLock, Preserve) {
                 ,	14,
                 PEWS,	1,
                 WSTA,	1,
                 ,	14,
                 PEWD,	1
             }
             OperationRegion(GPIO, PCI_Config, 0x00, 0x0100)
             Field(GPIO, AnyAcc, NoLock, Preserve) {
                 Offset(0x50),
                 G49O,	1,
                 G50O,	1,
                 G51O,	1,
                 G52O,	1,
                 G49E,	1,
                 G50E,	1,
                 G51E,	1,
                 G52E,	1,
                 Offset(0x52),
                 G53O,	1,
                 G54O,	1,
                 G55O,	1,
                 G56O,	1,
                 G53E,	1,
                 G54E,	1,
                 G55E,	1,
                 G56E,	1,
                 Offset(0x56),
                 ,	3,
                 G64O,	1,
                 ,	3,
                 G64E,	1,
                 Offset(0x5a),
                 G70O,	1,
                 G71O,	1,
                 G72O,	1,
                 G73O,	1,
                 G70E,	1,
                 G71E,	1,
                 G72E,	1,
                 G73E,	1,
                 G70S,	1,
                 G71S,	1,
                 G72S,	1,
                 G73S,	1,
                 G70F,	1,
                 G71F,	1,
                 G72F,	1,
                 G73F,	1,
                 Offset(0x7e),
                 ,	1,
                 G66O,	1,
                 ,	3,
                 G66E,	1,
                 Offset(0x7f),
                 ,	1,
                 G66S,	1,
                 Offset(0x80),
                 ,	3,
                 G03O,	1,
                 ,	3,
                 G03E,	1,
                 ,	3,
                 G03S,	1,
                 Offset(0x82),
                 G13O,	1,
                 ,	3,
                 G13E,	1,
                 Offset(0xa6),
                 ,	3,
                 G48O,	1,
                 ,	3,
                 G48E,	1,
                 Offset(0xa8),
                 ,	1,
                 G05O,	1,
                 ,	1,
                 G07O,	1,
                 G08O,	1,
                 G09O,	1,
                 Offset(0xa9),
                 ,	1,
                 G05E,	1,
                 ,	1,
                 G07E,	1,
                 G08E,	1,
                 G09E,	1,
                 Offset(0xaa),
                 ,	3,
                 G07S,	1,
                 Offset(0xbc),
                 G33O,	1,
                 G34O,	1,
                 G35O,	1,
                 G36O,	1,
                 G33E,	1,
                 G34E,	1,
                 G35E,	1,
                 G36E,	1,
                 G33S,	1,
                 G34S,	1,
                 G35S,	1,
                 G36S,	1,
                 G33F,	1,
                 G34F,	1,
                 G35F,	1,
                 G36F,	1
             }
             Method(TRMD) {
                 Store(Zero, SPRE)
                 Store(Zero, TPDE)
             }
             Method(HTCD) {
                 Store(Zero, PI2E)
                 Store(Zero, TM2E)
                 Store(PI2S, PI2S)
                 Store(TM2S, TM2S)
             }
         }
         Device(IDE) {
             Name(_ADR, 0x00140001)
             Name(UDMT, Package(0x08) {
                 0x78,
                 0x5a,
                 0x3c,
                 0x2d,
                 0x1e,
                 0x14,
                 0x0f,
                 0x00,
             })
             Name(PIOT, Package(0x06) {
                 0x0258,
                 0x0186,
                 0x010e,
                 0xb4,
                 0x78,
                 0x00,
             })
             Name(PITR, Package(0x06) {
                 0x99,
                 0x47,
                 0x34,
                 0x22,
                 0x20,
                 0x99,
             })
             Name(MDMT, Package(0x04) {
                 0x01e0,
                 0x96,
                 0x78,
                 0x00,
             })
             Name(MDTR, Package(0x04) {
                 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(ATPI, 1) {
                 Store(Arg0, Local0)
                 And(Local0, 0xff, Local0)
                 Or(Local0, 0x41544900, Local0)
                 Store(Local0, \_SB.PCI0.LPC0.INFO)
             }
             Method(GETT, 1) {
                 Store(And(Arg0, 0x0f, ), Local0)
                 Store(ShiftRight(Arg0, 0x04, ), Local1)
                 Return(Multiply(0x1e, Add(Add(Local0, 0x01, ), Add(Local1=
 , 0x01, ), ), ))
             }
             Method(GTM, 1) {
                 CreateByteField(Arg0, 0x00, PIT1)
                 CreateByteField(Arg0, 0x01, PIT0)
                 CreateByteField(Arg0, 0x02, MDT1)
                 CreateByteField(Arg0, 0x03, MDT0)
                 CreateByteField(Arg0, 0x04, PICX)
                 CreateByteField(Arg0, 0x05, UDCX)
                 CreateByteField(Arg0, 0x06, UDMX)
                 Name(BUF, Buffer(0x14) {0xff, 0xff, 0xff, 0xff, 0xff, 0xf=
 f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, =
 0x0, 0x0 })
                 CreateDWordField(BUF, 0x00, PIO0)
                 CreateDWordField(BUF, 0x04, DMA0)
                 CreateDWordField(BUF, 0x08, PIO1)
                 CreateDWordField(BUF, 0x0c, DMA1)
                 CreateDWordField(BUF, 0x10, FLAG)
                 If(And(PICX, 0x01, )) {
                     Return(BUF)
                 }
                 Store(GETT(PIT0), PIO0)
                 Store(GETT(PIT1), PIO1)
                 If(And(UDCX, 0x01, )) {
                     Or(FLAG, 0x01, FLAG)
                     Store(DerefOf(Index(^UDMT, And(UDMX, 0x0f, ), )), DMA=
 0)
                 }
                 Else {
                     Store(GETT(MDT0), DMA0)
                 }
                 If(And(UDCX, 0x02, )) {
                     Or(FLAG, 0x04, FLAG)
                     Store(DerefOf(Index(^UDMT, ShiftRight(UDMX, 0x04, ), =
 )), DMA1)
                 }
                 Else {
                     Store(GETT(MDT1), DMA1)
                 }
                 Or(FLAG, 0x1a, FLAG)
                 Return(BUF)
             }
             Method(STM, 3) {
                 CreateDWordField(Arg0, 0x00, PIO0)
                 CreateDWordField(Arg0, 0x04, DMA0)
                 CreateDWordField(Arg0, 0x08, PIO1)
                 CreateDWordField(Arg0, 0x0c, DMA1)
                 CreateDWordField(Arg0, 0x10, FLAG)
                 Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0=
 x0 })
                 CreateByteField(BUF, 0x00, PIT1)
                 CreateByteField(BUF, 0x01, PIT0)
                 CreateByteField(BUF, 0x02, MDT1)
                 CreateByteField(BUF, 0x03, MDT0)
                 CreateByteField(BUF, 0x04, PIMX)
                 CreateByteField(BUF, 0x05, UDCX)
                 CreateByteField(BUF, 0x06, UDMX)
                 Store(Match(^PIOT, MLE, PIO0, MTR, 0x00, 0x00), Local0)
                 Divide(Local0, 0x05, Local0, )
                 Store(Match(^PIOT, MLE, PIO1, MTR, 0x00, 0x00), Local1)
                 Divide(Local1, 0x05, Local1, )
                 Store(Or(ShiftLeft(Local1, 0x04, ), Local0, ), PIMX)
                 Store(DerefOf(Index(^PITR, Local0, )), PIT0)
                 Store(DerefOf(Index(^PITR, Local1, )), PIT1)
                 If(And(FLAG, 0x01, )) {
                     Store(Match(^UDMT, MLE, DMA0, MTR, 0x00, 0x00), Local=
 0)
                     Divide(Local0, 0x07, Local0, )
                     Or(UDMX, Local0, UDMX)
                     Or(UDCX, 0x01, UDCX)
                 }
                 Else {
                     If(LNot(LEqual(DMA0, 0xffffffff))) {
                         Store(Match(^MDMT, MLE, DMA0, MTR, 0x00, 0x00), L=
 ocal0)
                         Store(DerefOf(Index(^MDTR, Local0, )), MDT0)
                     }
                 }
                 If(And(FLAG, 0x04, )) {
                     Store(Match(^UDMT, MLE, DMA1, MTR, 0x00, 0x00), Local=
 0)
                     Divide(Local0, 0x07, Local0, )
                     Or(UDMX, ShiftLeft(Local0, 0x04, ), UDMX)
                     Or(UDCX, 0x02, UDCX)
                 }
                 Else {
                     If(LNot(LEqual(DMA1, 0xffffffff))) {
                         Store(Match(^MDMT, MLE, DMA1, MTR, 0x00, 0x00), L=
 ocal0)
                         Store(DerefOf(Index(^MDTR, Local0, )), MDT1)
                     }
                 }
                 Return(BUF)
             }
             Method(GTF, 2) {
                 CreateByteField(Arg1, 0x00, MDT1)
                 CreateByteField(Arg1, 0x01, MDT0)
                 CreateByteField(Arg1, 0x02, PIMX)
                 CreateByteField(Arg1, 0x03, UDCX)
                 CreateByteField(Arg1, 0x04, UDMX)
                 If(LEqual(Arg0, 0xa0)) {
                     Store(And(PIMX, 0x0f, ), Local0)
                     Store(MDT0, Local1)
                     And(UDCX, 0x01, Local2)
                     Store(And(UDMX, 0x0f, ), Local3)
                 }
                 Else {
                     Store(ShiftRight(PIMX, 0x04, ), Local0)
                     Store(MDT1, Local1)
                     And(UDCX, 0x02, Local2)
                     Store(ShiftRight(UDMX, 0x04, ), Local3)
                 }
                 Name(BUF, Buffer(0x15) {0x3, 0x0, 0x0, 0x0, 0x0, 0xff, 0x=
 ef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xef, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
 f5 })
                 CreateByteField(BUF, 0x01, PMOD)
                 CreateByteField(BUF, 0x08, DMOD)
                 CreateByteField(BUF, 0x05, CMDA)
                 CreateByteField(BUF, 0x0c, CMDB)
                 CreateByteField(BUF, 0x13, CMDC)
                 Store(Arg0, CMDA)
                 Store(Arg0, CMDB)
                 Store(Arg0, CMDC)
                 Or(Local0, 0x08, PMOD)
                 If(Local2) {
                     Or(Local3, 0x40, DMOD)
                 }
                 Else {
                     Store(Match(^MDMT, MLE, GETT(Local1), MTR, 0x00, 0x00=
 ), Local4)
                     If(LLess(Local4, 0x03)) {
                         Or(0x20, Local4, DMOD)
                     }
                 }
                 Return(BUF)
             }
             Device(PRID) {
                 Name(_ADR, 0x00)
                 Method(_GTM) {
                     Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x=
 0, 0x0 })
                     CreateWordField(BUF, 0x00, VPIT)
                     CreateWordField(BUF, 0x02, VMDT)
                     CreateByteField(BUF, 0x04, VPIC)
                     CreateByteField(BUF, 0x05, VUDC)
                     CreateByteField(BUF, 0x06, VUDM)
                     If(\_SB.PCI0.SMB.SOPT) {
                         Store(^^PPIT, VPIT)
                         Store(^^PMDT, VMDT)
                         Store(^^PPIC, VPIC)
                         Store(^^PUDC, VUDC)
                         Store(^^PUDM, VUDM)
                     }
                     Else {
                         Store(^^SPIT, VPIT)
                         Store(^^SMDT, VMDT)
                         Store(^^SPIC, VPIC)
                         Store(^^SUDC, VUDC)
                         Store(^^SUDM, VUDM)
                     }
                     Return(GTM(BUF))
                 }
                 Method(_STM, 3) {
                     Name(BUF, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x0 })
                     CreateWordField(BUF, 0x00, VPIT)
                     CreateWordField(BUF, 0x02, VMDT)
                     CreateByteField(BUF, 0x04, VPIM)
                     CreateByteField(BUF, 0x05, VUDC)
                     CreateByteField(BUF, 0x06, VUDM)
                     Store(STM(Arg0, Arg1, Arg2), BUF)
                     If(\_SB.PCI0.SMB.SOPT) {
                         Store(VPIT, ^^PPIT)
                         Store(VMDT, ^^PMDT)
                         Store(VPIM, ^^PPIM)
                         Store(VUDC, ^^PUDC)
                         Store(VUDM, ^^PUDM)
                     }
                     Else {
                         Store(VPIT, ^^SPIT)
                         Store(VMDT, ^^SMDT)
                         Store(VPIM, ^^SPIM)
                         Store(VUDC, ^^SUDC)
                         Store(VUDM, ^^SUDM)
                     }
                 }
                 Device(P_D0) {
                     Name(_ADR, 0x00)
                     Method(_GTF) {
                         Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
 )
                         CreateWordField(BUF, 0x00, VMDT)
                         CreateByteField(BUF, 0x02, VPIM)
                         CreateByteField(BUF, 0x03, VUDC)
                         CreateByteField(BUF, 0x04, VUDM)
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(^^^PMDT, VMDT)
                             Store(^^^PPIM, VPIM)
                             Store(^^^PUDC, VUDC)
                             Store(^^^PUDM, VUDM)
                         }
                         Else {
                             Store(^^^SMDT, VMDT)
                             Store(^^^SPIM, VPIM)
                             Store(^^^SUDC, VUDC)
                             Store(^^^SUDM, VUDM)
                         }
                         Return(GTF(0xa0, BUF))
                     }
                 }
                 Device(P_D1) {
                     Name(_ADR, 0x01)
                     Method(_GTF) {
                         Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
 )
                         CreateWordField(BUF, 0x00, VMDT)
                         CreateByteField(BUF, 0x02, VPIM)
                         CreateByteField(BUF, 0x03, VUDC)
                         CreateByteField(BUF, 0x04, VUDM)
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(^^^PMDT, VMDT)
                             Store(^^^PPIM, VPIM)
                             Store(^^^PUDC, VUDC)
                             Store(^^^PUDM, VUDM)
                         }
                         Else {
                             Store(^^^SMDT, VMDT)
                             Store(^^^SPIM, VPIM)
                             Store(^^^SUDC, VUDC)
                             Store(^^^SUDM, VUDM)
                         }
                         Return(GTF(0xb0, BUF))
                     }
                 }
                 Method(_STA) {
                     And(PPIC, 0x01, Local0)
                     If(LAnd(Local0, 0x01)) {
                         Return(Z008)
                     }
                     Else {
                         Return(Z005)
                     }
                 }
             }
             Device(SECD) {
                 Name(_ADR, 0x01)
                 Method(_GTM) {
                     Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x=
 0, 0x0 })
                     CreateWordField(BUF, 0x00, VPIT)
                     CreateWordField(BUF, 0x02, VMDT)
                     CreateByteField(BUF, 0x04, VPIC)
                     CreateByteField(BUF, 0x05, VUDC)
                     CreateByteField(BUF, 0x06, VUDM)
                     If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(^^PPIT, VPIT)
                             Store(^^PMDT, VMDT)
                             Store(^^PPIC, VPIC)
                             Store(^^PUDC, VUDC)
                             Store(^^PUDM, VUDM)
                         }
                         Else {
                             Store(^^SPIT, VPIT)
                             Store(^^SMDT, VMDT)
                             Store(^^SPIC, VPIC)
                             Store(^^SUDC, VUDC)
                             Store(^^SUDM, VUDM)
                         }
                     }
                     Else {
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(^^SPIT, VPIT)
                             Store(^^SMDT, VMDT)
                             Store(^^SPIC, VPIC)
                             Store(^^SUDC, VUDC)
                             Store(^^SUDM, VUDM)
                         }
                         Else {
                             Store(^^PPIT, VPIT)
                             Store(^^PMDT, VMDT)
                             Store(^^PPIC, VPIC)
                             Store(^^PUDC, VUDC)
                             Store(^^PUDM, VUDM)
                         }
                     }
                     Return(GTM(BUF))
                 }
                 Method(_STM, 3) {
                     Name(BUF, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
  0x0 })
                     CreateWordField(BUF, 0x00, VPIT)
                     CreateWordField(BUF, 0x02, VMDT)
                     CreateByteField(BUF, 0x04, VPIM)
                     CreateByteField(BUF, 0x05, VUDC)
                     CreateByteField(BUF, 0x06, VUDM)
                     Store(STM(Arg0, Arg1, Arg2), BUF)
                     If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(VPIT, ^^PPIT)
                             Store(VMDT, ^^PMDT)
                             Store(VPIM, ^^PPIM)
                             Store(VUDC, ^^PUDC)
                             Store(VUDM, ^^PUDM)
                         }
                         Else {
                             Store(VPIT, ^^SPIT)
                             Store(VMDT, ^^SMDT)
                             Store(VPIM, ^^SPIM)
                             Store(VUDC, ^^SUDC)
                             Store(VUDM, ^^SUDM)
                         }
                     }
                     Else {
                         If(\_SB.PCI0.SMB.SOPT) {
                             Store(VPIT, ^^SPIT)
                             Store(VMDT, ^^SMDT)
                             Store(VPIM, ^^SPIM)
                             Store(VUDC, ^^SUDC)
                             Store(VUDM, ^^SUDM)
                         }
                         Else {
                             Store(VPIT, ^^PPIT)
                             Store(VMDT, ^^PMDT)
                             Store(VPIM, ^^PPIM)
                             Store(VUDC, ^^PUDC)
                             Store(VUDM, ^^PUDM)
                         }
                     }
                 }
                 Device(S_D0) {
                     Name(_ADR, 0x00)
                     Method(_GTF) {
                         Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
 )
                         CreateWordField(BUF, 0x00, VMDT)
                         CreateByteField(BUF, 0x02, VPIM)
                         CreateByteField(BUF, 0x03, VUDC)
                         CreateByteField(BUF, 0x04, VUDM)
                         If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
                             If(\_SB.PCI0.SMB.SOPT) {
                                 Store(^^^PMDT, VMDT)
                                 Store(^^^PPIM, VPIM)
                                 Store(^^^PUDC, VUDC)
                                 Store(^^^PUDM, VUDM)
                             }
                             Else {
                                 Store(^^^SMDT, VMDT)
                                 Store(^^^SPIM, VPIM)
                                 Store(^^^SUDC, VUDC)
                                 Store(^^^SUDM, VUDM)
                             }
                         }
                         Else {
                             If(\_SB.PCI0.SMB.SOPT) {
                                 Store(^^^SMDT, VMDT)
                                 Store(^^^SPIM, VPIM)
                                 Store(^^^SUDC, VUDC)
                                 Store(^^^SUDM, VUDM)
                             }
                             Else {
                                 Store(^^^PMDT, VMDT)
                                 Store(^^^PPIM, VPIM)
                                 Store(^^^PUDC, VUDC)
                                 Store(^^^PUDM, VUDM)
                             }
                         }
                         Return(GTF(0xa0, BUF))
                     }
                 }
                 Device(S_D1) {
                     Name(_ADR, 0x01)
                     Method(_GTF) {
                         Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
 )
                         CreateWordField(BUF, 0x00, VMDT)
                         CreateByteField(BUF, 0x02, VPIM)
                         CreateByteField(BUF, 0x03, VUDC)
                         CreateByteField(BUF, 0x04, VUDM)
                         If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
                             If(\_SB.PCI0.SMB.SOPT) {
                                 Store(^^^PMDT, VMDT)
                                 Store(^^^PPIM, VPIM)
                                 Store(^^^PUDC, VUDC)
                                 Store(^^^PUDM, VUDM)
                             }
                             Else {
                                 Store(^^^SMDT, VMDT)
                                 Store(^^^SPIM, VPIM)
                                 Store(^^^SUDC, VUDC)
                                 Store(^^^SUDM, VUDM)
                             }
                         }
                         Else {
                             If(\_SB.PCI0.SMB.SOPT) {
                                 Store(^^^SMDT, VMDT)
                                 Store(^^^SPIM, VPIM)
                                 Store(^^^SUDC, VUDC)
                                 Store(^^^SUDM, VUDM)
                             }
                             Else {
                                 Store(^^^PMDT, VMDT)
                                 Store(^^^PPIM, VPIM)
                                 Store(^^^PUDC, VUDC)
                                 Store(^^^PUDM, VUDM)
                             }
                         }
                         Return(GTF(0xb0, BUF))
                     }
                 }
                 Method(_STA) {
                     And(SPIC, 0x01, Local0)
                     If(LAnd(Local0, 0x01)) {
                         Return(Z008)
                     }
                     Else {
                         Return(Z005)
                     }
                 }
             }
         }
         Device(HDA) {
             Name(_ADR, 0x00140002)
             Name(_PRW, Package(0x02) {
                 0x1b,
                 0x03,
             })
         }
         Device(LPC0) {
             Name(_ADR, 0x00140003)
             Mutex(PSMX, 0)
             OperationRegion(PIRQ, SystemIO, 0x0c00, 0x02)
             Field(PIRQ, ByteAcc, NoLock, Preserve) {
                 PIID,	8,
                 PIDA,	8
             }
             IndexField(PIID, PIDA, ByteAcc, NoLock, Preserve) {
                 PIRA,	8,
                 PIRB,	8,
                 PIRC,	8,
                 PIRD,	8,
                 PIRS,	8,
                 Offset(0x9),
                 PIRE,	8,
                 PIRF,	8,
                 PIRG,	8,
                 PIRH,	8
             }
             Name(IPRS, Buffer(0x06) {0x23, 0x0, 0xc, 0x18, 0x79, 0x0 })
             Name(UPRS, Buffer(0x06) {0x23, 0xb8, 0x0, 0x8, 0x79, 0x0 })
             Method(DSPI) {
                 Store(0x00, PIRA)
                 Store(0x00, PIRB)
                 Store(0x00, PIRC)
                 Store(0x00, PIRD)
                 Store(0x00, PIRE)
                 Store(0x00, PIRF)
                 Store(0x00, PIRG)
                 Store(0x00, PIRH)
             }
             Device(LNKA) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x01)
                 Method(_STA) {
                     If(PIRA) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRA)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRA, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRA)
                 }
             }
             Device(LNKB) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x02)
                 Method(_STA) {
                     If(PIRB) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRB)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRB, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRB)
                 }
             }
             Device(LNKC) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x03)
                 Method(_STA) {
                     If(PIRC) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRC)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRC, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRC)
                 }
             }
             Device(LNKD) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x04)
                 Method(_STA) {
                     If(PIRD) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRD)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRD, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRD)
                 }
             }
             Device(LNKE) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x05)
                 Method(_STA) {
                     If(PIRE) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRE)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRE, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRE)
                 }
             }
             Device(LNKF) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x06)
                 Method(_STA) {
                     If(PIRF) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRF)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRF, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRF)
                 }
             }
             Device(LNKG) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x07)
                 Method(_STA) {
                     If(PIRG) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRG)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRG, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRG)
                 }
             }
             Device(LNKH) {
                 Name(_HID, 0x0f0cd041)
                 Name(_UID, 0x08)
                 Method(_STA) {
                     If(PIRH) {
                         Return(Z007)
                     }
                     Else {
                         Return(Z008)
                     }
                 }
                 Method(_PRS) {
                     Return(IPRS)
                 }
                 Method(_DIS) {
                     Store(0x00, PIRH)
                 }
                 Method(_CRS) {
                     Store(IPRS, Local0)
                     CreateWordField(Local0, 0x01, IRQ0)
                     ShiftLeft(0x01, PIRH, IRQ0)
                     Return(Local0)
                 }
                 Method(_SRS, 1) {
                     CreateWordField(Arg0, 0x01, IRQ0)
                     FindSetRightBit(IRQ0, Local0)
                     Decrement(Local0)
                     Store(Local0, PIRH)
                 }
             }
             OperationRegion(LCLM, SystemIO, 0x0c50, 0x03)
             Field(LCLM, ByteAcc, NoLock, Preserve) {
                 CLMI,	8,
                 CLMD,	8,
                 CLGP,	8
             }
             OperationRegion(ECTH, SystemIO, 0x68, 0x06)
             Field(ECTH, ByteAcc, NoLock, Preserve) {
                 ECPI,	8,
                 Offset(0x2),
                 Offset(0x3),
                 Offset(0x4),
                 ECPD,	8
             }
             IndexField(CLMI, CLMD, ByteAcc, NoLock, Preserve) {
                 IDRG,	8,
                 Offset(0x2),
                 TSTS,	8,
                 TINT,	8,
                 Offset(0x12),
                 I2CC,	8,
                 GPIO,	8
             }
             Method(RGPM) {
                 Store(\_SB.PCI0.LPC0.GPIO, Local0)
                 And(Local0, Not(0xc0, ), Local0)
                 Store(Local0, \_SB.PCI0.LPC0.GPIO)
                 Store(\_SB.PCI0.LPC0.CLGP, Local1)
                 Return(Local1)
             }
             OperationRegion(LPCR, PCI_Config, 0x00, 0x7f)
             Field(LPCR, ByteAcc, NoLock, Preserve) {
                 Offset(0x44),
                 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,
                 Offset(0x48),
                 ,	2,
                 ENW0,	1,
                 Offset(0x4a),
                 IOP0,	1,
                 IOP1,	1,
                 IOP2,	1,
                 IOP3,	1,
                 Offset(0x4b),
                 ENW1,	1,
                 Offset(0x64),
                 IOB1,	16,
                 IOB2,	16,
                 Offset(0x74),
                 AWR0,	1,
                 ,	1,
                 AWR1,	1
             }
             Device(DMAC) {
                 Name(_HID, 0x0002d041)
                 Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
 x1, 0x20, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x10, 0x47, 0x1, 0xc0, 0x=
 0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
             }
             Device(MATH) {
                 Name(_HID, 0x040cd041)
                 Name(_CRS, Buffer(0x0e) {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(0x0e) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0,=
  0x1, 0x2, 0x23, 0x0, 0x1, 0x1, 0x79, 0x0 })
             }
             Device(SPKR) {
                 Name(_HID, 0x0008d041)
                 Name(_CRS, Buffer(0x0a) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0,=
  0x1, 0x1, 0x79, 0x0 })
             }
             Device(TIME) {
                 Name(_HID, 0x0001d041)
                 Name(_CRS, Buffer(0x0e) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0,=
  0x1, 0x4, 0x23, 0x1, 0x0, 0x1, 0x79, 0x0 })
             }
             Device(KBC0) {
                 Name(_HID, 0x0303d041)
                 Method(_STA) {
                     If(LEqual(OSYS, 0x40)) {
                         If(LEqual(KBTP, 0x4a)) {
                             Return(0x00)
                         }
                         Else {
                             Return(0x0f)
                         }
                     }
                     Else {
                         Return(0x0f)
                     }
                 }
                 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(KBCJ) {
                 Name(_HID, 0x2003d041)
                 Method(_STA) {
                     If(LEqual(OSYS, 0x40)) {
                         If(LEqual(KBTP, 0x4a)) {
                             Return(0x0f)
                         }
                         Else {
                             Return(0x00)
                         }
                     }
                     Else {
                         Return(0x00)
                     }
                 }
                 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(0x06) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 =
 })
                 Method(_STA) {
                     If(LOr(LEqual(PTYP, 0x02), LEqual(PTYP, 0x04))) {
                         Return(0x0f)
                     }
                     Else {
                         If(LEqual(PTYP, 0x01)) {
                             Return(0x00)
                         }
                         Else {
                             Return(0x0f)
                         }
                     }
                 }
                 Method(_PSW, 1) {
                 }
             }
             Device(MSS0) {
                 Name(_HID, 0x171b2e4f)
                 Name(_CID, Package(0x03) {
                     0x00072e4f,
                     0x02002e4f,
                     0x130fd041,
                 })
                 Method(_STA) {
                     If(LEqual(PTYP, 0x01)) {
                         Return(0x0f)
                     }
                     Else {
                         Return(0x00)
                     }
                 }
                 Name(_CRS, Buffer(0x06) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 =
 })
                 Method(_PSW, 1) {
                 }
             }
             Device(SYSR) {
                 Name(_HID, 0x020cd041)
                 Method(_STA) {
                     If(PJID) {
                         Return(0x00)
                     }
                     Else {
                         Return(0x0f)
                     }
                 }
                 Name(_CRS, Buffer(0xfa) {0x47, 0x1, 0x22, 0x0, 0x22, 0x0,=
  0x1, 0x2, 0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x68, 0x=
 0, 0x68, 0x0, 0x1, 0x1, 0x47, 0x1, 0x6c, 0x0, 0x6c, 0x0, 0x1, 0x1, 0x47, =
 0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x2, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1=
 , 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb8, 0x0, 0=
 xb8, 0x0, 0x1, 0x1, 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, 0=
 x1, 0x1, 0x47, 0x1, 0x6f, 0xc, 0x6f, 0xc, 0x1, 0x1, 0x47, 0x1, 0xd0, 0xc,=
  0xd0, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd2, 0xc, 0xd2, 0xc, 0x1, 0x2, 0x47, 0x=
 1, 0xd4, 0xc, 0xd4, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd6, 0xc, 0xd6, 0xc, 0x1, =
 0x2, 0x47, 0x1, 0xd8, 0xc, 0xd8, 0xc, 0x1, 0x8, 0x47, 0x1, 0x0, 0x80, 0x0=
 , 0x80, 0x1, 0x60, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x81, 0x=
 ff, 0x81, 0x0, 0x0, 0x0, 0x1, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x=
 0, 0x82, 0xff, 0x82, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0x40, 0xf, 0x40, 0xf,=
  0x1, 0x8, 0x47, 0x1, 0x7f, 0x8, 0x7f, 0x8, 0x1, 0x1, 0x79, 0x0 })
             }
             Device(SYSC) {
                 Name(_HID, 0x020cd041)
                 Method(_STA) {
                     If(PJID) {
                         Return(0x0f)
                     }
                     Else {
                         Return(0x00)
                     }
                 }
                 Name(_CRS, Buffer(0x0102) {0x47, 0x1, 0x22, 0x0, 0x22, 0x=
 0, 0x1, 0x2, 0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x68, =
 0x0, 0x68, 0x0, 0x1, 0x1, 0x47, 0x1, 0x6c, 0x0, 0x6c, 0x0, 0x1, 0x1, 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, 0xb8, 0x=
 0, 0xb8, 0x0, 0x1, 0x1, 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, 0x=
 d6, 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, 0x=
 c, 0x1, 0x1, 0x47, 0x1, 0x6f, 0xc, 0x6f, 0xc, 0x1, 0x1, 0x47, 0x1, 0xd0, =
 0xc, 0xd0, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd2, 0xc, 0xd2, 0xc, 0x1, 0x2, 0x47=
 , 0x1, 0xd4, 0xc, 0xd4, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd6, 0xc, 0xd6, 0xc, 0=
 x1, 0x2, 0x47, 0x1, 0xd8, 0xc, 0xd8, 0xc, 0x1, 0x8, 0x47, 0x1, 0x0, 0x80,=
  0x0, 0x80, 0x1, 0x60, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x81=
 , 0xff, 0x81, 0x0, 0x0, 0x0, 0x1, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0=
 , 0x0, 0x82, 0xff, 0x82, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0x40, 0xf, 0x40, =
 0xf, 0x1, 0x8, 0x47, 0x1, 0x7f, 0x8, 0x7f, 0x8, 0x1, 0x1, 0x47, 0x1, 0x60=
 , 0xfd, 0x60, 0xfd, 0x1, 0x4, 0x79, 0x0 })
             }
             Device(MEM) {
                 Name(_HID, 0x010cd041)
                 Name(MSRC, Buffer(0x26) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0=
 xe, 0x0, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xff, 0=
 x0, 0x0, 0x10, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
 0, 0x0, 0x79, 0x0 })
                 Method(_CRS) {
                     CreateDWordField(MSRC, 0x1c, BARX)
                     CreateDWordField(MSRC, 0x20, GALN)
                     Store(\_SB.PCI0.Z00U, Local0)
                     If(Local0) {
                         Store(0x1000, GALN)
                         And(Local0, 0xfffffff0, BARX)
                     }
                     Return(MSRC)
                 }
                 Method(_STA) {
                     Return(0x0f)
                 }
             }
             OperationRegion(SMI0, SystemIO, 0x00000f40, 0x00000002)
             Field(SMI0, AnyAcc, NoLock, Preserve) {
                 SMIC,	8
             }
             OperationRegion(SMI1, SystemMemory, 0xafeddcdc, 0x00000120)
             Field(SMI1, AnyAcc, NoLock, Preserve) {
                 BCMD,	8,
                 DID,	32,
                 INFO,	1024
             }
             Field(SMI1, AnyAcc, NoLock, Preserve) {
                 AccessAs(ByteAcc, 0),
                 Offset(0x5),
                 INF,	8,
                 INF1,	32
             }
             Method(PHSS, 1) {
                 Acquire(PSMX, 0xffff)
                 Store(0xa0, BCMD)
                 Store(Arg0, DID)
                 Store(Zero, SMIC)
                 Release(PSMX)
             }
             Device(HPET) {
                 Name(_HID, 0x0301d041)
                 Name(CRS, Buffer(0x0e) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x=
 d0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0 })
                 Method(_STA) {
                     If(LEqual(\_SB.PCI0.SMB.HPET, One)) {
                         Return(0x0f)
                     }
                     Else {
                         Return(0x00)
                     }
                 }
                 Mutex(HPSM, 0)
                 Method(_CRS) {
                     CreateDWordField(CRS, 0x04, HPT)
                     Acquire(HPSM, 0xffff)
                     Store(\_SB.PCI0.SMB.HIHP, Local0)
                     Store(Zero, \_SB.PCI0.SMB.HIHP)
                     If(LNot(LEqual(\_SB.PCI0.SMB.HPBS, 0x00))) {
                         Store(\_SB.PCI0.SMB.HPBS, HPT)
                     }
                     Store(Local0, \_SB.PCI0.SMB.HIHP)
                     Release(HPSM)
                     And(HPT, 0xffffffc0, HPT)
                     Return(CRS)
                 }
             }
             Method(ECOK) {
                 If(LEqual(\_SB.PCI0.LPC0.EC0.Z012, 0x01)) {
                     If(LEqual(OSYS, 0x40)) {
                         Store(0x01, \_SB.PCI0.LPC0.EC0.OSIF)
                     }
                     Else {
                         Store(0x00, \_SB.PCI0.LPC0.EC0.OSIF)
                     }
                     Return(0x01)
                 }
                 Else {
                     Return(0x00)
                 }
             }
             Device(EC0) {
                 Name(_HID, 0x090cd041)
                 Name(_GPE, 0x03)
                 Name(Z012, Zero)
                 Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,=
  0x1, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
                 Method(_REG, 2) {
                     If(LEqual(Arg0, 0x03)) {
                         Store(Arg1, Z012)
                     }
                 }
                 OperationRegion(ERAM, EmbeddedControl, 0x00, 0xff)
                 Field(ERAM, ByteAcc, Lock, Preserve) {
                     Offset(0x8),
                     BATM,	16,
                     Offset(0x19),
                     BATD,	56,
                     Offset(0x60),
                     SMPR,	8,
                     SMST,	8,
                     SMAD,	8,
                     SMCM,	8,
                     SMDR,	32,
                     BCNT,	8,
                     SMAA,	8,
                     SMD0,	8,
                     SMD1,	8,
                     Offset(0x90),
                     Offset(0x91),
                     Offset(0x92),
                     Offset(0x93),
                     Offset(0x94),
                     ERIB,	16,
                     ERBD,	8,
                     Offset(0x98),
                     Offset(0x99),
                     OSIF,	1,
                     Offset(0x9a),
                     BAL1,	1,
                     BAL2,	1,
                     BAL3,	1,
                     BAL4,	1,
                     BCL1,	1,
                     BCL2,	1,
                     BCL3,	1,
                     BCL4,	1,
                     BPU1,	1,
                     BPU2,	1,
                     BPU3,	1,
                     BPU4,	1,
                     BOS1,	1,
                     BOS2,	1,
                     BOS3,	1,
                     BOS4,	1,
                     PHDD,	1,
                     IFDD,	1,
                     IODD,	1,
                     SHDD,	1,
                     LS20,	1,
                     EFDD,	1,
                     ECRT,	1,
                     LANC,	1,
                     SBTN,	1,
                     VIDO,	1,
                     VOLD,	1,
                     VOLU,	1,
                     MUTE,	1,
                     CONT,	1,
                     BRGT,	1,
                     HBTN,	1,
                     S4SE,	1,
                     SKEY,	1,
                     BKEY,	1,
                     TKEY,	1,
                     FKEY,	1,
                     DVDM,	1,
                     DIGM,	1,
                     CDLK,	1,
                     ,	1,
                     LIDO,	1,
                     PMEE,	1,
                     PBET,	1,
                     RIIN,	1,
                     BTWK,	1,
                     DKIN,	1,
                     Offset(0xa0),
                     ,	6,
                     SWTH,	1,
                     HWTH,	1,
                     DKT0,	1,
                     DKT1,	1,
                     ,	2,
                     OSUD,	1,
                     OSDK,	1,
                     OSSU,	1,
                     DKCG,	1,
                     ODTS,	8,
                     S1LD,	1,
                     S3LD,	1,
                     VGAQ,	1,
                     PCMQ,	1,
                     PCMR,	1,
                     ADPT,	1,
                     SYS6,	1,
                     SYS7,	1,
                     PWAK,	1,
                     MWAK,	1,
                     LWAK,	1,
                     RWAK,	1,
                     ,	2,
                     KWAK,	1,
                     MSWK,	1,
                     CCAC,	1,
                     AOAC,	1,
                     BLAC,	1,
                     PSRC,	1,
                     BOAC,	1,
                     LCAC,	1,
                     AAAC,	1,
                     ACAC,	1,
                     PCEC,	8,
                     THON,	8,
                     THSD,	8,
                     Offset(0xaa),
                     TCON,	8,
                     THRS,	8,
                     THSE,	8,
                     FSSN,	4,
                     FANU,	4,
                     PTVL,	3,
                     ,	3,
                     TTSR,	1,
                     TTHR,	1,
                     TSTH,	1,
                     TSBC,	1,
                     TSBF,	1,
                     TSPL,	1,
                     TSBT,	1,
                     ,	2,
                     THTA,	1,
                     CTMP,	8,
                     LTMP,	8,
                     SKTA,	8,
                     SKTB,	8,
                     SKTC,	8,
                     SKTD,	8,
                     NBTP,	8,
                     LANP,	1,
                     LCDS,	1,
                     Offset(0xb8),
                     BTPV,	8,
                     BRTS,	8,
                     CTRS,	8,
                     WLAT,	1,
                     BTAT,	1,
                     WLEX,	1,
                     BTEX,	1,
                     KLSW,	1,
                     WLOK,	1,
                     Offset(0xbc),
                     PJID,	8,
                     CPUN,	8,
                     THFN,	8,
                     MLED,	1,
                     SCHG,	1,
                     SCCF,	1,
                     SCPF,	1,
                     ACIS,	1,
                     Offset(0xc0),
                     ,	4,
                     BTMF,	3,
                     BTY0,	1,
                     BST0,	8,
                     BRC0,	16,
                     BSN0,	16,
                     BPV0,	16,
                     BDV0,	16,
                     BDC0,	16,
                     BFC0,	16,
                     GAU0,	8,
                     BSCY,	8,
                     BSCU,	16,
                     BAC0,	16,
                     BTW0,	8,
                     BATV,	8,
                     BPTC,	8,
                     BTTC,	8,
                     BTMA,	16,
                     BTSC,	8,
                     BCIX,	8,
                     CCBA,	8,
                     CBOT,	8,
                     BTSS,	16,
                     OVCC,	8,
                     CCFC,	8,
                     BADC,	8,
                     BSC1,	16,
                     BSC2,	16,
                     BSC3,	16,
                     BSC4,	16,
                     BDME,	16,
                     Offset(0xee),
                     Offset(0xef),
                     Offset(0xf0),
                     BTS1,	8,
                     BTS2,	8,
                     BSCS,	16,
                     BDAD,	16,
                     BACV,	16,
                     BDFC,	16
                 }
                 Method(PCLK) {
                     Store(PTVL, Local0)
                     Store(Local0, P80H)
                     Store(0x04, Local1)
                     If(LGreater(Local1, 0x00)) {
                         Decrement(Local1)
                     }
                     If(LNot(LGreater(Local0, Local1))) {
                         Store(Local0, \_PR.CPU0._PPC)
                         If(LEqual(CPUS, 0x00)) {
                             Store(Local0, \_PR.CPU1._PPC)
                         }
                     }
                     Else {
                         Store(Local1, \_PR.CPU0._PPC)
                         If(LEqual(CPUS, 0x00)) {
                             Store(Local1, \_PR.CPU1._PPC)
                         }
                     }
                     Notify(\_PR.CPU0, 0x80)
                     If(LEqual(CPUS, 0x00)) {
                         Notify(\_PR.CPU1, 0x80)
                     }
                 }
                 Method(_Q11) {
                     If(LEqual(OSYS, 0x40)) {
                         Store(0x87, P80H)
                         If(UMAS) {
                             Notify(\_SB.PCI0.AGP.VGA.LCD, 0x87)
                         }
                         Else {
                             Notify(\_SB.PCI0.PB2.DGFX.LCD, 0x87)
                         }
                         If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                             Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
                             Store(\_SB.WMID.LBL0, Local2)
                             Add(Local2, Local1, Local2)
                             Store(Local2, \_SB.WMID.NTDC)
                             Notify(\_SB.WMID, 0x80)
                         }
                     }
                     Else {
                         If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                             Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
                             Store(\_SB.WMID.LBL0, Local2)
                             Add(Local2, Local1, Local2)
                             Store(Local2, \_SB.WMID.NTDC)
                             Notify(\_SB.WMID, 0x80)
                         }
                     }
                 }
                 Method(_Q12) {
                     If(LEqual(OSYS, 0x40)) {
                         Store(0x86, P80H)
                         If(UMAS) {
                             Notify(\_SB.PCI0.AGP.VGA.LCD, 0x86)
                         }
                         Else {
                             Notify(\_SB.PCI0.PB2.DGFX.LCD, 0x86)
                         }
                         If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                             Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
                             Store(\_SB.WMID.LBL0, Local2)
                             Add(Local2, Local1, Local2)
                             Store(Local2, \_SB.WMID.NTDC)
                             Notify(\_SB.WMID, 0x80)
                         }
                     }
                     Else {
                         If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                             Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
                             Store(\_SB.WMID.LBL0, Local2)
                             Add(Local2, Local1, Local2)
                             Store(Local2, \_SB.WMID.NTDC)
                             Notify(\_SB.WMID, 0x80)
                         }
                     }
                 }
                 Method(_Q15) {
                     Store(0x15, P80H)
                     Notify(\_SB.LID, 0x80)
                 }
                 Method(_Q16) {
                     Store(0x16, P80H)
                     Notify(\_SB.LID, 0x80)
                 }
                 Method(_Q1D) {
                     Store(0x1d, P80H)
                     \_SB.PCI0.LPC0.EC0.PCLK()
                     Notify(\_TZ.THRM, 0x80)
                     Sleep(0x1e)
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
                 }
                 Method(_Q22) {
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
                 }
                 Method(_Q25) {
                     Store(0x25, P80H)
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x81)
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
                 }
                 Method(_Q27) {
                     Notify(\_TZ.THRM, 0x80)
                 }
                 Method(_Q2A) {
                     Store(0x1f, \_SB.PCI0.SMB.Z00W)
                     Sleep(0x32)
                     Store(0xc0, \_SB.PCI0.SMB.Z010)
                     Sleep(0x32)
                     Store(0x01, \_SB.PCI0.SMB.Z00Z)
                     Sleep(0x32)
                     Store(0x00, \_SB.PCI0.SMB.Z011)
                     Sleep(0x32)
                     Store(0x4c, \_SB.PCI0.SMB.Z00Y)
                     Sleep(0x32)
                     Store(0x1f, \_SB.PCI0.SMB.Z00W)
                     Sleep(0x32)
                 }
                 Method(_Q2B) {
                     Store(0x1f, \_SB.PCI0.SMB.Z00W)
                     Sleep(0x32)
                     Store(0xc0, \_SB.PCI0.SMB.Z010)
                     Sleep(0x32)
                     Store(0x03, \_SB.PCI0.SMB.Z00Z)
                     Sleep(0x32)
                     Store(0x01, \_SB.PCI0.SMB.Z011)
                     Sleep(0x32)
                     Store(0x4c, \_SB.PCI0.SMB.Z00Y)
                     Sleep(0x32)
                     Store(0x1f, \_SB.PCI0.SMB.Z00W)
                     Sleep(0x32)
                 }
                 Method(_Q34) {
                     If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                         Store(\_SB.PCI0.LPC0.EC0.BTAT, Local1)
                         Store(\_SB.WMID.BLTD, Local2)
                         Add(Local2, Local1, Local2)
                         Store(Local2, \_SB.WMID.NTDC)
                         Notify(\_SB.WMID, 0x80)
                     }
                 }
                 Method(_Q37) {
                     Store(0x37, P80H)
                     Notify(\_SB.PCI0.LPC0.ACAD, 0x80)
                     Sleep(0x03e8)
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
                     Notify(\_PR.CPU0, 0x80)
                     If(LEqual(CPUS, 0x00)) {
                         Notify(\_PR.CPU1, 0x80)
                     }
                 }
                 Method(_Q38) {
                     Store(0x38, P80H)
                     Notify(\_SB.PCI0.LPC0.ACAD, 0x80)
                     Sleep(0x03e8)
                     Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
                     Notify(\_PR.CPU0, 0x80)
                     If(LEqual(CPUS, 0x00)) {
                         Notify(\_PR.CPU1, 0x80)
                     }
                 }
                 Method(_Q4F) {
                     If(LEqual(\_SB.WMID.BAEF, One)) {
                         Store(0x01, Local1)
                         If(LEqual(\_SB.PCI0.LPC0.EC0.LANC, 0x01)) {
                             Store(0x00, Local1)
                         }
                         Store(\_SB.WMID.LANI, Local2)
                         Add(Local2, Local1, Local2)
                         Store(Local2, \_SB.WMID.NTDC)
                         Notify(WMID, 0x80)
                     }
                 }
                 Method(_Q50) {
                     If(LEqual(\_SB.WMID.BAEF, One)) {
                         Store(0x00, Local1)
                         If(LEqual(\_SB.PCI0.LPC0.EC0.LCDS, 0x01)) {
                             Store(0x01, Local1)
                         }
                         Store(\_SB.WMID.LDOF, Local2)
                         Add(Local2, Local1, Local2)
                         Store(Local2, \_SB.WMID.NTDC)
                         Notify(WMID, 0x80)
                     }
                 }
                 Method(_Q60) {
                     If(LEqual(\_SB.WMID.BAEF, 0x01)) {
                         Store(\_SB.PCI0.LPC0.EC0.WLAT, Local1)
                         Store(\_SB.WMID.WLSD, Local2)
                         Add(Local2, Local1, Local2)
                         Store(Local2, \_SB.WMID.NTDC)
                         Notify(\_SB.WMID, 0x80)
                     }
                 }
                 Method(_Q43) {
                 }
                 OperationRegion(CCLK, SystemIO, 0x8010, 0x04)
                 Field(CCLK, DWordAcc, NoLock, Preserve) {
                     ,	1,
                     DUTY,	3,
                     THEN,	1,
                     Offset(0x1),
                     ,	9,
                     TSTS,	1
                 }
                 Mutex(FAMX, 0)
                 Method(FANG, 1) {
                     Acquire(FAMX, 0xffff)
                     Store(Arg0, ERIB)
                     Store(ERBD, Local0)
                     Release(FAMX)
                     Return(Local0)
                 }
                 Method(FANW, 2) {
                     Acquire(FAMX, 0xffff)
                     Store(Arg0, ERIB)
                     Store(Arg1, ERBD)
                     Release(FAMX)
                     Return(Arg1)
                 }
                 Method(TUVR, 1) {
                     Return(0x03)
                 }
                 Method(THRO, 1) {
                     If(LEqual(Arg0, 0x00)) {
                         Return(THEN)
                     }
                     Else {
                         If(LEqual(Arg0, 0x01)) {
                             Return(DUTY)
                         }
                         Else {
                             If(LEqual(Arg0, 0x02)) {
                                 Return(TTHR)
                             }
                             Else {
                                 Return(0xff)
                             }
                         }
                     }
                 }
                 Method(CLCK, 1) {
                     If(LEqual(Arg0, 0x00)) {
                         Store(0x00, THEN)
                     }
                     Else {
                         Store(Arg0, DUTY)
                         Store(0x01, THEN)
                     }
                     Return(THEN)
                 }
             }
             Device(MIR) {
                 Name(_HID, 0x0001c515)
                 Method(_STA) {
                     If(PJID) {
                         Return(0x00)
                     }
                     Else {
                         Return(0x0f)
                     }
                 }
                 Method(_CRS) {
                     Name(BUF0, Buffer(0x0d) {0x47, 0x1, 0x60, 0xfd, 0x60,=
  0xfd, 0x1, 0x4, 0x22, 0x10, 0x0, 0x79, 0x0 })
                     Return(BUF0)
                 }
                 Name(_PRS, Buffer(0x0d) {0x47, 0x1, 0x60, 0xfd, 0x60, 0xf=
 d, 0x1, 0x4, 0x22, 0x10, 0x0, 0x79, 0x0 })
             }
             Device(ACAD) {
                 Name(_HID, "ACPI0003")
                 Name(_PCL, Package(0x01) {
                     \_SB,
                 })
                 Method(_PSR) {
                     If(ECOK()) {
                         Store(\_SB.PCI0.LPC0.EC0.ADPT, Local0)
                         If(UMAS) {
                             If(Local0) {
                                 \_SB.PCI0.AGP.VGA.AFN4(0x01)
                             }
                             Else {
                                 \_SB.PCI0.AGP.VGA.AFN4(0x02)
                             }
                         }
                         Return(Local0)
                     }
                     Return(0x01)
                 }
             }
             Device(BAT1) {
                 Name(_HID, 0x0a0cd041)
                 Name(_UID, 0x01)
                 Name(_PCL, Package(0x01) {
                     \_SB,
                 })
                 Name(PBIF, Package(0x0d) {
                     0x01,
                     0x19c8,
                     0x19c8,
                     0x01,
                     0x39d0,
                     0x0294,
                     0xc6,
                     0x0108,
                     0x0ec4,
                     "Primary\x20",
                     "",
                     "Lion",
                     "Acer",
                 })
                 Name(PBST, Package(0x04) {
                     0x01,
                     0xffffffff,
                     0xffffffff,
                     0x39d0,
                 })
                 Method(_STA) {
                     If(ECOK()) {
                         If(\_SB.PCI0.LPC0.EC0.BAL1) {
                             Sleep(0x14)
                             Return(0x1f)
                         }
                         Else {
                             Sleep(0x14)
                             Return(0x0f)
                         }
                     }
                     Else {
                         Sleep(0x14)
                         Return(0x1f)
                     }
                 }
                 Method(_BIF) {
                     If(ECOK()) {
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BDC0, Index(PBIF, 0x01, =
 ))
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BFC0, Index(PBIF, 0x02, =
 ))
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BDV0, Index(PBIF, 0x04, =
 ))
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BDC0, Local2)
                         Divide(Local2, 0x64, Local6, Local2)
                         Multiply(Local2, 0x05, Local3)
                         Store(Local3, Index(PBIF, 0x05, ))
                         Multiply(Local2, 0x03, Local4)
                         Store(Local4, Index(PBIF, 0x06, ))
                         If(LNot(LLess(OSYS, 0x40))) {
                             ToHexString(\_SB.PCI0.LPC0.EC0.BSN0, Local2)
                             Mid(Local2,0x02,0x04,Local3)
                             Store(Local3, Index(PBIF, 0x0a, ))
                             Sleep(0x14)
                         }
                         Store(\_SB.PCI0.LPC0.EC0.BATD, Index(PBIF, 0x09, =
 ))
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BTMF, Local1)
                         Sleep(0x14)
                         If(LEqual(Local1, 0x01)) {
                             Store("SANYO\x20", Index(PBIF, 0x0c, ))
                         }
                         Else {
                             If(LEqual(Local1, 0x02)) {
                                 Store("SONY\x20", Index(PBIF, 0x0c, ))
                             }
                             Else {
                                 If(LEqual(Local1, 0x04)) {
                                     Store("PANASONIC\x20", Index(PBIF, 0x=
 0c, ))
                                 }
                                 Else {
                                     If(LEqual(Local1, 0x03)) {
                                         Store("Simplo\x20", Index(PBIF, 0=
 x0c, ))
                                     }
                                     Else {
                                         Store("COMPAL\x20", Index(PBIF, 0=
 x0c, ))
                                     }
                                 }
                             }
                         }
                     }
                     Return(PBIF)
                 }
                 Method(_BST) {
                     If(ECOK()) {
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BST0, Local0)
                         And(Local0, 0x07, Local0)
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.GAU0, Local2)
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BPV0, Local3)
                         Sleep(0x14)
                         Store(\_SB.PCI0.LPC0.EC0.BFC0, Local1)
                         If(Local2) {
                             Multiply(Local2, Local1, Local2)
                             Divide(Local2, 0x64, Local6, Local2)
                             If(Local6) {
                                 Increment(Local2)
                             }
                         }
                         Store(\_SB.PCI0.LPC0.EC0.BAC0, Local1)
                         If(And(Local1, 0x8000, Local1)) {
                             Store(\_SB.PCI0.LPC0.EC0.BAC0, Local1)
                             Subtract(0xffff, Local1, Local1)
                         }
                         Else {
                             Store(0x00, Local1)
                         }
                         Store(Local0, Index(PBST, 0x00, ))
                         Store(Local1, Index(PBST, 0x01, ))
                         Store(Local2, Index(PBST, 0x02, ))
                         Store(Local3, Index(PBST, 0x03, ))
                     }
                     Return(PBST)
                 }
             }
         }
         Device(P2P) {
             Name(_ADR, 0x00140004)
             Name(_PRW, Package(0x02) {
                 0x04,
                 0x05,
             })
             Method(_PRT) {
                 If(GPIC) {
                     Return(Package(0x01) {
                         Package(0x04) {
                             0x0001ffff,
                             0x00,
                             0x00,
                             0x14,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x01) {
                         Package(0x04) {
                             0x0001ffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKE,
                             0x00,
                         },
                     })
                 }
             }
         }
         Device(AGP) {
             Name(_ADR, 0x00010000)
             Method(_PRT) {
                 If(GPIC) {
                     Return(Package(0x02) {
                         Package(0x04) {
                             0x0005ffff,
                             0x00,
                             0x00,
                             0x12,
                         },
                         Package(0x04) {
                             0x0005ffff,
                             0x01,
                             0x00,
                             0x13,
                         },
                     })
                 }
                 Else {
                     Return(Package(0x02) {
                         Package(0x04) {
                             0x0005ffff,
                             0x00,
                             \_SB.PCI0.LPC0.LNKC,
                             0x00,
                         },
                         Package(0x04) {
                             0x0005ffff,
                             0x01,
                             \_SB.PCI0.LPC0.LNKD,
                             0x00,
                         },
                     })
                 }
             }
             Device(VGA) {
                 Name(_ADR, 0x00050000)
                 Method(_STA) {
                     Return(0x0f)
                 }
                 Name(ATIB, Buffer(0x0100) { })
                 Name(SWIT, 0x01)
                 Name(CRTA, 0x01)
                 Name(LCDA, 0x01)
                 Name(TVAA, 0x01)
                 Name(VLDF, 0x01)
                 OperationRegion(VIDS, PCI_Config, 0x00, 0xc8)
                 Field(VIDS, DWordAcc, NoLock, Preserve) {
                     VID0,	16,
                     DID0,	16
                 }
                 Name(_PSC, 0x00)
                 Method(_PS0) {
                     Store(0x00, _PSC)
                 }
                 Method(_PS1) {
                     Store(0x01, _PSC)
                 }
                 Method(_PS3) {
                     Store(0x03, _PSC)
                 }
                 Method(_DOS, 1) {
                     Store(And(Arg0, 0x03, ), SWIT)
                 }
                 Method(_DOD) {
                     Return(Package(0x03) {
                         0x00010100,
                         0x00010110,
                         0x0200,
                     })
                 }
                 Device(CRT) {
                     Method(_ADR) {
                         Return(0x0100)
                     }
                 }
                 Device(LCD) {
                     Method(_ADR) {
                         Return(0x0110)
                     }
                     Method(_BCL) {
                         Store(0xc0, P80H)
                         Return(Package(0x0c) {
                             0x64,
                             0x46,
                             0x0a,
                             0x14,
                             0x1e,
                             0x28,
                             0x32,
                             0x3c,
                             0x46,
                             0x50,
                             0x5a,
                             0x64,
                         })
                     }
                     Method(_BCM, 1) {
                         Store(0xc1, P80H)
                         Divide(Arg0, 0x0a, Local0, Local1)
                         Decrement(Local1)
                         Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS)
                     }
                     Method(_BQC) {
                         Store(0xc2, P80H)
                         Multiply(\_SB.PCI0.LPC0.EC0.BRTS, 0x0a, Local0)
                         Add(Local0, 0x01, Local0)
                         Sleep(0x64)
                         Return(Local0)
                     }
                 }
                 Device(TV) {
                     Method(_ADR) {
                         Return(0x0200)
                     }
                 }
                 Method(ATIF, 2, Serialized) {
                     If(LEqual(Arg0, 0x00)) {
                         Return(AF00())
                     }
                     If(LEqual(Arg0, 0x01)) {
                         Return(AF01())
                     }
                     If(LEqual(Arg0, 0x02)) {
                         Return(AF02())
                     }
                     If(LEqual(Arg0, 0x03)) {
                         Return(AF03(DerefOf(Index(Arg1, 0x02, )), DerefOf=
 (Index(Arg1, 0x04, ))))
                     }
                     Else {
                         CreateWordField(ATIB, 0x00, SSZE)
                         CreateWordField(ATIB, 0x02, VERN)
                         CreateDWordField(ATIB, 0x04, NMSK)
                         CreateDWordField(ATIB, 0x08, SFUN)
                         Store(0x00, SSZE)
                         Store(0x00, VERN)
                         Store(0x00, NMSK)
                         Store(0x00, SFUN)
                         Return(ATIB)
                     }
                 }
                 Method(AF00) {
                     Store(0xf0, P80H)
                     CreateWordField(ATIB, 0x00, SSZE)
                     CreateWordField(ATIB, 0x02, VERN)
                     CreateDWordField(ATIB, 0x04, NMSK)
                     CreateDWordField(ATIB, 0x08, SFUN)
                     Store(0x0c, SSZE)
                     Store(0x01, VERN)
                     If(CondRefOf(\_SB.PCI0.AGP.VGA.XTPX, Local4)) {
                         Store(0x11, NMSK)
                     }
                     Else {
                         Store(0x51, NMSK)
                     }
                     Store(NMSK, MSKN)
                     Store(0x07, SFUN)
                     Return(ATIB)
                 }
                 Name(NCOD, 0x81)
                 Method(AF01) {
                     Store(0xf1, P80H)
                     CreateWordField(ATIB, 0x00, SSZE)
                     CreateDWordField(ATIB, 0x02, VMSK)
                     CreateDWordField(ATIB, 0x06, FLGS)
                     Store(0x03, VMSK)
                     Store(0x0a, SSZE)
                     Store(0x01, FLGS)
                     Store(0x81, NCOD)
                     Return(ATIB)
                 }
                 Name(PSBR, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
                 Name(MSKN, 0x00)
                 Name(SEXM, 0x00)
                 Name(STHG, 0x00)
                 Name(STHI, 0x00)
                 Name(SFPG, 0x00)
                 Name(SFPI, 0x00)
                 Name(SSPS, 0x00)
                 Name(SSDM, 0x0a)
                 Name(SCDY, 0x00)
                 Name(SACT, Buffer(0x06) {0x1, 0x2, 0x8, 0x3, 0x9, 0xa })
                 Method(AF02) {
                     Store(0xf2, P80H)
                     CreateBitField(PSBR, 0x00, PDSW)
                     CreateBitField(PSBR, 0x01, PEXM)
                     CreateBitField(PSBR, 0x02, PTHR)
                     CreateBitField(PSBR, 0x03, PFPS)
                     CreateBitField(PSBR, 0x04, PSPS)
                     CreateBitField(PSBR, 0x05, PDCC)
                     CreateBitField(PSBR, 0x06, PXPS)
                     CreateWordField(ATIB, 0x00, SSZE)
                     CreateDWordField(ATIB, 0x02, PSBI)
                     CreateByteField(ATIB, 0x06, EXPM)
                     CreateByteField(ATIB, 0x07, THRM)
                     CreateByteField(ATIB, 0x08, THID)
                     CreateByteField(ATIB, 0x09, FPWR)
                     CreateByteField(ATIB, 0x0a, FPID)
                     CreateByteField(ATIB, 0x0b, SPWR)
                     Store(0x0c, SSZE)
                     Store(PSBR, PSBI)
                     If(PDSW) {
                         Store(0x82, P80H)
                         Store(Zero, PDSW)
                     }
                     If(PEXM) {
                         Store(SEXM, EXPM)
                         Store(Zero, SEXM)
                         Store(Zero, PEXM)
                     }
                     If(PTHR) {
                         Store(STHG, THRM)
                         Store(STHI, THID)
                         Store(Zero, STHG)
                         Store(Zero, STHI)
                         Store(Zero, PTHR)
                     }
                     If(PFPS) {
                         Store(SFPG, FPWR)
                         Store(SFPI, FPWR)
                         Store(Zero, SFPG)
                         Store(Zero, SFPI)
                         Store(Zero, PFPS)
                     }
                     If(PSPS) {
                         Store(SSPS, SPWR)
                         Store(Zero, PSPS)
                     }
                     If(PXPS) {
                         Store(0xa2, P80H)
                         Store(Zero, PXPS)
                     }
                     Return(ATIB)
                 }
                 Method(AF03, 2) {
                     Store(0xf3, P80H)
                     CreateWordField(ATIB, 0x00, SSZE)
                     CreateWordField(ATIB, 0x02, SSDP)
                     CreateWordField(ATIB, 0x04, SCDP)
                     Store(Arg0, SSDP)
                     Store(Arg1, SCDP)
                     Name(NXTD, 0x06)
                     Name(CIDX, 0x06)
                     Store(SSDP, Local1)
                     And(Local1, 0x0b, Local1)
                     Store(SCDP, Local2)
                     If(CondRefOf(\_SB.LID._LID, Local4)) {
                         And(Local2, Not(0x01, ), Local2)
                         Or(Local2, \_SB.LID._LID(), Local2)
                     }
                     Else {
                         Or(Local2, 0x01, Local2)
                     }
                     Store(Local2, P80H)
                     Store(Zero, Local0)
                     While(LLess(Local0, SizeOf(SACT))) {
                         Store(DerefOf(Index(SACT, Local0, )), Local3)
                         If(LEqual(Local3, Local1)) {
                             Store(Local0, CIDX)
                             Store(SizeOf(SACT), Local0)
                         }
                         Else {
                             Increment(Local0)
                         }
                     }
                     Store(CIDX, Local0)
                     While(LLess(Local0, SizeOf(SACT))) {
                         Increment(Local0)
                         If(LEqual(Local0, SizeOf(SACT))) {
                             Store(0x00, Local0)
                         }
                         Store(DerefOf(Index(SACT, Local0, )), Local3)
                         If(LEqual(And(Local3, Local2, ), Local3)) {
                             Store(Local0, NXTD)
                             Store(SizeOf(SACT), Local0)
                         }
                     }
                     If(LEqual(NXTD, SizeOf(SACT))) {
                         Store(Zero, SSDP)
                     }
                     Else {
                         Store(NXTD, Local0)
                         Store(DerefOf(Index(SACT, Local0, )), Local3)
                         And(SSDP, Not(0x0b, ), SSDP)
                         Or(SSDP, Local3, SSDP)
                     }
                     Store(0x04, SSZE)
                     Store(SSDP, P80H)
                     Return(ATIB)
                 }
                 Method(AFN0, 0, Serialized) {
                     If(And(MSKN, 0x01, )) {
                         CreateBitField(PSBR, 0x00, PDSW)
                         Store(One, PDSW)
                         Notify(VGA, NCOD)
                     }
                 }
                 Method(AFN3, 2, Serialized) {
                     If(And(MSKN, 0x08, )) {
                         Store(Arg0, Local0)
                         Store(Local0, SFPI)
                         Store(Arg1, Local0)
                         Store(And(Local0, 0x03, Local0), SFPG)
                         CreateBitField(PSBR, 0x03, PFPS)
                         Store(One, PFPS)
                         Notify(VGA, NCOD)
                     }
                 }
                 Method(AFN4, 1, Serialized) {
                     If(And(MSKN, 0x10, )) {
                         Store(Arg0, Local0)
                         Store(SSPS, Local1)
                         Store(Local0, SSPS)
                         If(LEqual(Local0, Local1)) {
                         }
                         Else {
                             CreateBitField(PSBR, 0x04, PSPS)
                             Store(One, PSPS)
                             Notify(VGA, NCOD)
                         }
                     }
                 }
                 Method(AFN5, 0, Serialized) {
                     If(And(MSKN, 0x20, )) {
                         CreateBitField(PSBR, 0x05, PDCC)
                         Store(One, PDCC)
                         Notify(VGA, NCOD)
                     }
                 }
                 Method(AFN6, 0, Serialized) {
                     If(And(MSKN, 0x40, )) {
                         CreateBitField(PSBR, 0x06, PXPS)
                         Store(One, PXPS)
                         Notify(VGA, NCOD)
                     }
                 }
             }
         }
         Scope(\_SB.PCI0.AGP.VGA) {
             Name(ATPB, Buffer(0x0100) { })
             Name(DSID, 0xffffffff)
             Method(XTPX, 2, Serialized) {
                 If(LEqual(Arg0, 0x00)) {
                     Return(PX00())
                 }
                 If(LEqual(Arg0, 0x01)) {
                     Return(PX01())
                 }
                 If(LEqual(Arg0, 0x02)) {
                     Return(PX02(DerefOf(Index(Arg1, 0x02, ))))
                 }
                 If(LEqual(Arg0, 0x03)) {
                     Return(PX03(DerefOf(Index(Arg1, 0x02, ))))
                 }
                 CreateWordField(ATPB, 0x00, SSZE)
                 CreateWordField(ATPB, 0x02, VERN)
                 CreateDWordField(ATPB, 0x04, SFUN)
                 Store(0x00, SSZE)
                 Store(0x00, VERN)
                 Store(0x00, SFUN)
                 Return(ATPB)
             }
             Method(PX00) {
                 Store(0xe0, P80H)
                 CreateWordField(ATPB, 0x00, SSZE)
                 CreateWordField(ATPB, 0x02, VERN)
                 CreateDWordField(ATPB, 0x04, SFUN)
                 Store(0x08, SSZE)
                 Store(0x01, VERN)
                 Store(0x07, SFUN)
                 Store(\_SB.PCI0.PB2.DGFX.SVID, Local0)
                 If(LNot(LEqual(Local0, 0xffffffff))) {
                     Store(Local0, \_SB.PCI0.AGP.VGA.DSID)
                 }
                 Return(ATPB)
             }
             Method(PX01) {
                 Store(0xe1, P80H)
                 CreateWordField(ATPB, 0x00, SSZE)
                 CreateDWordField(ATPB, 0x02, VMSK)
                 CreateDWordField(ATPB, 0x06, FLGS)
                 Store(0x0a, SSZE)
                 Store(0x0f, VMSK)
                 Store(0x0f, FLGS)
                 Return(ATPB)
             }
             Method(PX02, 1) {
                 CreateWordField(ATPB, 0x00, SSZE)
                 CreateByteField(ATPB, 0x02, PWST)
                 Store(0x03, SSZE)
                 And(Arg0, 0x01, PWST)
                 Name(HPOK, 0x00)
                 Store(0x01, \_SB.PCI0.SMB.G72F)
                 Store(0x01, \_SB.PCI0.SMB.G36F)
                 If(PWST) {
                     Store(0x11e2, P80H)
                     Store(One, \_SB.PCI0.SMB.G72O)
                     Store(Zero, \_SB.PCI0.SMB.G72E)
                     Sleep(0x32)
                     Store(One, \_SB.PCI0.SMB.G36O)
                     Store(Zero, \_SB.PCI0.SMB.G36E)
                     Store(0x12e2, P80H)
                     Store(0x00, HPOK)
                     Sleep(0x64)
                     Sleep(0x64)
                     \_SB.PCI0.XPTR(0x02, 0x01)
                     Sleep(0x14)
                     Store(0x00, Local2)
                     While(LLess(Local2, 0x0f)) {
                         Store(0x08, \_SB.PCI0.PB2.SLST)
                         Store(0x01, Local4)
                         Store(0xc8, Local5)
                         While(LAnd(Local4, Local5)) {
                             Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
                             And(Local6, 0x7f, Local6)
                             If(LAnd(LNot(LLess(Local6, 0x10)), LNot(LEqua=
 l(Local6, 0x7f)))) {
                                 Store(0x00, Local4)
                             }
                             Else {
                                 Sleep(0x05)
                                 Decrement(Local5)
                             }
                         }
                         If(LNot(Local4)) {
                             Store(\_SB.PCI0.PB2.XPDL(), Local5)
                             If(Local5) {
                                 \_SB.PCI0.PB2.XPRT()
                                 Sleep(0x05)
                                 Increment(Local2)
                             }
                             Else {
                                 Store(0x10, \_SB.PCI0.LPC0.INFO)
                                 Store(0x87, \_SB.PCI0.LPC0.BCMD)
                                 Store(Zero, \_SB.PCI0.LPC0.SMIC)
                                 If(LEqual(\_SB.PCI0.PB2.XPR2(), Ones)) {
                                     Store(0x01, HPOK)
                                     Store(0x10, Local2)
                                 }
                                 Else {
                                     Store(0x00, HPOK)
                                     Store(0x10, Local2)
                                 }
                             }
                         }
                         Else {
                             Store(0x10, Local2)
                         }
                     }
                     If(LNot(HPOK)) {
                         Store(0x13e2, P80H)
                         Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
                         Sleep(0x0a)
                         Store(0x01, Local4)
                         Store(0x05, Local5)
                         While(LAnd(Local4, Local5)) {
                             Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
                             And(Local6, 0x7f, Local6)
                             If(LNot(LGreater(Local6, 0x04))) {
                                 Store(0x00, Local4)
                             }
                             Else {
                                 Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
                                 Sleep(0x05)
                                 Decrement(Local5)
                             }
                         }
                         \_SB.PCI0.XPTR(0x02, 0x00)
                     }
                     Store(0x14e2, P80H)
                 }
                 Else {
                     Store(0x02e2, P80H)
                     Store(Zero, \_SB.PCI0.SMB.G36O)
                     Store(Zero, \_SB.PCI0.SMB.G36E)
                     Store(Zero, \_SB.PCI0.SMB.G72O)
                     Store(Zero, \_SB.PCI0.SMB.G72E)
                     Store(0x03e2, P80H)
                     Store(0x08, \_SB.PCI0.PB2.SLST)
                     Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
                     Sleep(0x0a)
                     Store(0x01, Local4)
                     Store(0x05, Local5)
                     While(LAnd(Local4, Local5)) {
                         Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
                         And(Local6, 0x7f, Local6)
                         If(LNot(LGreater(Local6, 0x04))) {
                             Store(0x00, Local4)
                         }
                         Else {
                             Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
                             Sleep(0x05)
                             Decrement(Local5)
                         }
                     }
                     \_SB.PCI0.XPTR(0x02, 0x00)
                     Store(0x02, HPOK)
                     Store(0x04e2, P80H)
                 }
                 If(HPOK) {
                     If(LAnd(LEqual(HPOK, 0x01), LNot(LEqual(\_SB.PCI0.AGP=
 =2EVGA.DSID, 0xffffffff)))) {
                         Store(\_SB.PCI0.AGP.VGA.DSID, Local7)
                         Store(Local7, \_SB.PCI0.PB2.DGFX.SMID)
                         Sleep(0x0a)
                     }
                     Notify(\_SB.PCI0.PB2, 0x00)
                 }
             }
             Method(PX03, 1) {
                 CreateWordField(ATPB, 0x00, SSZE)
                 CreateWordField(ATPB, 0x02, DPSW)
                 Store(0x04, SSZE)
                 And(Arg0, 0x01, DPSW)
                 If(DPSW) {
                     Store(0x02e3, P80H)
                     Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
                     Store(0x02, \_SB.PCI0.LPC0.INFO)
                     Store(0x85, \_SB.PCI0.LPC0.BCMD)
                     Store(Zero, \_SB.PCI0.LPC0.SMIC)
                     Release(\_SB.PCI0.LPC0.PSMX)
                 }
                 Else {
                     Store(0x01e3, P80H)
                     Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
                     Store(0x01, \_SB.PCI0.LPC0.INFO)
                     Store(0x85, \_SB.PCI0.LPC0.BCMD)
                     Store(Zero, \_SB.PCI0.LPC0.SMIC)
                     Release(\_SB.PCI0.LPC0.PSMX)
                 }
             }
         }
         Scope(\_SB.PCI0.AGP.VGA) {
             OperationRegion(REVD, SystemMemory, 0xafedde6c, 0x00000008)
             Field(REVD, AnyAcc, NoLock, Preserve) {
                 SROM,	32,
                 VROM,	32
             }
             Name(TVGA, Buffer(0x0004) {0x0 })
             Method(XTRM, 2, Serialized) {
                 Add(Arg0, Arg1, Local0)
                 If(LNot(LGreater(Local0, SROM))) {
                     Multiply(Arg1, 0x08, Local1)
                     Multiply(Arg0, 0x08, Local2)
                     Store(VROM, TVGA)
                     CreateField(TVGA, Local2, Local1, TEMP)
                     Name(RETB, Buffer(Arg1) { })
                     Store(TEMP, RETB)
                     Return(RETB)
                 }
                 Else {
                     If(LLess(Arg0, SROM)) {
                         Subtract(SROM, Arg0, Local3)
                         Multiply(Local3, 0x08, Local1)
                         Multiply(Arg0, 0x08, Local2)
                         Store(VROM, TVGA)
                         CreateField(TVGA, Local2, Local1, TEM)
                         Name(RETC, Buffer(Local3) { })
                         Store(TEM, RETC)
                         Return(RETC)
                     }
                     Else {
                         Name(RETD, Buffer(0x01) { })
                         Return(RETD)
                     }
                 }
             }
         }
     }
 }
 Scope(\_GPE) {
     Method(_L04) {
         Notify(\_SB.PCI0.P2P, 0x02)
     }
     Method(_L0B) {
         Notify(\_SB.PCI0.OHC0, 0x02)
         Notify(\_SB.PCI0.OHC1, 0x02)
         Notify(\_SB.PCI0.OHC2, 0x02)
         Notify(\_SB.PCI0.OHC3, 0x02)
         Notify(\_SB.PCI0.OHC4, 0x02)
         Notify(\_SB.PCI0.EHC0, 0x02)
         Notify(\_SB.PCI0.EHC1, 0x02)
     }
     Method(_L0E) {
         If(LEqual(\_SB.WMID.BGEF, 0x01)) {
             If(LNot(LEqual(CRTS, 0x01))) {
                 Store(0x01, CRTS)
                 Store(\_SB.WMID.VAPI, Local0)
             }
             Else {
                 Store(0x00, CRTS)
                 Store(\_SB.WMID.VAPO, Local0)
             }
             Store(Local0, \_SB.WMID.NTDV)
             Notify(\_SB.WMID, 0x82)
         }
     }
     Method(_L19) {
         Store(\_SB.PCI0.SMB.GM4C, Local0)
         Not(Local0, Local0)
         And(Local0, 0x01, \_SB.PCI0.SMB.GM4C)
         Store(0x01, \_SB.PCI0.SMB.GM4S)
         If(LAnd(LNot(LLess(\_SB.TPOS, 0x04)), LLess(\_SB.TPOS, 0x40))) {
             Store(And(\_SB.PCI0.SMB.GM4C, 0x01, ), Local0)
             Store(Local0, \_SB.PCI0.LPC0.INFO)
             Store(0x8f, \_SB.PCI0.LPC0.BCMD)
             Store(Zero, \_SB.PCI0.LPC0.SMIC)
         }
         Notify(\_SB.LID, 0x80)
     }
     Mutex(Z013, 0)
     Method(_L1A) {
         Name(HPOK, 0x00)
         Acquire(Z013, 0xffff)
         If(\_SB.PCI0.SMB.GM5C) {
             Sleep(0x14)
             Store(\_SB.PCI0.LPC0.RGPM(), Local0)
             If(And(Local0, 0x20, )) {
                 Store(0x00, \_SB.PCI0.SMB.GM5C)
                 Store("HotPlug\x3a04\x3a\x20Removal\x20Event", Debug)
                 Store(0x08, \_SB.PCI0.PB4.SLST)
                 Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
                 Sleep(0x0a)
                 Store(0x01, Local4)
                 Store(0x05, Local5)
                 While(LAnd(Local4, Local5)) {
                     Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
                     And(Local6, 0x7f, Local6)
                     If(LNot(LGreater(Local6, 0x04))) {
                         Store(0x00, Local4)
                     }
                     Else {
                         Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
                         Sleep(0x05)
                         Decrement(Local5)
                     }
                 }
                 \_SB.PCI0.XPTR(0x04, 0x00)
                 \_SB.PCI0.PB4.XPLP(0x00)
                 Sleep(0x1388)
                 Store(0x01, HPOK)
             }
         }
         Else {
             Sleep(0x14)
             Store(\_SB.PCI0.LPC0.RGPM(), Local0)
             If(LNot(And(Local0, 0x20, ))) {
                 Store(0x01, \_SB.PCI0.SMB.GM5C)
                 Store("HotPlug\x3a04\x3a\x20Insertion\x20Event", Debug)
                 Store(0x00, HPOK)
                 \_SB.PCI0.PB4.XPLP(0x01)
                 Sleep(0xc8)
                 \_SB.PCI0.XPTR(0x04, 0x01)
                 Sleep(0x14)
                 Store(0x00, Local2)
                 While(LLess(Local2, 0x0f)) {
                     Store(0x08, \_SB.PCI0.PB4.SLST)
                     Store(0x01, Local4)
                     Store(0xc8, Local5)
                     While(LAnd(Local4, Local5)) {
                         Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
                         And(Local6, 0x7f, Local6)
                         If(LAnd(LNot(LLess(Local6, 0x10)), LNot(LEqual(Lo=
 cal6, 0x7f)))) {
                             Store("HotPlug\x3a04\x3a\x20TrainingState\x3d=
 0x10", Debug)
                             Store(0x00, Local4)
                         }
                         Else {
                             Sleep(0x05)
                             Decrement(Local5)
                         }
                     }
                     If(LNot(Local4)) {
                         Store("HotPlug\x3a04\x3a\x20Check\x20VC\x20Negoti=
 ation\x20Pending", Debug)
                         Store(\_SB.PCI0.PB4.XPDL(), Local5)
                         If(Local5) {
                             Store("HotPlug\x3a04\x3a\x20Retraining\x20Lin=
 k", Debug)
                             \_SB.PCI0.PB4.XPRT()
                             Sleep(0x05)
                             Increment(Local2)
                         }
                         Else {
                             Store("HotPlug\x3a04\x3a\x20Device\x20OK", De=
 bug)
                             Store(0x20, \_SB.PCI0.LPC0.INFO)
                             Store(0x87, \_SB.PCI0.LPC0.BCMD)
                             Store(Zero, \_SB.PCI0.LPC0.SMIC)
                             If(LEqual(\_SB.PCI0.PB4.XPR2(), Ones)) {
                                 Store(0x01, HPOK)
                                 Store(0x10, Local2)
                             }
                             Else {
                                 Store("HotPlug\x3a04\x3a\x20Common\x20Clo=
 ck\x20Retraining\x20Failed", Debug)
                                 Store(0x00, HPOK)
                                 Store(0x10, Local2)
                             }
                         }
                     }
                     Else {
                         Store("HotPlug\x3a04\x3a\x20TrainingState\x20Time=
 out", Debug)
                         Store(0x10, Local2)
                     }
                 }
                 If(LNot(HPOK)) {
                     Store("HotPlug\x3a04\x3a\x20Insertion\x20Failed\x3a\x=
 20Disable\x20Training\x20\x26\x20PowerDown", Debug)
                     Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
                     Sleep(0x0a)
                     Store(0x01, Local4)
                     Store(0x05, Local5)
                     While(LAnd(Local4, Local5)) {
                         Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
                         And(Local6, 0x7f, Local6)
                         If(LNot(LGreater(Local6, 0x04))) {
                             Store(0x00, Local4)
                         }
                         Else {
                             Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
                             Sleep(0x05)
                             Decrement(Local5)
                         }
                     }
                     \_SB.PCI0.XPTR(0x04, 0x00)
                     \_SB.PCI0.PB4.XPLP(0x00)
                 }
             }
         }
         If(HPOK) {
             Notify(\_SB.PCI0.PB4, 0x00)
         }
         Release(Z013)
     }
     Method(_L1B) {
         Notify(\_SB.PCI0.HDA, 0x02)
     }
     Method(_L1C) {
         Name(HPOK, 0x00)
         Store(0xca, P80H)
         If(LNot(LEqual(PJID, 0x03))) {
             If(LOr(LEqual(EBID, 0x03), LNot(LEqual(PJID, 0x01)))) {
                 If(\_SB.PCI0.SMB.GM6C) {
                     Store(0xcb, P80H)
                     Sleep(0x14)
                     Store(\_SB.PCI0.LPC0.RGPM(), Local0)
                     If(And(Local0, 0x40, )) {
                         Store(0x00, \_SB.PCI0.SMB.GM6C)
                         Store(0x08, \_SB.PCI0.PB9.SLST)
                         Store(0x01, HPOK)
                     }
                 }
                 Else {
                     Store(0xcc, P80H)
                     Sleep(0x14)
                     Store(\_SB.PCI0.LPC0.RGPM(), Local0)
                     If(LNot(And(Local0, 0x40, ))) {
                         Store(0x01, \_SB.PCI0.SMB.GM6C)
                         Store(0x08, \_SB.PCI0.PB9.SLST)
                         Store(0x01, HPOK)
                     }
                 }
                 If(HPOK) {
                     If(And(\_SB.PCI0.PB9.SLST, 0x40, )) {
                         Store(0xcd, P80H)
                         \_SB.PCI0.LPC0.PHSS(0x5a)
                         Stall(0xff)
                     }
                     Notify(\_SB.PCI0.PB9, 0x00)
                 }
             }
         }
     }
 }
 Scope(_TZ) {
     Name(DTMP, 0x0bba)
     Name(DAC0, 0x0ca0)
     Name(DPSV, 0x0e30)
     Name(TBSE, 0x0aac)
     Name(DCRT, 0x127c)
     ThermalZone(THRM) {
         Method(_TMP) {
             If(\_SB.PCI0.LPC0.ECOK()) {
                 Multiply(\_SB.PCI0.LPC0.EC0.CTMP, 0x0a, Local0)
                 Add(Local0, 0x0aac, Local0)
                 Return(Local0)
             }
             Return(DTMP)
         }
         Method(_AC0) {
             Return(DAC0)
         }
         Method(_CRT) {
             Return(DCRT)
         }
         Method(_PSV) {
             Return(DPSV)
         }
         Method(_PSL, 0, Serialized) {
             If(CPUS) {
                 Return(Package(0x01) {
                     \_PR.CPU0,
                 })
             }
             Else {
                 Return(Package(0x02) {
                     \_PR.CPU0,
                     \_PR.CPU1,
                 })
             }
         }
         Name(_TC1, 0x02)
         Name(_TC2, 0x05)
         Name(_TSP, 0x012c)
     }
     ThermalZone(Z014) {
         Method(_TMP) {
             If(\_SB.PCI0.LPC0.ECOK()) {
                 Multiply(\_SB.PCI0.LPC0.EC0.SKTA, 0x0a, Local0)
                 Add(Local0, 0x0aac, Local0)
                 Return(Local0)
             }
             Return(DTMP)
         }
         Method(_AC0) {
             Return(DAC0)
         }
         Method(_CRT) {
             Return(DCRT)
         }
         Method(_PSV) {
             Return(DPSV)
         }
         Method(_PSL, 0, Serialized) {
             If(CPUS) {
                 Return(Package(0x01) {
                     \_PR.CPU0,
                 })
             }
             Else {
                 Return(Package(0x02) {
                     \_PR.CPU0,
                     \_PR.CPU1,
                 })
             }
         }
         Name(_TC1, 0x02)
         Name(_TC2, 0x05)
         Name(_TSP, 0x012c)
     }
 }
 Scope(\_SB.PCI0.SMB) {
     Mutex(SBX0, 0)
     OperationRegion(SMB1, SystemIO, 0x8050, 0x10)
     Field(SMB1, ByteAcc, NoLock, Preserve) {
         HSTS,	8,
         SLVS,	8,
         HCNT,	8,
         HCMD,	8,
         HADD,	8,
         DAT0,	8,
         DAT1,	8,
         BLKD,	8,
         PECR,	8,
         CAUX,	8,
         ASFS,	8,
         SMK0,	8,
         SMK1,	8,
         SLMC,	8,
         RADD,	8,
         SADD,	8
     }
     Method(SBI) {
         Store(Package(0x02) {
             0x10,
             0x00,
         }, Local0)
         Store(Buffer(0x05) {0x10, 0x20, 0x3, 0xa, 0x0 }, Index(Local0, 0x=
 01, ))
         Return(Local0)
     }
     Method(SWBD, 1) {
         Store(Arg0, Local0)
         Store(0x00, Local2)
         Store(HSTS, Local3)
         Store(And(Local3, 0x80, ), Local1)
         While(LNot(LEqual(Local1, 0x80))) {
             If(LLess(Local0, 0x0a)) {
                 Store(0x18, Local2)
                 Store(0x00, Local1)
             }
             Else {
                 Sleep(0x0a)
                 Subtract(Local0, 0x0a, Local0)
                 Store(HSTS, Local3)
                 Store(And(Local3, 0x80, ), Local1)
             }
         }
         If(LNot(LEqual(Local2, 0x18))) {
             Store(And(HSTS, 0x1c, ), Local1)
             If(Local1) {
                 Store(0x07, Local2)
             }
         }
         Return(Local2)
     }
     Method(SWTC, 1) {
         Store(Arg0, Local0)
         Store(0x07, Local2)
         Store(0x01, Local1)
         While(LEqual(Local1, 0x01)) {
             Store(And(HSTS, 0x1f, ), Local3)
             If(LNot(LEqual(Local3, 0x00))) {
                 If(LEqual(Local3, 0x01)) {
                     If(LLess(Local0, 0x0a)) {
                         Store(0x18, Local2)
                         Store(0x00, Local1)
                     }
                     Else {
                         Sleep(0x0a)
                         Subtract(Local0, 0x0a, Local0)
                     }
                 }
                 Else {
                     Store(0x07, Local2)
                     Store(0x00, Local1)
                 }
             }
             Else {
                 Store(0x00, Local2)
                 Store(0x00, Local1)
             }
         }
         Store(Or(HSTS, 0x1f, ), HSTS)
         Return(Local2)
     }
     Method(SBR, 3) {
         Store(Package(0x22) {
             0x07,
             0x00,
             0x00,
         }, Local0)
         Store(And(Arg0, 0x5f, ), Local4)
         If(LNot(LEqual(Local4, 0x03))) {
             If(LNot(LEqual(Local4, 0x05))) {
                 If(LNot(LEqual(Local4, 0x07))) {
                     If(LNot(LEqual(Local4, 0x09))) {
                         If(LNot(LEqual(Local4, 0x0b))) {
                             Store(0x19, Index(Local0, 0x00, ))
                             Return(Local0)
                         }
                     }
                 }
             }
         }
         If(LEqual(Acquire(SBX0, 0xffff), 0x00)) {
             Store(Or(ShiftLeft(Arg1, 0x01, ), 0x01, ), HADD)
             Store(Arg2, HCMD)
             Store(Or(HSTS, 0x1f, ), HSTS)
             Store(And(Arg0, 0xa0, ), Local1)
             Store(Or(And(HCNT, 0x5f, ), Local1, ), HCNT)
             If(LEqual(Local4, 0x03)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x40, ), HCNT)
             }
             If(LEqual(Local4, 0x05)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x44, ), HCNT)
             }
             If(LEqual(Local4, 0x07)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x48, ), HCNT)
             }
             If(LEqual(Local4, 0x09)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x4c, ), HCNT)
             }
             If(LEqual(Local4, 0x0b)) {
                 Store(Or(HSTS, 0x80, ), HSTS)
                 Store(0x00, DAT0)
                 Store(Or(And(HCNT, 0xa0, ), 0x54, ), HCNT)
             }
             Store(SWTC(0x03e8), Local1)
             Store(Local1, Index(Local0, 0x00, ))
             If(LEqual(Local1, 0x00)) {
                 If(LEqual(Local4, 0x05)) {
                     Store(0x01, Index(Local0, 0x01, ))
                     Store(DAT0, Index(Local0, 0x02, ))
                 }
                 If(LEqual(Local4, 0x07)) {
                     Store(0x01, Index(Local0, 0x01, ))
                     Store(DAT0, Index(Local0, 0x02, ))
                 }
                 If(LEqual(Local4, 0x09)) {
                     Store(0x02, Index(Local0, 0x01, ))
                     Store(DAT1, Local2)
                     ShiftLeft(Local2, 0x08, Local2)
                     Add(Local2, DAT0, Local2)
                     Store(Local2, Index(Local0, 0x02, ))
                 }
                 If(LEqual(Local4, 0x0b)) {
                     Store(SWBD(0x01f4), Local1)
                     If(LNot(LEqual(Local1, 0x00))) {
                         Store(Local1, Index(Local0, 0x00, ))
                     }
                     Else {
                         Store(DAT0, Index(Local0, 0x01, ))
                         Store(DAT0, Local1)
                         Store(HCNT, Local2)
                         Store(0x00, Local2)
                         While(LLess(Local2, Local1)) {
                             Add(0x02, Local2, Local3)
                             Store(BLKD, Index(Local0, Local3, ))
                             Add(0x01, Local2, Local2)
                         }
                         Store(Or(HSTS, 0x80, ), HSTS)
                     }
                 }
             }
             Store(And(HCNT, 0x5f, ), HCNT)
             Release(SBX0)
         }
         Return(Local0)
     }
     Method(SBW, 5) {
         Store(Package(0x01) {
             0x07,
         }, Local0)
         Store(And(Arg0, 0x5f, ), Local4)
         If(LNot(LEqual(Local4, 0x02))) {
             If(LNot(LEqual(Local4, 0x04))) {
                 If(LNot(LEqual(Local4, 0x06))) {
                     If(LNot(LEqual(Local4, 0x08))) {
                         If(LNot(LEqual(Local4, 0x0a))) {
                             Store(0x19, Index(Local0, 0x00, ))
                             Return(Local0)
                         }
                     }
                 }
             }
         }
         If(LEqual(Acquire(SBX0, 0xffff), 0x00)) {
             Store(ShiftLeft(Arg1, 0x01, ), HADD)
             Store(Arg2, HCMD)
             Store(Or(HSTS, 0x1f, ), HSTS)
             Store(And(Arg0, 0xa0, ), Local1)
             Store(Or(And(HCNT, 0x5f, ), Local1, ), HCNT)
             If(LEqual(Local4, 0x02)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x40, ), HCNT)
             }
             If(LEqual(Local4, 0x04)) {
                 Store(Or(And(HCNT, 0xa0, ), 0x44, ), HCNT)
             }
             If(LEqual(Local4, 0x06)) {
                 Store(Arg4, DAT0)
                 Store(Or(And(HCNT, 0xa0, ), 0x48, ), HCNT)
             }
             If(LEqual(Local4, 0x08)) {
                 And(Arg4, 0xff, DAT0)
                 ShiftRight(Arg4, 0x08, DAT1)
                 Store(Or(And(HCNT, 0xa0, ), 0x4c, ), HCNT)
             }
             If(LEqual(Local4, 0x0a)) {
                 Store(Or(HSTS, 0x80, ), HSTS)
                 Store(HCNT, Local1)
                 Store(Arg3, DAT0)
                 Store(0x00, Local2)
                 While(LLess(Local2, Arg3)) {
                     Store(Index(Arg4, Local2, ), BLKD)
                     Add(0x01, Local2, Local2)
                 }
                 Store(Or(And(HCNT, 0xa0, ), 0x54, ), HCNT)
             }
             Store(SWTC(0x03e8), Index(Local0, 0x00, ))
             Store(And(HCNT, 0x5f, ), HCNT)
             Release(SBX0)
         }
         Return(Local0)
     }
 }
 Scope(\_SB.PCI0.SMB) {
     Name(ASD, Buffer(0x04) {0xff, 0xff, 0xff, 0xff })
     Device(OW00) {
         Name(_HID, "MGMT201")
         Name(_UID, 0x02010300)
         Method(_STA) {
             Return(ASFE)
         }
         Method(INFO) {
             Name(BUFF, Buffer(0x1a) {0x2, 0x10, 0x1, 0x3, 0x0, 0x4, 0x1, =
 0x0, 0x0, 0x0, 0x1, 0x2, 0x0, 0x0, 0x0, 0x1, 0x3, 0x0, 0x0, 0x0, 0x0, 0x4=
 , 0x0, 0x0, 0x0, 0x1 })
             Store(WTQ(), Local0)
             Store(Local0, Index(BUFF, 0x14, ))
             Return(BUFF)
         }
         Method(WTV) {
             Return(0x80000000)
         }
         Method(WTR) {
         }
         Method(WTQ) {
             Store(0xaf, \_SB.PCI0.LPC0.BCMD)
             Store(0x02, \_SB.PCI0.LPC0.DID)
             Store(Zero, \_SB.PCI0.LPC0.SMIC)
             Return(\_SB.PCI0.LPC0.INFO)
         }
         Method(WTC, 1) {
             Store(0x00, Local1)
             Store(0x01, Local2)
             While(LNot(LEqual(Local2, 0xff))) {
                 Store(Index(\_SB.PCI0.SMB.ASD, Local1, ), Local2)
                 If(LNot(LEqual(Local2, 0xff))) {
                     STOP(Local2)
                     STRT(Local2, Arg0)
                     Add(Local1, 0x01, Local1)
                 }
             }
         }
         Method(WAQ) {
             Return(0x01)
         }
         Method(WAC, 1) {
             If(LEqual(Arg0, 0x00)) {
                 Store(0x00, Local1)
                 Store(0x01, Local2)
                 While(LNot(LEqual(Local2, 0xff))) {
                     Store(Index(\_SB.PCI0.SMB.ASD, Local1, ), Local2)
                     If(LNot(LEqual(Local2, 0xff))) {
                         STOP(Local2)
                         Add(Local1, 0x01, Local1)
                     }
                 }
             }
         }
         Name(MSG, Buffer(0x20) { })
         Method(STRT, 2) {
             Store(0x13, Index(MSG, 0x00, ))
             Store(0x10, Index(MSG, 0x01, ))
             Store(And(Arg1, 0xff, ), Index(MSG, 0x02, ))
             Store(ShiftRight(Arg1, 0x08, ), Index(MSG, 0x03, ))
             Store(0x20, Index(MSG, 0x04, ))
             Store(0x6f, Index(MSG, 0x05, ))
             Store(0x10, Index(MSG, 0x06, ))
             Store(0x68, Index(MSG, 0x07, ))
             Store(0x10, Index(MSG, 0x08, ))
             Store(0xff, Index(MSG, 0x09, ))
             Store(0xff, Index(MSG, 0x0a, ))
             Store(0x23, Index(MSG, 0x0b, ))
             Store(0x00, Index(MSG, 0x0c, ))
             \_SB.PCI0.SMB.SBW(0x0a, Arg0, 0x02, 0x0d, MSG)
         }
         Method(STOP, 1) {
             Store(0x14, Index(MSG, 0x00, ))
             Store(0x10, Index(MSG, 0x01, ))
             \_SB.PCI0.SMB.SBW(0x0a, Arg0, 0x02, 0x02, MSG)
         }
     }
     Device(OW01) {
         Name(_HID, "MGMT201")
         Name(_UID, 0x02010400)
         Method(_STA) {
             Return(ASFE)
         }
         Method(INFO) {
             Name(BUFF, Buffer(0x1a) {0x2, 0x10, 0x1, 0x4, 0x0, 0x4, 0x1, =
 0x0, 0x0, 0x0, 0x1, 0x2, 0x0, 0x0, 0x0, 0x1, 0x3, 0x0, 0x0, 0x0, 0x0, 0x4=
 , 0x0, 0x0, 0x0, 0x1 })
             Store(WTQ(), Local0)
             Store(Local0, Index(BUFF, 0x14, ))
             Return(BUFF)
         }
         Method(WTV) {
             Return(\_SB.PCI0.SMB.OW00.WTV())
         }
         Method(WTR) {
             Return(\_SB.PCI0.SMB.OW00.WTR())
         }
         Method(WTQ) {
             Return(\_SB.PCI0.SMB.OW00.WTQ())
         }
         Method(WTC, 1) {
             Return(\_SB.PCI0.SMB.OW00.WTC(Arg0))
         }
         Method(WAQ) {
             Return(\_SB.PCI0.SMB.OW00.WAQ())
         }
         Method(WAC, 1) {
             Return(\_SB.PCI0.SMB.OW00.WAC(Arg0))
         }
     }
 }
 Scope(\_SB) {
     Name(ASFE, 0x00)
     Device(ASF) {
         Name(_HID, "ASF0001")
         Method(_STA) {
             Return(ASFE)
         }
         Method(GPWT) {
             Store(0xaf, \_SB.PCI0.LPC0.BCMD)
             Store(0x01, \_SB.PCI0.LPC0.DID)
             Store(Zero, \_SB.PCI0.LPC0.SMIC)
             Return(\_SB.PCI0.LPC0.INFO)
         }
         Method(SPWT, 1) {
             Store(0xaf, \_SB.PCI0.LPC0.BCMD)
             Store(0x02, \_SB.PCI0.LPC0.DID)
             Store(Arg0, \_SB.PCI0.LPC0.INFO)
             Store(Zero, \_SB.PCI0.LPC0.SMIC)
         }
     }
 }

 }
 /*
 SLIC: Length=3D374, Revision=3D1, Checksum=3D158,
 	OEMID=3DACRSYS, OEM Table ID=3DACRPRDCT, OEM Revision=3D0x6040000,
 	Creator ID=3DLOHR, Creator Revision=3D0x0
  */
 /*
 SSDT: Length=3D692, Revision=3D1, Checksum=3D43,
 	OEMID=3DPTLTD, OEM Table ID=3DPOWERNOW, OEM Revision=3D0x6040000,
 	Creator ID=3D LTP, Creator Revision=3D0x1
  */
 /*
 APIC: Length=3D94, Revision=3D1, Checksum=3D62,
 	OEMID=3DPTLTD, OEM Table ID=3D	 APIC, OEM Revision=3D0x6040000,
 	Creator ID=3D LTP, Creator Revision=3D0x0
  */
 /*
 MCFG: Length=3D60, Revision=3D1, Checksum=3D94,
 	OEMID=3DPTLTD, OEM Table ID=3D  MCFG, OEM Revision=3D0x6040000,
 	Creator ID=3D LTP, Creator Revision=3D0x0
  */
 /*
 HPET: Length=3D56, Revision=3D1, Checksum=3D154,
 	OEMID=3DPTLTD, OEM Table ID=3DHPETTBL, OEM Revision=3D0x6040000,
 	Creator ID=3D LTP, Creator Revision=3D0x1
  */
 /*
 ASF!: Length=3D299, Revision=3D32, Checksum=3D75,
 	OEMID=3D   DMA, OEM Table ID=3DAMDTBL, OEM Revision=3D0x6040000,
 	Creator ID=3DPTL, Creator Revision=3D0x1
  */

 --------------020902030803040906090409
 Content-Type: text/plain;
  name="acer5530.dmesg"
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline;
  filename="acer5530.dmesg"

 Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
     2006, 2007, 2008, 2009
     The NetBSD Foundation, Inc.  All rights reserved.
 Copyright (c) 1982, 1986, 1989, 1991, 1993
     The Regents of the University of California.  All rights reserved.

 NetBSD 5.99.16 (MONOLITHAMD64) #1: Fri Sep 11 21:45:24 EEST 2009
 	root@maailma.local:/local/scratch/build/nbsd-current/amd64/obj/sys/arch/amd64/compile/MONOLITHAMD64
 total memory = 2814 MB
 avail memory = 2714 MB
 timecounter: Timecounters tick every 10.000 msec
 timecounter: Timecounter "i8254" frequency 1193182 Hz quality 100
 Acer             Aspire 5530      (V1.11    )
 mainbus0 (root)
 cpu0 at mainbus0 apid 0: AMD 686-class, 1900MHz, id 0x200f31
 cpu1 at mainbus0 apid 1: AMD 686-class, 1900MHz, id 0x200f31
 ioapic0 at mainbus0 apid 2: pa 0xfec00000, version 21, 24 pins
 acpi0 at mainbus0: Intel ACPICA 20090730
 acpi0: X/RSDT: OemId <ACRSYS,ACRPRDCT,06040000>, AslId < LTP,00000000>
 acpi0: SCI interrupting at int 9
 acpi0: fixed-feature power button present
 timecounter: Timecounter "ACPI-Fast" frequency 3579545 Hz quality 1000
 ACPI-Fast 32-bit timer
 acpibut0 at acpi0 (PWRB, PNP0C0C): ACPI Power Button
 acpibut1 at acpi0 (SLPB, PNP0C0E): ACPI Sleep Button
 acpilid0 at acpi0 (LID, PNP0C0D): ACPI Lid Switch
 WMID (PNP0C14) at acpi0 not configured
 pcppi1 at acpi0 (SPKR, PNP0800): io 0x61
 sysbeep0 at pcppi1
 attimer1 at acpi0 (TIME, PNP0100): io 0x40-0x43 irq 0
 pckbc1 at acpi0 (KBC0, PNP0303) (kbd port): io 0x60,0x64 irq 1
 pckbc2 at acpi0 (MSE0, PNP0F13) (aux port): irq 12
 hpet0 at acpi0 (HPET, PNP0103): mem 0xfed00000-0xfed003ff
 timecounter: Timecounter "hpet0" frequency 14282292 Hz quality 2000
 acpiec0 at acpi0 (EC0, PNP0C09): io 0x62,0x66
 MIR (ENE0100) at acpi0 not configured
 acpiacad0 at acpi0 (ACAD, ACPI0003): ACPI AC Adapter
 acpibat0 at acpi0 (BAT1, PNP0C0A-1): ACPI Battery (Control Method)
 ACPI Warning for \_SB_.PCI0.LPC0.BAT1._BIF: Converted Buffer to expected String at index 9 (20090730/nsrepair-215)
 acpibat0: battery info: SANYO , Lion, AS07B31 0098
 acpitz0 at acpi0 (THRM): passive 42.0C, passive cooling
 acpitz1 at acpi0 (Z014): passive 0.0C, passive cooling
 attimer1: attached to pcppi1
 pckbd0 at pckbc1 (kbd slot)
 pckbc1: using irq 1 for kbd slot
 wskbd0 at pckbd0: console keyboard
 pms0 at pckbc1 (aux slot)
 pckbc1: using irq 12 for aux slot
 wsmouse0 at pms0 mux 0
 pci0 at mainbus0 bus 0: configuration mode 1
 pci0: i/o space, memory space enabled, rd/line, rd/mult, wr/inv ok
 pchb0 at pci0 dev 0 function 0: vendor 0x1022 product 0x9600 (rev. 0x00)
 ppb0 at pci0 dev 1 function 0: vendor 0x1025 product 0x9602 (rev. 0x00)
 pci1 at ppb0 bus 1
 pci1: i/o space, memory space enabled
 vga0 at pci1 dev 5 function 0: vendor 0x1002 product 0x9612 (rev. 0x00)
 wsdisplay0 at vga0 kbdmux 1: console (80x25, vt100 emulation), using wskbd0
 wsmux1: connecting to wsdisplay0
 radeondrm0 at vga0: ATI Radeon HD 3200 Graphics
 radeondrm0: Initialized radeon 1.29.0 20080613
 azalia0 at pci1 dev 5 function 1: Generic High Definition Audio Controller
 azalia0: interrupting at ioapic0 pin 19
 azalia0: host: 0x1002/0x960f (rev. 0), HDA rev. 1.0
 ppb1 at pci0 dev 4 function 0: vendor 0x1022 product 0x9604 (rev. 0x00)
 ppb1: unsupported PCI Express version
 pci2 at ppb1 bus 2
 pci2: no spaces enabled!
 ppb2 at pci0 dev 6 function 0: vendor 0x1022 product 0x9606 (rev. 0x00)
 ppb2: unsupported PCI Express version
 pci3 at ppb2 bus 5
 pci3: i/o space, memory space enabled, rd/line, wr/inv ok
 ath0 at pci3 dev 0 function 0
 ath0: interrupting at ioapic0 pin 18
 ath0: 11b rates: 1Mbps 2Mbps 5.5Mbps 11Mbps
 ath0: 11g rates: 1Mbps 2Mbps 5.5Mbps 11Mbps 6Mbps 9Mbps 12Mbps 18Mbps 24Mbps 36Mbps 48Mbps 54Mbps
 ath0: mac 14.2 phy 7.0 radio 10.2
 ppb3 at pci0 dev 7 function 0: vendor 0x1022 product 0x9607 (rev. 0x00)
 ppb3: unsupported PCI Express version
 pci4 at ppb3 bus 6
 pci4: i/o space, memory space enabled, rd/line, wr/inv ok
 bge0 at pci4 dev 0 function 0: Broadcom BCM5764 Gigabit Ethernet
 bge0: interrupting at ioapic0 pin 19
 bge0: chip id 5784100
 bge0: ASIC BCM5784 A1 (0x0578), Ethernet address 00:1e:ec:4a:5b:d1
 bge0: setting short Tx thresholds
 brgphy0 at bge0 phy 1: Broadcom BCM5764, rev. 4
 brgphy0: 10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, 1000baseT, 1000baseT-FDX, auto
 ppb4 at pci0 dev 9 function 0: vendor 0x1022 product 0x9608 (rev. 0x00)
 ppb4: unsupported PCI Express version
 pci5 at ppb4 bus 7
 pci5: i/o space, memory space enabled, rd/line, wr/inv ok
 ahcisata0 at pci0 dev 17 function 0: vendor 0x1002 product 0x4391
 ahcisata0: interrupting at ioapic0 pin 22
 ahcisata0: AHCI revision 1.1, 6 ports, 32 command slots, features 0xf722e080
 atabus0 at ahcisata0 channel 0
 atabus1 at ahcisata0 channel 1
 atabus2 at ahcisata0 channel 2
 atabus3 at ahcisata0 channel 3
 atabus4 at ahcisata0 channel 4
 atabus5 at ahcisata0 channel 5
 ohci0 at pci0 dev 18 function 0: vendor 0x1002 product 0x4397 (rev. 0x00)
 ohci0: interrupting at ioapic0 pin 16
 ohci0:  OHCI version 1.0, legacy support
 usb0 at ohci0: USB revision 1.0
 ohci1 at pci0 dev 18 function 1: vendor 0x1002 product 0x4398 (rev. 0x00)
 ohci1: interrupting at ioapic0 pin 16
 ohci1:  OHCI version 1.0, legacy support
 usb1 at ohci1: USB revision 1.0
 ehci0 at pci0 dev 18 function 2: vendor 0x1002 product 0x4396 (rev. 0x00)
 ehci0: applying AMD SB600/SB700 USB freeze workaround
 ehci0: interrupting at ioapic0 pin 17
 ehci0: dropped intr workaround enabled
 ehci0: EHCI version 1.0
 ehci0: companion controllers, 3 ports each: ohci0 ohci1
 usb2 at ehci0: USB revision 2.0
 ohci2 at pci0 dev 19 function 0: vendor 0x1002 product 0x4397 (rev. 0x00)
 ohci2: interrupting at ioapic0 pin 18
 ohci2:  OHCI version 1.0, legacy support
 usb3 at ohci2: USB revision 1.0
 ohci3 at pci0 dev 19 function 1: vendor 0x1002 product 0x4398 (rev. 0x00)
 ohci3: interrupting at ioapic0 pin 18
 ohci3:  OHCI version 1.0, legacy support
 usb4 at ohci3: USB revision 1.0
 ehci1 at pci0 dev 19 function 2: vendor 0x1002 product 0x4396 (rev. 0x00)
 ehci1: applying AMD SB600/SB700 USB freeze workaround
 ehci1: interrupting at ioapic0 pin 19
 ehci1: dropped intr workaround enabled
 ehci1: EHCI version 1.0
 ehci1: companion controllers, 3 ports each: ohci2 ohci3
 usb5 at ehci1: USB revision 2.0
 piixpm0 at pci0 dev 20 function 0
 piixpm0: vendor 0x1002 product 0x4385 (rev. 0x3a)
 piixpm0: interrupting at SMI, polling
 iic0 at piixpm0: I2C bus
 azalia1 at pci0 dev 20 function 2: Generic High Definition Audio Controller
 azalia1: interrupting at ioapic0 pin 16
 azalia1: host: 0x1002/0x4383 (rev. 0), HDA rev. 1.0
 pcib0 at pci0 dev 20 function 3: vendor 0x1002 product 0x439d (rev. 0x00)
 ppb5 at pci0 dev 20 function 4: vendor 0x1002 product 0x4384 (rev. 0x00)
 pci6 at ppb5 bus 8
 pci6: i/o space, memory space enabled
 pchb1 at pci0 dev 24 function 0: vendor 0x1022 product 0x1300 (rev. 0x40)
 pchb2 at pci0 dev 24 function 1: vendor 0x1022 product 0x1301 (rev. 0x00)
 pchb3 at pci0 dev 24 function 2: vendor 0x1022 product 0x1302 (rev. 0x00)
 amdtemp0 at pci0 dev 24 function 3: AMD CPU Temperature Sensors (Family10h / Family11h)
 pchb4 at pci0 dev 24 function 4: vendor 0x1022 product 0x1304 (rev. 0x00)
 isa0 at pcib0
 timecounter: Timecounter "clockinterrupt" frequency 100 Hz quality 0
 timecounter: Timecounter "TSC" frequency 1900853000 Hz quality 3000
 azalia0: codec[0]: ATI RS690/780 HDMI (rev. 0.0), HDA rev. 1.0
 audio0 at azalia0: full duplex, independent
 azalia1: codec[0]: Realtek ALC888 (rev. 2.2), HDA rev. 1.0
 azalia1: codec[1]: 0x14f1/0x2c06 (rev. 0.0), HDA rev. 1.0
 azalia1: codec[1]: No support for modem function groups
 azalia1: codec[1] has no audio function groups
 audio1 at azalia1: full duplex, independent
 uhub0 at usb0: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
 uhub0: 3 ports with 3 removable, self powered
 uhub1 at usb1: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
 uhub1: 3 ports with 3 removable, self powered
 uhub2 at usb2: vendor 0x1002 EHCI root hub, class 9/0, rev 2.00/1.00, addr 1
 uhub2: 6 ports with 6 removable, self powered
 uhub3 at usb3: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
 uhub3: 3 ports with 3 removable, self powered
 uhub4 at usb4: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
 uhub4: 3 ports with 3 removable, self powered
 uhub5 at usb5: vendor 0x1002 EHCI root hub, class 9/0, rev 2.00/1.00, addr 1
 uhub5: 6 ports with 6 removable, self powered
 acpiacad0: AC adapter online.
 ahcisata0 port 1: device present, speed: 1.5Gb/s
 ahcisata0 port 0: device present, speed: 1.5Gb/s
 wd0 at atabus0 drive 0: <WDC WD2500BEVS-22UST0>
 wd0: drive supports 16-sector PIO transfers, LBA48 addressing
 wd0: 232 GB, 484521 cyl, 16 head, 63 sec, 512 bytes/sect x 488397168 sectors
 wd0: drive supports PIO mode 4, DMA mode 2, Ultra-DMA mode 6 (Ultra/133)
 wd0(ahcisata0:0:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 6 (Ultra/133) (using DMA)
 atapibus0 at atabus1: 1 targets
 cd0 at atapibus0 drive 0: <Optiarc DVD RW AD-7560S, 30652610 1075062Q11, SX07> cdrom removable
 cd0: drive supports PIO mode 4, DMA mode 2, Ultra-DMA mode 5 (Ultra/100)
 cd0(ahcisata0:1:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 5 (Ultra/100) (using DMA)
 boot device: wd0
 root on wd0a dumps on wd0b
 root file system type: ffs
 WARNING: clock gained 2 days
 wsdisplay0: screen 1 added (80x25, vt100 emulation)
 wsdisplay0: screen 2 added (80x25, vt100 emulation)
 wsdisplay0: screen 3 added (80x25, vt100 emulation)
 wsdisplay0: screen 4 added (80x25, vt100 emulation)
 info: [drm] Setting GART location based on new memory map
 info: [drm] Loading RS780 Microcode
 info: [drm] Resetting GPU
 info: [drm] writeback test failed ffffffff deadbeef
 radeondrm0: interrupting at ioapic0 pin 18
 set{u,g}id pid 688 (gnome-pty-helper) was invoked by uid 1000 ppid 623 (Terminal) with fd 2 closed

 --------------020902030803040906090409--

From: Arto Huusko <arto.huusko@pp2.inet.fi>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/42051
Date: Wed, 16 Sep 2009 08:14:10 +0300

 After suspending and resuming the machine via lid switch, sysmon
 thread in kernel has wchan tstile. Stack trace for the thread is:

 trace: pid 0 lid 13 at 0xffff80004a0d6510
 sleepq_block() at netbsd:sleepq_block+0xcd
 turnstile_block() at netbsd:turnstile_block+0x223
 mutex_vector_enter() at netbsd:mutex_vector_enter+0x327
 acpiec_lock() at netbsd:acpiec_lock+0x1b
 acpiec_space_handler() at netbsd:acpiec_space_handler+0xd3
 AcpiEvAddressSpaceDispatch() at netbsd:AcpiEvAddressSpaceDispatch+0xc2
 AcpiExAccessRegion() at netbsd:AcpiExAccessRegion+0x162
 AcpiExFieldDatumIo() at netbsd:AcpiExFieldDatumIo+0xdc
 AcpiExWriteWithUpdateRule() at netbsd:AcpiExWriteWithUpdateRule+0xba
 AcpiExInsertIntoField() at netbsd:AcpiExInsertIntoField+0x1c0
 AcpiExWriteDataToField() at netbsd:AcpiExWriteDataToField+0x86
 AcpiExStoreObjectToNode() at netbsd:AcpiExStoreObjectToNode+0xd6
 AcpiExStore() at netbsd:AcpiExStore+0x159
 AcpiExOpcode_1A_1T_1R() at netbsd:AcpiExOpcode_1A_1T_1R+0x21b
 AcpiDsExecEndOp() at netbsd:AcpiDsExecEndOp+0x142
 AcpiPsParseLoop() at netbsd:AcpiPsParseLoop+0x25e
 AcpiPsParseAml() at netbsd:AcpiPsParseAml+0x1a6
 AcpiPsExecuteMethod() at netbsd:AcpiPsExecuteMethod+0x153
 AcpiNsEvaluate() at netbsd:AcpiNsEvaluate+0x1df
 AcpiEvaluateObject() at netbsd:AcpiEvaluateObject+0x99
 acpibat_update() at netbsd:acpibat_update+0x54
 acpibat_update_stat() at netbsd:acpibat_update_stat+0x37
 sysmon_task_queue_thread() at netbsd:sysmon_task_queue_thread+0x41


 When suspended manually from command line and resumed, sysmon is
 in its normal state smtaskq.

From: Makoto Fujiwara <makoto@ki.nu>
To: gnats-bugs@NetBSD.org
Cc: 
Subject: Re: kern/42051: lid switch works only once
Date: Mon, 09 Mar 2015 14:16:26 +0900

 I sent the very much similar PR, which is  closed (duplication).
   http://gnats.netbsd.org/49024

 ( And I did further testing, too.)
 | - suspending the machine by setting machdep.sleep_state=3
 |   from command line does not break lid switch. After suspending,
 |   and resuming, the lid switch works, but only once again.
 As is written in following URL,
 I'm observing differrently.
    sysctl -w hw.acpi.sleep.state=3
 is the point not to sleep by lid_close.

 http://www.ki.nu/software/acpi/lid_sw.html
 ------------------------------------------
 @ lid_sw
   1. Stop powerd (see /etc/defaults/rc.conf, powerd may be "YES" by following
      lines)
         if /sbin/sysctl -q hw.acpi.root; then
                 powerd=YES
         fi
      To disable powerd on boot, you need to say following in /etc/rc.conf
         powerd= NO

   2. Build kernel with following debug print:

      Index: sys/dev/acpi/acpi_lid.c
      ===================================================================
      RCS file: /cvs/cvsroot/src/sys/dev/acpi/acpi_lid.c,v
      retrieving revision 1.43
      diff -u -r1.43 acpi_lid.c
      --- sys/dev/acpi/acpi_lid.c     16 Feb 2011 08:35:51 -0000      1.43
      +++ sys/dev/acpi/acpi_lid.c     8 Mar 2015 13:52:53 -0000
      @@ -158,7 +158,7 @@
       {
              static const int handler = OSL_NOTIFY_HANDLER;
              device_t dv = context;
      -
      +       aprint_normal("notify 0x%02X\n", notify);
              switch (notify) {

              case ACPI_NOTIFY_LID:

   3. above line is any times active whenever open and close lid.
      (Assuming powerd is not running).
   4. Then start powerd.
      It will get sleep only once.
      Another open/close lid won't give item 2 debug print anymore.

 @ powerd or script

  powerd invokes /etc/powerd/scripts/lid_switch
  Let me decide which is harmfull, powerd itself or script invoked.
  Try disabling sleep line in script. just not to issue following line
  (Have # char in the beginning the line)

    #       sysctl -w hw.acpi.sleep.state=3

  Then repeating lid open/close anytimes. Every time you do you may have
  following print out:
  (If kernel is configured with 'options ACPI_DEBUG')

  $dhcpd is not enabled - see rc.conf(5).
  Use the following if you wish to perform the operation:
    /etc/rc.d/dhcpd onestart
  err: /etc/powerd/scripts/lid_switch exited with status 1dispatch_dev_power: even
  t type 0
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.
  com/DTDs/PropertyList-1.0.dtd">
  <plist version="1.0">
  <dict>
          <key>driver-name</key>
          <string>acpilid0</string>
          <key>power-type</key>
          <string>pswitch</string>
          <key>powerd-event-name</key>
          <string>released</string>
          <key>powerd-script-name</key>
          <string>lid_switch</string>
  </dict>
  </plist>
  running script: /etc/powerd/scripts/lid_switch acpilid0 released
  wsconsctl: WSDISPLAYIO_PARAM_BACKLIGHT: Inappropriate ioctl for device


 @ sysctl -w is the point of problem
   1. reboot
   2. make sure powerd is not running
   3. issue following command
        sysctl -w hw.acpi.sleep.state=3
   4. run powerd
   5. close lid

  This procedure won't give sleep. Step 3. above is the harmful point.

  Last Update: Mon, 09 Mar 2015 04:51:47 GMT

NetBSD Home
NetBSD PR Database Search

(Contact us) $NetBSD: query-full-pr,v 1.39 2013/11/01 18:47:49 spz Exp $
$NetBSD: gnats_config.sh,v 1.8 2006/05/07 09:23:38 tsutsui Exp $
Copyright © 1994-2007 The NetBSD Foundation, Inc. ALL RIGHTS RESERVED.