From owner-acpi-jp@jp.freebsd.org  Mon Mar  5 20:06:38 2001
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id UAA01422;
	Mon, 5 Mar 2001 20:06:38 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from webcom.it (brian.inet.it [213.92.4.195])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with SMTP id UAA01402
	for <acpi-jp@jp.freebsd.org>; Mon, 5 Mar 2001 20:06:31 +0900 (JST)
	(envelope-from andrea@webcom.it)
Received: (qmail 732 invoked by uid 1000); 5 Mar 2001 11:02:00 -0000
Date: Mon, 5 Mar 2001 12:01:59 +0100
From: Andrea Campi <andrea@webcom.it>
To: acpi-jp@jp.freebsd.org
Cc: msmith@FreeBSD.org
Message-ID: <20010305120159.A535@webcom.it>
References: <20010304163716.A514@webcom.it>
Mime-Version: 1.0
Content-Type: multipart/mixed; boundary="dDRMvlgZJXvWKvBx"
Content-Disposition: inline
User-Agent: Mutt/1.2.5i
In-Reply-To: <20010304163716.A514@webcom.it>; from andrea@webcom.it on Sun, Mar 04, 2001 at 04:37:17PM +0100
X-Echelon: BND CIA NSA Mossad KGB MI6 IRA detonator nuclear assault strike
Reply-To: acpi-jp@jp.freebsd.org
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+000315
X-Sequence: acpi-jp 1081
Subject: [acpi-jp 1081] Re: Bug in battery support in IBM Thinkpad?
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: andrea@webcom.it


--dDRMvlgZJXvWKvBx
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable

Ok, I came up with a patch that fixes the issue for me. I am almost sure th=
is
issue must plague all IBM Thinkpad owners, so I ask ACPI experts to please
review this, and I would be really happy if anybody would commit this. That=
 is,
unless anybody can come up with something better - but at least now I can g=
et
ACPI to work.

Bye,
	Andrea


On Sun, Mar 04, 2001 at 04:37:17PM +0100, Andrea Campi wrote:
> Ok, I finally found time to play with ACPI again on my laptop (Thinkpad 5=
70E),
> -current as of yesterday. The stupid thing used to panic just after:
>=20
> acpi0: <PTLTD    RSDT  > on motherboard
> acpi0: power button is handled as a fixed feature programming model.
> acpi_tz0: <thermal zone> on acpi0
> acpi_acad0: <AC adapter> on acpi0
> acpi_acad0: On Line
> acpi_cmbat0: <Control method Battery> on acpi0
>=20
> After a good amount of fighting, I wasn't able to solve the issue in a pr=
oper
> way (3:30 AM), so I came up with a very bogus patch:
>=20
> --- acpi_cmbat.c.orig   Sun Mar  4 16:29:00 2001
> +++ acpi_cmbat.c        Sun Mar  4 16:28:38 2001
> @@ -136,6 +136,7 @@
>         }
>         res =3D sc->bst_buffer.Pointer;
> +       return;
>         if ((res->Type !=3D ACPI_TYPE_PACKAGE) && (res->Package.Count < 4=
))
>                 return ;
> @@ -186,6 +187,7 @@
>         }
>         res =3D sc->bif_buffer.Pointer;
> +       return;
>         if ((res->Type !=3D ACPI_TYPE_PACKAGE) && (res->Package.Count < 1=
3))
>                 return ;
>=20
>=20
> This allowed me to boot fine, showing:
>=20
> acpi0: <PTLTD    RSDT  > on motherboard
> acpi0: power button is handled as a fixed feature programming model.
> acpi_tz0: <thermal zone> on acpi0
> acpi_acad0: <AC adapter> on acpi0
> acpi_acad0: On Line
> acpi_cmbat0: <Control method Battery> on acpi0
> acpi_cmbat1: <Control method Battery> on acpi0
> acpi_lid0: <Control Method Lid Switch> on acpi0
> acpi_button0: <Control Method Sleep Button Device> on acpi0
> acpi_pcib0: <Host-PCI bridge> on acpi0
> pci0: <PCI bus> on acpi_pcib0
>=20
> even though I only really have 1 battery.
>=20
> The reason for the panic is of course a null pointer dereference just bel=
ow
> the return I added:
>=20
>         movl -16(%ebp),%edx
>         movl 8(%edx),%esi
>         cmpl $1,(%esi)			<<<<<<<< panic
>         jne .L982
>=20
> I wasn't able to understand the problem so I guess it's my ACPI ASL or wh=
atever
> fault.  I am attaching acpidump output, even if it's in the archive alrea=
dy, in
> case anybody wants to have a look.
>=20
>=20
> Even after managing to boot, this:
>=20
> # acpiconf -e
> # acpiconf -s 1
>=20
> only gets white flashing over my display and:
>=20
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[11]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[14]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[15]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[16]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[18]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[19]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[1c]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[1d]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[1e]
> evevent-0945: *** Error: AcpiEvGpeDispatch: No installed handler for GPE =
[1f]
>=20
> but I guess this will have to wait...
>=20
>=20
> TIA, bye,
> 	Andrea
>=20
>=20
> --=20
>                I believe the technical term is "Oops!"

> RSD PTR: Checksum=3D52, OEMID=3DPTLTD, RsdtAddress=3D0x03ffaa59
> RSDT: Lenth=3D44, Revision=3D1, Checksum=3D223,
> 	OEMID=3DPTLTD, OEM Table ID=3D  RSDT, OEM Revision=3D0x6040000,
> 	Creator ID=3D LTP, Creator Revision=3D0x0
> 	Entries=3D{ 0x03fffb65, 0x03fffbd9 }
> 	DSDT=3D0x3ffaa85
> 	INT_MODEL=3DPIC
> 	SCI_INT=3D9
> 	SMI_CMD=3D0xb2, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1, S4BIOS_REQ=3D0x=
f2
> 	PM1a_EVT_BLK=3D0x1000-0x1003
> 	PM1a_CNT_BLK=3D0x1004-0x1005
> 	PM2_CNT_BLK=3D0x22-0x22
> 	PM2_TMR_BLK=3D0x1008-0x100b
> 	PM2_GPE0_BLK=3D0x100c-0x100f
> 	P_LVL2_LAT=3D10ms, P_LVL3_LAT=3D20ms
> 	FLUSH_SIZE=3D0, FLUSH_STRIDE=3D0
> 	DUTY_OFFSET=3D1, DUTY_WIDTH=3D3
> 	DAY_ALRM=3D13, MON_ALRM=3D0, CENTURY=3D50
> 	Flags=3D{WBINVD,SLP_BUTTON,RTC_S4,DCK_CAP}
> DSDT: Lenth=3D20704, Revision=3D1, Checksum=3D186,
> 	OEMID=3DIBM, OEM Table ID=3DVIPER, OEM Revision=3D0x6040000,
> 	Creator ID=3DMSFT, Creator Revision=3D0x1000004
> Name(_S0_, Package(0x2) {
>     0x5,
>     0x5,
> })
> Name(_S1_, Package(0x2) {
>     0x4,
>     0x4,
> })
> Name(_S3_, Package(0x2) {
>     0x1,
>     0x1,
> })
> Name(_S4_, Package(0x2) {
>     0x0,
>     0x0,
> })
> Name(_S5_, Package(0x2) {
>     0x0,
>     0x0,
> })
> Scope(_PR_) {
>     Processor(CPU_, 0, 0x1010, 0x6) {
>     }
> }
> Scope(_SI_) {
>     Method(_SST, 1) {
>         If(LEqual(Arg0, 0x0)) {
>             If(LEqual(\SSLV, 0x0)) {
>                 \_SB_.PCI_.ISA_.EC__.SLED
>                 0x80
>                 0x0
>                 \_SB_.PCI_.ISA_.EC__.SLED
>                 0x1
>                 0x0
>             }
>             \_SB_.PCI_.ISA_.EC__.BEEP
>             0x7
>             0x0
>         }
>         If(LEqual(Arg0, 0x1)) {
>             \_SB_.PCI_.ISA_.EC__.SLED
>             0x80
>             0x0
>             \_SB_.PCI_.ISA_.EC__.SLED
>             0x1
>             0x1
>             If(LNot(LEqual(\SSLV, 0x0))) {
>                 \_SB_.PCI_.ISA_.EC__.BEEP
>                 0x5
>                 0x0
>             }
>         }
>         If(LEqual(Arg0, 0x3)) {
>             If(LOr(LEqual(\SSLV, 0x3), LEqual(\SSLV, 0x0))) {
>                 \_SB_.PCI_.ISA_.EC__.SLED
>                 0x1
>                 0x0
>             }
>             \_SB_.PCI_.ISA_.EC__.SLED
>             0x80
>             0x1
>             \_SB_.PCI_.ISA_.EC__.BEEP
>             0x3
>             0x0
>         }
>         If(LEqual(Arg0, 0x4)) {
>             If(LOr(LEqual(\SSLV, 0x3), LEqual(\SSLV, 0x0))) {
>                 \_SB_.PCI_.ISA_.EC__.SLED
>                 0x1
>                 0x0
>             }
>             \_SB_.PCI_.ISA_.EC__.SLED
>             0x80
>             0x0
>             \_SB_.PCI_.ISA_.EC__.BEEP
>             0x3
>             0x0
>         }
>     }
> }
> Scope(_TZ_) {
>     ThermalZone(THM0) {
>         Name(_TC1, 0x1)
>         Name(_TC2, 0x3)
>         Name(_TSP, 0x012c)
>         Method(_CRT) {
>             Return(CRTL)
>         }
>         Method(_PSV) {
>             If(\_SB_.PCI_.PWR_.THTE) {
>                 Return(PSVL)
>             }
>             Else {
>                 Return(PSVH)
>             }
>         }
>         Method(_AC0) {
>             If(And(\_SB_.PCI_.ISA_.EC__.GFAN, 0x7, )) {
>                 Return(AC0L)
>             }
>             Else {
>                 Return(AC0H)
>             }
>         }
>         Method(_TMP) {
>             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local0)
>             0x4
>             Local0
>             CreateWordField(Local0, 0x0, TMP0)
>             Store(TMP0, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.GTHZ, Local1)
>             If(LEqual(Local1, 0x0)) {
>                 If(LNot(LLess(Local0, AC0L))) {
>                     Store(AC0L, Local0)
>                     Subtract(Local0, 0x5, )
>                 }
>             }
>             If(And(Local1, 0x1, )) {
>                 If(LNot(LGreater(Local0, AC0L))) {
>                     Store(AC0H, Local0)
>                     Add(Local0, 0x5, )
>                 }
>             }
>             If(And(Local1, 0x2, )) {
>                 If(LNot(LGreater(Local0, PSVL))) {
>                     Store(PSVH, Local0)
>                     Add(Local0, 0x5, )
>                 }
>             }
>             Return(Local0)
>         }
>         Method(_SCP, 1) {
>             Notify(\_TZ_.THM0, 0x81)
>         }
>         Name(_AL0, Package(0x1) {
>             FAN_,
>         })
>         Name(_PSL, Package(0x1) {
>             \_PR_.CPU_,
>         })
>         Name(CRTL, 0x0e94)
>         Name(PSVH, 0x0e30)
>         Name(PSVL, 0x0e30)
>         Name(AC0H, 0x0d5e)
>         Name(AC0L, 0x0d36)
>     }
>     PowerResource(FANP, 0, 0) {
>         Method(_STA) {
>             If(And(\_SB_.PCI_.ISA_.EC__.GFAN, 0x7, )) {
>                 Return(0x1)
>             }
>             Else {
>                 Return(0x0)
>             }
>         }
>         Method(_ON_) {
>             \_SB_.PCI_.ISA_.EC__.SFAN
>             0x7
>         }
>         Method(_OFF) {
>             \_SB_.PCI_.ISA_.EC__.SFAN
>             0x0
>         }
>     }
>     Device(FAN_) {
>         Name(_HID, 0x0b0cd041)
>         Name(_PR0, Package(0x1) {
>             FANP,
>         })
>     }
> }
> Scope(_GPE) {
>     Method(_L00) {
>         Not(\_SB_.PCI_.PWR_.TPOL, \_SB_.PCI_.PWR_.TPOL)
>     }
>     Method(_L08) {
>         Notify(\_SB_.PCI_.USB_, 0x2)
>     }
>     Method(_L09) {
>         Store(\_SB_.PCI_.ISA_.EC__.ECQE, Local0)
>         While(Local0) {
>             If(LEqual(Local0, 0x11)) {
>                 \_SB_.PCI_.ISA_.EC__._Q11
>             }
>             If(LEqual(Local0, 0x13)) {
>                 \_SB_.PCI_.ISA_.EC__._Q13
>             }
>             If(LEqual(Local0, 0x16)) {
>                 \_SB_.PCI_.ISA_.EC__._Q16
>             }
>             If(LEqual(Local0, 0x17)) {
>                 \_SB_.PCI_.ISA_.EC__._Q17
>             }
>             If(LEqual(Local0, 0x1b)) {
>                 \_SB_.PCI_.ISA_.EC__._Q1B
>             }
>             If(LEqual(Local0, 0x1c)) {
>                 \_SB_.PCI_.ISA_.EC__._Q1C
>             }
>             If(LEqual(Local0, 0x1d)) {
>                 \_SB_.PCI_.ISA_.EC__._Q1D
>             }
>             If(LEqual(Local0, 0x1e)) {
>                 \_SB_.PCI_.ISA_.EC__._Q1E
>             }
>             If(LEqual(Local0, 0x20)) {
>                 \_SB_.PCI_.ISA_.EC__._Q20
>             }
>             If(LEqual(Local0, 0x21)) {
>                 \_SB_.PCI_.ISA_.EC__._Q21
>             }
>             If(LEqual(Local0, 0x22)) {
>                 \_SB_.PCI_.ISA_.EC__._Q22
>             }
>             If(LEqual(Local0, 0x23)) {
>                 \_SB_.PCI_.ISA_.EC__._Q23
>             }
>             If(LEqual(Local0, 0x24)) {
>                 \_SB_.PCI_.ISA_.EC__._Q24
>             }
>             If(LEqual(Local0, 0x25)) {
>                 \_SB_.PCI_.ISA_.EC__._Q25
>             }
>             If(LEqual(Local0, 0x26)) {
>                 \_SB_.PCI_.ISA_.EC__._Q26
>             }
>             If(LEqual(Local0, 0x27)) {
>                 \_SB_.PCI_.ISA_.EC__._Q27
>             }
>             If(LEqual(Local0, 0x2a)) {
>                 \_SB_.PCI_.ISA_.EC__._Q2A
>             }
>             If(LEqual(Local0, 0x2b)) {
>                 \_SB_.PCI_.ISA_.EC__._Q2B
>             }
>             If(LEqual(Local0, 0x30)) {
>                 \_SB_.PCI_.ISA_.EC__._Q30
>             }
>             If(LEqual(Local0, 0x31)) {
>                 \_SB_.PCI_.ISA_.EC__._Q31
>             }
>             If(LEqual(Local0, 0x32)) {
>                 \_SB_.PCI_.ISA_.EC__._Q32
>             }
>             If(LEqual(Local0, 0x37)) {
>                 \_SB_.PCI_.ISA_.EC__._Q37
>             }
>             If(LEqual(Local0, 0x39)) {
>                 \_SB_.PCI_.ISA_.EC__._Q39
>             }
>             If(LEqual(Local0, 0x3e)) {
>                 \_SB_.PCI_.ISA_.EC__._Q3E
>             }
>             If(LEqual(Local0, 0x40)) {
>                 \_SB_.PCI_.ISA_.EC__._Q40
>             }
>             If(LEqual(Local0, 0x50)) {
>                 \_SB_.PCI_.ISA_.EC__._Q50
>             }
>             If(LEqual(Local0, 0x51)) {
>                 \_SB_.PCI_.ISA_.EC__._Q51
>             }
>             If(LEqual(Local0, 0x52)) {
>                 \_SB_.PCI_.ISA_.EC__._Q52
>             }
>             If(LEqual(Local0, 0x53)) {
>                 \_SB_.PCI_.ISA_.EC__._Q53
>             }
>             Store(\_SB_.PCI_.ISA_.EC__.ECQE, Local0)
>         }
>     }
>     Method(_L0B) {
>         Store(\_SB_.PCI_.ISA_.EC__.GWES, Local0)
>         If(And(Local0, 0x1, )) {
>             Notify(\_SB_.PCI_, 0x2)
>             \_SB_.PCI_.ISA_.EC__.GWES
>         }
>         If(And(Local0, 0x2, )) {
>             Notify(\_SB_.LID_, 0x80)
>         }
>         If(And(Local0, 0x4, )) {
>             Notify(\_SB_.SLPB, 0x2)
>         }
>         If(And(Local0, 0x8, )) {
>             Notify(\_SB_.PCI_.MODM, 0x2)
>         }
>         If(And(Local0, 0x10, )) {
>             Notify(\_SB_.SLPB, 0x2)
>             \_SB_.PCI_.ISA_.EC__._Q50
>         }
>         If(And(Local0, 0x20, )) {
>             Notify(\_SB_.SLPB, 0x2)
>             \_SB_.PCI_.ISA_.EC__._Q51
>         }
>     }
> }
> Scope(_SB_) {
>     OperationRegion(PHSD, SystemMemory, 0x03fffebc, 0x00000100)
>     Field(PHSD, AnyAcc, NoLock, Preserve) {
>         BCMD,	8,
>         DID_,	32,
>         INFO,	2000
>     }
>     Field(PHSD, AnyAcc, NoLock, Preserve) {
>         Offset(0x5),
>         INF_,	8
>     }
>     Field(PHSD, AnyAcc, NoLock, Preserve) {
>         Offset(0x5),
>         INF2,	1024
>     }
>     OperationRegion(PHSI, SystemIO, 0x0000fe00, 0x00000002)
>     Field(PHSI, AnyAcc, NoLock, Preserve) {
>         SMIC,	8
>     }
>     Mutex(MPHS, 0)
>     Method(PSCS, 1, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(Zero, INFO)
>         Store(0x0, BCMD)
>         Store(Arg0, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Store(INFO, Local0)
>         Release(MPHS)
>         Return(Local0)
>     }
>     Method(PSSS, 2, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(0x1, BCMD)
>         Store(Arg0, DID_)
>         Store(Arg1, INFO)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Release(MPHS)
>     }
>     Method(PSPS, 1, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(0x0, INFO)
>         Store(0x2, BCMD)
>         Store(Arg0, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Store(INFO, Local0)
>         Release(MPHS)
>         Return(Local0)
>     }
>     Method(PSDI, 1, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(0x3, BCMD)
>         Store(Arg0, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Release(MPHS)
>     }
>     Method(PSST, 1, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(0x0, INF_)
>         Store(0x4, BCMD)
>         Store(Arg0, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Store(INF_, Local0)
>         Release(MPHS)
>         Return(Local0)
>     }
>     Method(PHS_, 1, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(Arg0, BCMD)
>         Store(Zero, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Store(INF_, Local0)
>         Release(MPHS)
>         Return(Local0)
>     }
>     Method(PHS2, 2, Serialized) {
>         Acquire(MPHS, 0xffff)
>         Store(Arg0, BCMD)
>         Store(Arg1, INF_)
>         Store(Zero, DID_)
>         Store(Zero, SMIC)
>         While(Not(DID_, )) {
>             Sleep(0x2)
>         }
>         Store(Zero, BCMD)
>         Store(Zero, DID_)
>         Store(INF2, Local0)
>         Release(MPHS)
>         Return(Local0)
>     }
>     Device(AC__) {
>         Name(_HID, "ACPI0003")
>         Name(_STA, 0xf)
>         Name(_PCL, Package(0x1) {
>             \_SB_,
>         })
>         Method(_PSR) {
>             Return(\_SB_.PCI_.ISA_.EC__.ACST)
>         }
>     }
>     Device(BAT1) {
>         Name(_HID, 0x0a0cd041)
>         Name(_UID, 0x1)
>         Name(BIFB, Package(0xd) {
>             0x0,
>             0xffffffff,
>             0xffffffff,
>             0x1,
>             0x2a30,
>             0x0,
>             0x0,
>             0x0,
>             0x1,
>             "",
>             "",
>             "",
>             "",
>         })
>         Name(BSTB, Package(0x4) {
>             0x0,
>             0xffffffff,
>             0xffffffff,
>             0xffffffff,
>         })
>         Name(_PCL, Package(0x1) {
>             \_SB_,
>         })
>         Name(_STA, 0xf)
>         Method(_BIF) {
>             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local0)
>             0x10
>             Local0
>             CreateByteField(Local0, 0x0, PWUT)
>             CreateDWordField(Local0, 0x4, DCAP)
>             CreateDWordField(Local0, 0x8, FCAP)
>             CreateWordField(Local0, 0x10, VOLT)
>             If(LEqual(PWUT, 0xff)) {
>                 Store(0x0, Index(BIFB, 0x0, ))
>                 Store(0xffffffff, Index(BIFB, 0x1, ))
>                 Store(0xffffffff, Index(BIFB, 0x2, ))
>                 Store(0x0, Index(BIFB, 0x5, ))
>                 Store(0x0, Index(BIFB, 0x6, ))
>             }
>             Else {
>                 Store(PWUT, Index(BIFB, 0x0, ))
>                 Store(DCAP, Index(BIFB, 0x1, ))
>                 Store(FCAP, Index(BIFB, 0x2, ))
>                 Store(Divide(DCAP, 0xa, , ), Index(BIFB, 0x5, ))
>                 Store(Divide(DCAP, 0x14, , ), Index(BIFB, 0x6, ))
>             }
>             Store("LION", Index(BIFB, 0xb, ))
>             Return(BIFB)
>         }
>         Method(_BST) {
>             Store(Zero, Local0)
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x0, 0x40)) {
>                 Zero
>                 Or(0x1, Local0, Local0)
>             }
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x0, 0x20)) {
>                 Zero
>                 Or(0x2, Local0, Local0)
>             }
>             If(LNot(LGreater(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x0, 0xf), Ze=
ro))) {
>                 0x3
>                 Or(0x4, Local0, Local0)
>             }
>             Store(Local0, Index(BSTB, 0x0, ))
>             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local0)
>             0x10
>             Local0
>             CreateByteField(Local0, 0x0, PWUT)
>             CreateDWordField(Local0, 0xc, CAPA)
>             CreateWordField(Local0, 0x10, VOLT)
>             CreateWordField(Local0, 0x12, CURR)
>             And(CURR, 0xff00, Local1)
>             If(LNot(LLess(Local1, 0x8000))) {
>                 Subtract(0x00010000, Local1, Local1)
>             }
>             If(LEqual(PWUT, 0x0)) {
>                 Store(Divide(Multiply(Local1, VOLT, ), 0x03e8, , ), Index=
(BSTB, 0x1, ))
>             }
>             Else {
>                 If(LEqual(PWUT, 0x1)) {
>                     Store(Local1, Index(BSTB, 0x1, ))
>                 }
>                 Else {
>                     If(LEqual(PWUT, 0xff)) {
>                         Store(0xffffffff, Index(BSTB, 0x1, ))
>                     }
>                 }
>             }
>             Store(CAPA, Index(BSTB, 0x2, ))
>             Store(VOLT, Index(BSTB, 0x3, ))
>             Return(BSTB)
>         }
>         Method(_INI) {
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x0, 0x80)) {
>                 Zero
>                 Store(0x1f, \_SB_.BAT1._STA)
>             }
>         }
>     }
>     Device(BAT2) {
>         Name(_HID, 0x0a0cd041)
>         Name(_UID, 0x2)
>         Name(BIFB, Package(0xd) {
>             0x0,
>             0xffffffff,
>             0xffffffff,
>             0x1,
>             0x2a30,
>             0x0,
>             0x0,
>             0x0,
>             0x1,
>             "",
>             "",
>             "",
>             "",
>         })
>         Name(BSTB, Package(0x4) {
>             0x0,
>             0xffffffff,
>             0xffffffff,
>             0xffffffff,
>         })
>         Name(_PCL, Package(0x1) {
>             \_SB_,
>         })
>         Name(_STA, 0xf)
>         Method(_BIF) {
>             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local0)
>             0x11
>             Local0
>             CreateByteField(Local0, 0x0, PWUT)
>             CreateDWordField(Local0, 0x4, DCAP)
>             CreateDWordField(Local0, 0x8, FCAP)
>             CreateWordField(Local0, 0x10, VOLT)
>             If(LEqual(PWUT, 0xff)) {
>                 Store(0x0, Index(BIFB, 0x0, ))
>                 Store(0xffffffff, Index(BIFB, 0x1, ))
>                 Store(0xffffffff, Index(BIFB, 0x2, ))
>                 Store(0x0, Index(BIFB, 0x5, ))
>                 Store(0x0, Index(BIFB, 0x6, ))
>             }
>             Else {
>                 Store(PWUT, Index(BIFB, 0x0, ))
>                 Store(DCAP, Index(BIFB, 0x1, ))
>                 Store(FCAP, Index(BIFB, 0x2, ))
>                 Store(Divide(DCAP, 0xa, , ), Index(BIFB, 0x5, ))
>                 Store(Divide(DCAP, 0x14, , ), Index(BIFB, 0x6, ))
>             }
>             Store("LION", Index(BIFB, 0xb, ))
>             Return(BIFB)
>         }
>         Method(_BST) {
>             Store(Zero, Local0)
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x40)) {
>                 Zero
>                 Or(0x1, Local0, Local0)
>             }
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x20)) {
>                 Zero
>                 Or(0x2, Local0, Local0)
>             }
>             If(LNot(LGreater(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0xf), Ze=
ro))) {
>                 0x3
>                 Or(0x4, Local0, Local0)
>             }
>             Store(Local0, Index(BSTB, 0x0, ))
>             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local0)
>             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local0)
>             0x11
>             Local0
>             CreateByteField(Local0, 0x0, PWUT)
>             CreateDWordField(Local0, 0xc, CAPA)
>             CreateWordField(Local0, 0x10, VOLT)
>             CreateWordField(Local0, 0x12, CURR)
>             If(LNot(LLess(CURR, 0x8000))) {
>                 Store(Subtract(0x00010000, CURR, ), Local1)
>             }
>             Else {
>                 Store(CURR, Local1)
>             }
>             If(LEqual(PWUT, 0x0)) {
>                 Store(Divide(Multiply(Local1, VOLT, ), 0x03e8, , ), Index=
(BSTB, 0x1, ))
>             }
>             Else {
>                 If(LEqual(PWUT, 0x1)) {
>                     Store(Local1, Index(BSTB, 0x1, ))
>                 }
>                 Else {
>                     If(LEqual(PWUT, 0xff)) {
>                         Store(0xffffffff, Index(BSTB, 0x1, ))
>                     }
>                 }
>             }
>             Store(CAPA, Index(BSTB, 0x2, ))
>             Store(VOLT, Index(BSTB, 0x3, ))
>             Return(BSTB)
>         }
>         Method(_INI) {
>             If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x80)) {
>                 Zero
>                 Store(0x1f, \_SB_.BAT2._STA)
>             }
>         }
>     }
>     Device(LID_) {
>         Name(_HID, 0x0d0cd041)
>         Name(_STA, 0xf)
>         Name(_PRW, Package(0x2) {
>             0xb,
>             0x4,
>         })
>         Method(_LID) {
>             Return(\_SB_.PCI_.ISA_.EC__.GLID)
>         }
>     }
>     Device(SLPB) {
>         Name(_HID, 0x0e0cd041)
>         Name(_STA, 0xf)
>         Name(_PRW, Package(0x2) {
>             0xb,
>             0x4,
>         })
>     }
>     Device(PCI_) {
>         Name(_HID, 0x030ad041)
>         Name(_BBN, 0x0)
>         Name(_ADR, 0x0)
>         OperationRegion(REGS, PCI_Config, 0x40, 0xc0)
>         Field(REGS, DWordAcc, NoLock, Preserve) {
>             Offset(0x19),
>             PAM0,	8,
>             PAM1,	8,
>             PAM2,	8,
>             PAM3,	8,
>             PAM4,	8,
>             PAM5,	8,
>             PAM6,	8,
>             DRB0,	8,
>             DRB1,	8,
>             DRB2,	8,
>             DRB3,	8,
>             DRB4,	8,
>             DRB5,	8,
>             DRB6,	8,
>             DRB7,	8,
>             ,	6,
>             HEN_,	2,
>             Offset(0x33),
>             T_EN,	1,
>             T_SZ,	2,
>             Offset(0x3a),
>             CRST,	1
>         }
>         Name(RSRC, Buffer(0x01d2) {0x88, 0xe, 0x0, 0x2, 0xc, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8=
, 0xc, 0x1, 0x8, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0=
xc, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0,=
 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0=
x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xc=
, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, =
0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xc, 0x0, 0x=
ff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x1=
8, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xc, 0x0, 0xff, 0xff,=
 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0=
x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 0x0,=
 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0=
x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0xe, 0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, =
0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x=
e, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0,=
 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xe, 0x0, 0=
xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x=
18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0, 0xff, 0xff=
, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, =
0x0, 0xc, 0x3, 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, 0xc, 0x3=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x=
0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
>         Method(_CRS, 0, Serialized) {
>             Store(Zero, Local1)
>             If(T_EN) {
>                 ShiftLeft(0x1, Add(T_SZ, 0x11, ), Local1)
>             }
>             CreateDWordField(RSRC, 0x0193, BTMN)
>             CreateDWordField(RSRC, 0x0197, BTMX)
>             CreateDWordField(RSRC, 0x019f, BTLN)
>             Multiply(DRB7, 0x00800000, Local0)
>             If(T_EN) {
>                 Subtract(Local0, Local1, Local2)
>                 Store(Local2, BTMN)
>                 Subtract(Add(Local0, 0x10000000, ), BTMN, BTLN)
>             }
>             Else {
>                 Store(Local0, BTMN)
>                 Subtract(0xffe00000, Local0, BTLN)
>                 Subtract(Add(BTMN, BTLN, ), 0x1, BTMX)
>             }
>             CreateDWordField(RSRC, 0x01ae, ATMN)
>             CreateDWordField(RSRC, 0x01b2, ATMX)
>             CreateDWordField(RSRC, 0x01ba, ATLN)
>             If(T_EN) {
>                 Add(Add(BTMN, BTLN, ), Local1, ATMN)
>                 Subtract(0xffe00000, ATMN, ATLN)
>                 Subtract(Add(ATMN, ATLN, ), 0x1, ATMX)
>             }
>             Else {
>                 Store(Zero, ATLN)
>             }
>             CreateBitField(RSRC, 0x0250, C0RW)
>             CreateDWordField(RSRC, 0x4f, C0MN)
>             CreateDWordField(RSRC, 0x53, C0MX)
>             CreateDWordField(RSRC, 0x5b, C0LN)
>             Store(One, C0RW)
>             If(LEqual(And(PAM1, 0x3, ), 0x1)) {
>                 Store(Zero, C0RW)
>             }
>             Store(Zero, C0LN)
>             If(LNot(And(PAM1, 0x3, ))) {
>                 Store(0x4000, C0LN)
>             }
>             CreateBitField(RSRC, 0x0328, C4RW)
>             CreateDWordField(RSRC, 0x6a, C4MN)
>             CreateDWordField(RSRC, 0x6e, C4MX)
>             CreateDWordField(RSRC, 0x76, C4LN)
>             Store(One, C4RW)
>             If(LEqual(And(PAM1, 0x30, ), 0x10)) {
>                 Store(Zero, C4RW)
>             }
>             Store(Zero, C4LN)
>             If(LNot(And(PAM1, 0x30, ))) {
>                 Store(0x4000, C4LN)
>             }
>             CreateBitField(RSRC, 0x0400, C8RW)
>             CreateDWordField(RSRC, 0x85, C8MN)
>             CreateDWordField(RSRC, 0x89, C8MX)
>             CreateDWordField(RSRC, 0x91, C8LN)
>             Store(One, C8RW)
>             If(LEqual(And(PAM2, 0x3, ), 0x1)) {
>                 Store(Zero, C8RW)
>             }
>             Store(Zero, C8LN)
>             If(LNot(And(PAM2, 0x3, ))) {
>                 Store(0x4000, C8LN)
>             }
>             CreateBitField(RSRC, 0x04d8, CCRW)
>             CreateDWordField(RSRC, 0xa0, CCMN)
>             CreateDWordField(RSRC, 0xa4, CCMX)
>             CreateDWordField(RSRC, 0xac, CCLN)
>             Store(One, CCRW)
>             If(LEqual(And(PAM2, 0x30, ), 0x10)) {
>                 Store(Zero, CCRW)
>             }
>             Store(Zero, CCLN)
>             If(LNot(And(PAM2, 0x30, ))) {
>                 Store(0x4000, CCLN)
>             }
>             CreateBitField(RSRC, 0x05b0, D0RW)
>             CreateDWordField(RSRC, 0xbb, D0MN)
>             CreateDWordField(RSRC, 0xbf, D0MX)
>             CreateDWordField(RSRC, 0xc7, D0LN)
>             Store(One, D0RW)
>             If(LEqual(And(PAM3, 0x3, ), 0x1)) {
>                 Store(Zero, D0RW)
>             }
>             Store(Zero, D0LN)
>             If(LNot(And(PAM3, 0x3, ))) {
>                 Store(0x4000, D0LN)
>             }
>             CreateBitField(RSRC, 0x0688, D4RW)
>             CreateDWordField(RSRC, 0xd6, D4MN)
>             CreateDWordField(RSRC, 0xda, D4MX)
>             CreateDWordField(RSRC, 0xe2, D4LN)
>             Store(One, D4RW)
>             If(LEqual(And(PAM3, 0x30, ), 0x10)) {
>                 Store(Zero, D4RW)
>             }
>             Store(Zero, D4LN)
>             If(LNot(And(PAM3, 0x30, ))) {
>                 Store(0x4000, D4LN)
>             }
>             CreateBitField(RSRC, 0x0760, D8RW)
>             CreateDWordField(RSRC, 0xf1, D8MN)
>             CreateDWordField(RSRC, 0xf5, D8MX)
>             CreateDWordField(RSRC, 0xfd, D8LN)
>             Store(One, D8RW)
>             If(LEqual(And(PAM4, 0x3, ), 0x1)) {
>                 Store(Zero, D8RW)
>             }
>             Store(Zero, D8LN)
>             If(LNot(And(PAM4, 0x3, ))) {
>                 Store(0x4000, D8LN)
>             }
>             CreateBitField(RSRC, 0x0838, DCRW)
>             CreateDWordField(RSRC, 0x010c, DCMN)
>             CreateDWordField(RSRC, 0x0110, DCMX)
>             CreateDWordField(RSRC, 0x0118, DCLN)
>             Store(One, DCRW)
>             If(LEqual(And(PAM4, 0x30, ), 0x10)) {
>                 Store(Zero, DCRW)
>             }
>             Store(Zero, DCLN)
>             If(LNot(And(PAM4, 0x30, ))) {
>                 Store(0x4000, DCLN)
>             }
>             CreateBitField(RSRC, 0x0910, E0RW)
>             CreateDWordField(RSRC, 0x0127, E0MN)
>             CreateDWordField(RSRC, 0x012b, E0MX)
>             CreateDWordField(RSRC, 0x0133, E0LN)
>             Store(One, E0RW)
>             If(LEqual(And(PAM5, 0x3, ), 0x1)) {
>                 Store(Zero, E0RW)
>             }
>             Store(Zero, E0LN)
>             If(LNot(And(PAM5, 0x3, ))) {
>                 Store(0x4000, E0LN)
>             }
>             CreateBitField(RSRC, 0x09e8, E4RW)
>             CreateDWordField(RSRC, 0x0142, E4MN)
>             CreateDWordField(RSRC, 0x0146, E4MX)
>             CreateDWordField(RSRC, 0x014e, E4LN)
>             Store(One, E4RW)
>             If(LEqual(And(PAM5, 0x30, ), 0x10)) {
>                 Store(Zero, E4RW)
>             }
>             Store(Zero, E4LN)
>             If(LNot(And(PAM5, 0x30, ))) {
>                 Store(0x4000, E4LN)
>             }
>             CreateBitField(RSRC, 0x0ac0, E8RW)
>             CreateDWordField(RSRC, 0x015d, E8MN)
>             CreateDWordField(RSRC, 0x0161, E8MX)
>             CreateDWordField(RSRC, 0x0169, E8LN)
>             Store(One, E8RW)
>             If(LEqual(And(PAM6, 0x3, ), 0x1)) {
>                 Store(Zero, E8RW)
>             }
>             Store(Zero, E8LN)
>             If(LNot(And(PAM6, 0x3, ))) {
>                 Store(0x4000, E8LN)
>             }
>             CreateBitField(RSRC, 0x0b98, ECRW)
>             CreateDWordField(RSRC, 0x0178, ECMN)
>             CreateDWordField(RSRC, 0x017c, ECMX)
>             CreateDWordField(RSRC, 0x0184, ECLN)
>             Store(One, ECRW)
>             If(LEqual(And(PAM6, 0x30, ), 0x10)) {
>                 Store(Zero, ECRW)
>             }
>             Store(Zero, ECLN)
>             If(LNot(And(PAM6, 0x30, ))) {
>                 Store(0x4000, ECLN)
>             }
>             Return(RSRC)
>         }
>         Name(_PRT, Package(0x8) {
>             Package(0x4) {
>                 0x0001ffff,
>                 0x0,
>                 \_SB_.PCI_.ISA_.LNKA,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0001ffff,
>                 0x1,
>                 \_SB_.PCI_.ISA_.LNKB,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0002ffff,
>                 0x0,
>                 \_SB_.PCI_.ISA_.LNKA,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0002ffff,
>                 0x1,
>                 \_SB_.PCI_.ISA_.LNKB,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0005ffff,
>                 0x0,
>                 \_SB_.PCI_.ISA_.LNKA,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0006ffff,
>                 0x3,
>                 \_SB_.PCI_.ISA_.LNKD,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0007ffff,
>                 0x0,
>                 \_SB_.PCI_.ISA_.LNKC,
>                 0x0,
>             },
>             Package(0x4) {
>                 0x0007ffff,
>                 0x1,
>                 \_SB_.PCI_.ISA_.LNKD,
>                 0x0,
>             },
>         })
>         Device(AGP_) {
>             Name(_ADR, 0x00010000)
>             Device(VGA_) {
>                 Name(_ADR, 0x0)
>                 Method(_INI) {
>                     Store(And(\_SB_.PHS_, 0x87, 0xf), Zero)
>                     \_SB_.PCI_.AGP_.VGA_.GDCS
>                     Store(And(\_SB_.PCI_.AGP_.VGA_.GDCS, 0x1, ), \_SB_.PC=
I_.AGP_.VGA_.LCD_._DCS)
>                     Store(ShiftRight(And(\_SB_.PCI_.AGP_.VGA_.GDCS, 0x2, =
), 0x1, ), \_SB_.PCI_.AGP_.VGA_.CRT_._DCS)
>                 }
>                 Method(_DOS, 1) {
>                     Store(Arg0, SWIT)
>                 }
>                 Name(_DOD, Package(0x2) {
>                     0x00010100,
>                     0x00010110,
>                 })
>                 Method(SRVO, 1) {
>                     If(And(\_SB_.PHS_, 0x87, 0x30)) {
>                         Zero
>                         If(Arg0) {
>                             If(LNot(LEqual(DDGS, 0x0))) {
>                                 Store(And(DDGS, 0x1, ), \_SB_.PCI_.AGP_.V=
GA_.LCD_._DGS)
>                                 Store(ShiftRight(And(DDGS, 0x2, ), 0x1, )=
, \_SB_.PCI_.AGP_.VGA_.CRT_._DGS)
>                                 Notify(\_SB_.PCI_.AGP_.VGA_, 0x80)
>                             }
>                         }
>                         Else {
>                             Store(Or(ShiftLeft(\_SB_.PCI_.AGP_.VGA_.CRT_.=
_DCS, 0x1, ), \_SB_.PCI_.AGP_.VGA_.LCD_._DCS, ), DDGS)
>                             Store(One, \_SB_.PCI_.AGP_.VGA_.LCD_._DGS)
>                             Store(Zero, \_SB_.PCI_.AGP_.VGA_.CRT_._DGS)
>                             Notify(\_SB_.PCI_.AGP_.VGA_, 0x80)
>                         }
>                     }
>                 }
>                 Device(CRT_) {
>                     Name(_ADR, 0x0100)
>                     Name(_DCS, 0x1f)
>                     Name(_DGS, 0x0)
>                     Method(_DDC, 1) {
>                         If(LEqual(Arg0, 0x1)) {
>                             Return(\_SB_.PHS2)
>                             0x8a
>                             0x0
>                         }
>                         If(LEqual(Arg0, 0x2)) {
>                             Concat(\_SB_.PHS2, 0x8a, 0x0)
>                             DDC0
>                             Local0
>                             Return(Local0)
>                         }
>                     }
>                     Method(_DSS, 1) {
>                         Or(And(\_SB_.PCI_.AGP_.VGA_.GDGS, 0x1, ), ShiftLe=
ft(And(Arg0, 0x1, ), 0x1, ), \_SB_.PCI_.AGP_.VGA_.GDGS)
>                         If(And(Arg0, 0xc0000000, )) {
>                             Store(GDGS, GDCS)
>                             If(LEqual(And(Arg0, 0x40000000, ), 0x0)) {
>                                 \_SB_.PHS2
>                                 0x8b
>                                 Or(GDCS, 0x80, )
>                                 Store(And(\_SB_.PHS_, 0x87, 0xf), Zero)
>                                 Local0
>                                 Store(And(Local0, 0x1, ), \_SB_.PCI_.AGP_=
.VGA_.LCD_._DCS)
>                                 Store(ShiftRight(And(Local0, 0x2, ), 0x1,=
 ), \_SB_.PCI_.AGP_.VGA_.CRT_._DCS)
>                             }
>                             Else {
>                                 \_SB_.PHS2
>                                 0x8b
>                                 GDCS
>                             }
>                         }
>                     }
>                 }
>                 Device(LCD_) {
>                     Name(_ADR, 0x0110)
>                     Name(_DCS, 0x1f)
>                     Name(_DGS, 0x1)
>                     Method(_DDC, 1) {
>                         If(LEqual(Arg0, 0x1)) {
>                             If(And(\_SB_.PHS_, 0x87, 0x40)) {
>                                 Zero
>                                 Return(DDC1)
>                             }
>                             Else {
>                                 Return(DDC2)
>                             }
>                         }
>                         If(LEqual(Arg0, 0x2)) {
>                             If(And(\_SB_.PHS_, 0x87, 0x40)) {
>                                 Zero
>                                 Concat(DDC1, DDC0, Local0)
>                                 Return(Local0)
>                             }
>                             Else {
>                                 Concat(DDC2, DDC0, Local0)
>                                 Return(Local0)
>                             }
>                         }
>                         Return(0x0)
>                     }
>                     Method(_DSS, 1) {
>                         Or(And(\_SB_.PCI_.AGP_.VGA_.GDGS, 0x2, ), And(Arg=
0, 0x1, ), \_SB_.PCI_.AGP_.VGA_.GDGS)
>                         If(And(Arg0, 0xc0000000, )) {
>                             Store(GDGS, GDCS)
>                             If(LEqual(And(Arg0, 0x40000000, ), 0x0)) {
>                                 \_SB_.PHS2
>                                 0x8b
>                                 Or(GDCS, 0x80, )
>                                 Store(And(\_SB_.PHS_, 0x87, 0xf), Zero)
>                                 Local0
>                                 Store(And(Local0, 0x1, ), \_SB_.PCI_.AGP_=
.VGA_.LCD_._DCS)
>                                 Store(ShiftRight(And(Local0, 0x2, ), 0x1,=
 ), \_SB_.PCI_.AGP_.VGA_.CRT_._DCS)
>                             }
>                             Else {
>                                 \_SB_.PHS2
>                                 0x8b
>                                 GDCS
>                             }
>                         }
>                     }
>                 }
>                 Name(SWIT, 0x1)
>                 Name(GDCS, 0x2)
>                 Name(GDGS, 0x2)
>                 Name(DDGS, 0x0)
>                 Name(DDC0, Buffer(0x80) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0 })
>                 Name(DDC1, Buffer(0x80) {0x0, 0xff, 0xff, 0xff, 0xff, 0xf=
f, 0xff, 0x0, 0x24, 0x4d, 0x55, 0xa, 0x1, 0x1, 0x1, 0x1, 0x23, 0x9, 0x1, 0x=
2, 0x80, 0x21, 0x18, 0x0, 0xea, 0xd, 0xfb, 0xa0, 0x57, 0x47, 0x98, 0x27, 0x=
12, 0x4d, 0x51, 0xa1, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64, 0x19, 0x0, 0x40, 0x41, 0x0, 0x26=
, 0x30, 0x18, 0x88, 0x36, 0x0, 0xe, 0xcb, 0x10, 0x0, 0x0, 0x1a, 0x0, 0x0, 0=
x0, 0xfc, 0x0, 0x54, 0x68, 0x69, 0x6e, 0x6b, 0x50, 0x61, 0x64, 0x20, 0x4c, =
0x43, 0x44, 0x20, 0x0, 0x0, 0x0, 0xfc, 0x0, 0x31, 0x30, 0x32, 0x34, 0x78, 0=
x37, 0x36, 0x38, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x33 })
>                 Name(DDC2, Buffer(0x80) {0x0, 0xff, 0xff, 0xff, 0xff, 0xf=
f, 0xff, 0x0, 0x24, 0x4d, 0x4b, 0xa, 0x1, 0x1, 0x1, 0x1, 0x23, 0x9, 0x1, 0x=
2, 0x80, 0x21, 0x18, 0x0, 0xea, 0xd, 0xfb, 0xa0, 0x57, 0x47, 0x98, 0x27, 0x=
12, 0x4d, 0x51, 0xa1, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x90, 0x1, 0x20, 0x0, 0x31, 0x58, 0x1c=
, 0x20, 0x28, 0x80, 0x1, 0x0, 0xf6, 0xb8, 0x0, 0x0, 0x0, 0x1a, 0x0, 0x0, 0x=
0, 0xfc, 0x0, 0x54, 0x68, 0x69, 0x6e, 0x6b, 0x50, 0x61, 0x64, 0x20, 0x4c, 0=
x43, 0x44, 0x20, 0x0, 0x0, 0x0, 0xfc, 0x0, 0x38, 0x30, 0x30, 0x78, 0x36, 0x=
30, 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa1 })
>             }
>         }
>         Device(CRD0) {
>             Name(_ADR, 0x00020000)
>             Name(_PRW, Package(0x2) {
>                 0xb,
>                 0x4,
>             })
>             OperationRegion(PCIC, PCI_Config, 0x0, 0x0100)
>             Field(PCIC, DWordAcc, NoLock, Preserve) {
>                 Offset(0x4),
>                 CMD_,	16,
>                 Offset(0x10),
>                 ADD0,	32,
>                 Offset(0x3c),
>                 INTL,	8,
>                 Offset(0x44),
>                 LADD,	32,
>                 Offset(0x80),
>                 PMRI,	1,
>                 Offset(0xa4),
>                 PWRS,	2,
>                 Offset(0xa5),
>                 ,	7,
>                 PMES,	1
>             }
>             Method(_INI) {
>                 Or(INTL, 0xff, INTL)
>                 And(LADD, 0xffff0000, LADD)
>             }
>             Method(_PS0) {
>                 Store(Zero, PWRS)
>                 Store(One, PMRI)
>                 Store(One, PMES)
>             }
>             Method(_PS3) {
>                 Store(Zero, PMRI)
>             }
>         }
>         Device(CRD1) {
>             Name(_ADR, 0x00020001)
>             OperationRegion(PCIC, PCI_Config, 0x0, 0x0100)
>             Field(PCIC, DWordAcc, NoLock, Preserve) {
>                 Offset(0x4),
>                 CMD_,	16,
>                 Offset(0x10),
>                 ADD0,	32,
>                 Offset(0x3c),
>                 INTL,	8,
>                 Offset(0x44),
>                 LADD,	32,
>                 Offset(0x80),
>                 PMRI,	1,
>                 Offset(0xa4),
>                 PWRS,	2,
>                 Offset(0xa5),
>                 ,	7,
>                 PMES,	1
>             }
>             Name(_PRW, Package(0x2) {
>                 0xb,
>                 0x4,
>             })
>             Method(_INI) {
>                 Or(INTL, 0xff, INTL)
>                 And(LADD, 0xffff0000, LADD)
>             }
>             Method(_PS0) {
>                 Store(Zero, PWRS)
>                 Store(One, PMRI)
>                 Store(One, PMES)
>             }
>             Method(_PS3) {
>                 Store(Zero, PMRI)
>             }
>         }
>         Device(OAK_) {
>             Name(_ADR, 0x00040000)
>             Name(_EJD, "_SB_.PCI_.ISA_.SLCE")
>             Name(_PRT, Package(0x3) {
>                 Package(0x4) {
>                     0xffff,
>                     0x0,
>                     \_SB_.PCI_.ISA_.LNKA,
>                     0x0,
>                 },
>                 Package(0x4) {
>                     0xffff,
>                     0x1,
>                     \_SB_.PCI_.ISA_.LNKA,
>                     0x0,
>                 },
>                 Package(0x4) {
>                     0x0001ffff,
>                     0x0,
>                     \_SB_.PCI_.ISA_.LNKB,
>                     0x0,
>                 },
>             })
>             OperationRegion(PCI_, PCI_Config, 0x0, 0x0100)
>             Field(PCI_, DWordAcc, NoLock, Preserve) {
>                 VID_,	32
>             }
>             Method(_BDN) {
>                 Return(0x43004d24)
>             }
>             Method(_UID) {
>                 Store(Zero, Local0)
>                 Or(Local0, \_SB_.PCI_.PWR_.RE2R, 0x2)
>                 Local0
>                 ShiftLeft(Local0, 0x8, Local0)
>                 Or(Local0, \_SB_.PCI_.PWR_.RE2R, 0x1)
>                 Local0
>                 ShiftLeft(Local0, 0x8, Local0)
>                 Or(Local0, \_SB_.PCI_.PWR_.RE2R, 0x0)
>                 Local0
>                 Return(Local0)
>             }
>             Method(_DCK, 1) {
>                 Store(Zero, \_SB_.PCI_.ISA_.PMGA.LOKE)
>                 If(Arg0) {
>                     Store(Zero, \_SB_.PCI_.ISA_.PMGA.DOKC)
>                 }
>                 Else {
>                     Store(One, \_SB_.PCI_.ISA_.PMGA.DOKC)
>                 }
>                 \_SB_.PCI_.AGP_.VGA_.SRVO
>                 Arg0
>                 Return(Arg0)
>             }
>             Method(_EJ0, 1) {
>                 Store(One, \_SB_.PCI_.ISA_.PMGA.UDOC)
>                 While(\_SB_.PCI_.ISA_.PMGA.DOKS) {
>                     Sleep(0x1)
>                 }
>                 Store(Zero, \_SB_.PCI_.ISA_.PMGA.UDOC)
>             }
>             Method(_STA) {
>                 Store(0x0, Local0)
>                 If(\_SB_.PCI_.ISA_.PMGA.DOKS) {
>                     If(LEqual(\_SB_.PCI_.PWR_.RE2R, 0x3)) {
>                         0x20
>                         Store(0xf, Local0)
>                     }
>                 }
>                 If(Local0) {
>                     Store(Zero, \_SB_.PCI_.ISA_.PMGA.LOKE)
>                 }
>                 Else {
>                     Store(One, \_SB_.PCI_.ISA_.PMGA.LOKE)
>                 }
>                 Store(Zero, \_SB_.PCI_.ISA_.PMGA.DOKC)
>                 Return(Local0)
>             }
>             Method(SDCK, 1) {
>                 If(Arg0) {
>                     If(\_SB_.PCI_.ISA_.PMGA.EXPS) {
>                         If(LEqual(\_SB_.PCI_.PWR_.RE2R, 0x3)) {
>                             0x20
>                             \_SB_.PHS_
>                             0x86
>                         }
>                     }
>                 }
>             }
>             Device(CRD0) {
>                 Name(_ADR, 0x0)
>                 Name(_PRW, Package(0x2) {
>                     0xb,
>                     0x4,
>                 })
>                 OperationRegion(PCIC, PCI_Config, 0x0, 0x0100)
>                 Field(PCIC, DWordAcc, NoLock, Preserve) {
>                     Offset(0x4),
>                     CMD_,	16,
>                     Offset(0x10),
>                     ADD0,	32,
>                     Offset(0x3c),
>                     INTL,	8,
>                     Offset(0x44),
>                     LADD,	32,
>                     Offset(0x80),
>                     PMRI,	1,
>                     Offset(0xa4),
>                     PWRS,	2,
>                     Offset(0xa5),
>                     ,	7,
>                     PMES,	1
>                 }
>                 Method(_INI) {
>                     Or(INTL, 0xff, INTL)
>                     And(LADD, 0xffff0000, LADD)
>                 }
>                 Method(_PS0) {
>                     Store(Zero, PWRS)
>                     Store(One, PMRI)
>                     Store(One, PMES)
>                 }
>                 Method(_PS3) {
>                     Store(Zero, PMRI)
>                 }
>             }
>             Device(CRD1) {
>                 Name(_ADR, 0x1)
>                 Name(_PSC, 0x0)
>                 Name(_PRW, Package(0x2) {
>                     0xb,
>                     0x4,
>                 })
>                 OperationRegion(PCIC, PCI_Config, 0x0, 0x0100)
>                 Field(PCIC, DWordAcc, NoLock, Preserve) {
>                     Offset(0x4),
>                     CMD_,	16,
>                     Offset(0x10),
>                     ADD0,	32,
>                     Offset(0x3c),
>                     INTL,	8,
>                     Offset(0x44),
>                     LADD,	32,
>                     Offset(0x80),
>                     PMRI,	1,
>                     Offset(0xa4),
>                     PWRS,	2,
>                     Offset(0xa5),
>                     ,	7,
>                     PMES,	1
>                 }
>                 Method(_INI) {
>                     Or(INTL, 0xff, INTL)
>                     And(LADD, 0xffff0000, LADD)
>                 }
>                 Method(_PS0) {
>                     Store(Zero, PWRS)
>                     Store(One, PMRI)
>                     Store(One, PMES)
>                 }
>                 Method(_PS3) {
>                     Store(Zero, PMRI)
>                 }
>             }
>             Device(LAN_) {
>                 Name(_ADR, 0x00010000)
>                 Name(_PRW, Package(0x2) {
>                     0xb,
>                     0x4,
>                 })
>             }
>         }
>         Device(AUD_) {
>             Name(_ADR, 0x00050000)
>         }
>         Device(ISA_) {
>             Name(_ADR, 0x00060000)
>             Device(DMAC) {
>                 Name(_HID, 0x0002d041)
>                 Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0, =
0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x2, 0x79, 0x0 })
>             }
>             Device(PIC_) {
>                 Name(_HID, 0x0100d041)
>                 Name(_CRS, Buffer(0x1e) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0,=
 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xd0, 0x4,=
 0xd0, 0x4, 0x1, 0x2, 0x23, 0x4, 0x0, 0x1, 0x79, 0x0 })
>             }
>             Device(TIME) {
>                 Name(_HID, 0x0001d041)
>                 Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, =
0x1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
>             }
>             Device(RTC_) {
>                 Name(_HID, 0x000bd041)
>                 Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, =
0x1, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
>             }
>             Device(SPKR) {
>                 Name(_HID, 0x0008d041)
>                 Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, =
0x1, 0x1, 0x79, 0x0 })
>             }
>             Device(MATH) {
>                 Name(_HID, 0x040cd041)
>                 Name(_CRS, Buffer(0xe) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, =
0x1, 0x10, 0x23, 0x0, 0x20, 0x1, 0x79, 0x0 })
>             }
>             Device(MEM_) {
>                 Name(_HID, 0x010cd041)
>                 Name(_CRS, Buffer(0x26) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0=
x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, =
0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff, 0x0, 0x0, 0x8, 0x=
0, 0x79, 0x0 })
>             }
>             Device(KBC_) {
>                 Name(_HID, 0x0303d041)
>                 Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0,=
 0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x79,=
 0x0 })
>             }
>             Device(MOUS) {
>                 Name(_HID, 0x80374d24)
>                 Name(_CID, 0x130fd041)
>                 Method(_CRS) {
>                     Return(PSCS)
>                     0x16
>                 }
>                 Method(_SRS, 1) {
>                     PSSS
>                     0x16
>                     Arg0
>                 }
>                 Method(_PRS) {
>                     Return(PSPS)
>                     0x16
>                 }
>                 Method(_DIS) {
>                     PSDI
>                     0x16
>                 }
>                 Method(_STA) {
>                     Return(PSST)
>                     0x16
>                 }
>             }
>             OperationRegion(GEN_, PCI_Config, 0xb0, 0x4)
>             Field(GEN_, DWordAcc, NoLock, Preserve) {
>                 Offset(0x1),
>                 ,	4,
>                 SIDE,	1
>             }
>             Device(LNKA) {
>                 Name(_HID, 0x0f0cd041)
>                 Name(_UID, 0x1)
>                 Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x8e, 0x18, 0x79, 0x0=
 })
>                 Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                 Method(_DIS) {
>                     Or(PIRA, 0x80, PIRA)
>                 }
>                 Method(_CRS) {
>                     CreateWordField(RSRC, 0x1, IRQ0)
>                     And(PIRA, 0xf, Local0)
>                     ShiftLeft(0x1, Local0, IRQ0)
>                     Store(RSRC, Debug)
>                     Return(RSRC)
>                 }
>                 Method(_SRS, 1) {
>                     Store(Arg0, Debug)
>                     CreateWordField(Arg0, 0x1, IRQ0)
>                     FindSetRightBit(IRQ0, Local0)
>                     Decrement(Local0)
>                     Or(Local0, And(PIRA, 0x70, ), PIRA)
>                 }
>                 Method(_STA) {
>                     If(And(PIRA, 0x80, )) {
>                         Return(0x9)
>                     }
>                     Return(0xb)
>                 }
>             }
>             Device(LNKB) {
>                 Name(_HID, 0x0f0cd041)
>                 Name(_UID, 0x2)
>                 Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x8e, 0x18, 0x79, 0x0=
 })
>                 Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                 Method(_DIS) {
>                     Or(PIRB, 0x80, PIRB)
>                 }
>                 Method(_CRS) {
>                     CreateWordField(RSRC, 0x1, IRQ0)
>                     And(PIRB, 0xf, Local0)
>                     ShiftLeft(0x1, Local0, IRQ0)
>                     Return(RSRC)
>                 }
>                 Method(_SRS, 1) {
>                     CreateWordField(Arg0, 0x1, IRQ0)
>                     FindSetRightBit(IRQ0, Local0)
>                     Decrement(Local0)
>                     Or(Local0, And(PIRB, 0x70, ), PIRB)
>                 }
>                 Method(_STA) {
>                     If(And(PIRB, 0x80, )) {
>                         Return(0x9)
>                     }
>                     Return(0xb)
>                 }
>             }
>             Device(LNKC) {
>                 Name(_HID, 0x0f0cd041)
>                 Name(_UID, 0x3)
>                 Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x8e, 0x18, 0x79, 0x0=
 })
>                 Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                 Method(_DIS) {
>                     Or(PIRC, 0x80, PIRC)
>                 }
>                 Method(_CRS) {
>                     CreateWordField(RSRC, 0x1, IRQ0)
>                     And(PIRC, 0xf, Local0)
>                     ShiftLeft(0x1, Local0, IRQ0)
>                     Return(RSRC)
>                 }
>                 Method(_SRS, 1) {
>                     CreateWordField(Arg0, 0x1, IRQ0)
>                     FindSetRightBit(IRQ0, Local0)
>                     Decrement(Local0)
>                     Or(Local0, And(PIRC, 0x70, ), PIRC)
>                 }
>                 Method(_STA) {
>                     If(And(PIRC, 0x80, )) {
>                         Return(0x9)
>                     }
>                     Return(0xb)
>                 }
>             }
>             Device(LNKD) {
>                 Name(_HID, 0x0f0cd041)
>                 Name(_UID, 0x4)
>                 Name(_PRS, Buffer(0x6) {0x23, 0xb8, 0x8e, 0x18, 0x79, 0x0=
 })
>                 Name(RSRC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                 Method(_DIS) {
>                     Or(PIRD, 0x80, PIRD)
>                 }
>                 Method(_CRS) {
>                     CreateWordField(RSRC, 0x1, IRQ0)
>                     And(PIRD, 0xf, Local0)
>                     ShiftLeft(0x1, Local0, IRQ0)
>                     Return(RSRC)
>                 }
>                 Method(_SRS, 1) {
>                     CreateWordField(Arg0, 0x1, IRQ0)
>                     FindSetRightBit(IRQ0, Local0)
>                     Decrement(Local0)
>                     Or(Local0, And(PIRD, 0x70, ), PIRD)
>                 }
>                 Method(_STA) {
>                     If(And(PIRD, 0x80, )) {
>                         Return(0x9)
>                     }
>                     Return(0xb)
>                 }
>             }
>             OperationRegion(PIRX, PCI_Config, 0x60, 0x4)
>             Field(PIRX, DWordAcc, NoLock, Preserve) {
>                 AccessAs(ByteAcc, 0),
>                 PIRA,	8,
>                 PIRB,	8,
>                 PIRC,	8,
>                 PIRD,	8
>             }
>             Device(PMGA) {
>                 Name(_HID, 0x050ad041)
>                 Name(_UID, 0x1)
>                 OperationRegion(GAIO, SystemIO, 0x15ee, 0x2)
>                 Field(GAIO, ByteAcc, NoLock, Preserve) {
>                     PMIX,	8,
>                     PMDA,	8
>                 }
>                 IndexField(PMIX, PMDA, ByteAcc, NoLock, Preserve) {
>                     ,	6,
>                     BREN,	1,
>                     Offset(0x2d),
>                     UDOC,	1,
>                     DOKC,	1,
>                     LOKE,	1,
>                     ,	1,
>                     DOKS,	1,
>                     EXPS,	1,
>                     Offset(0x2f),
>                     BAYE,	1,
>                     BAYP,	1,
>                     BAYR,	1
>                 }
>                 Name(_STA, 0xb)
>                 Method(SBAY, 1) {
>                     If(Arg0) {
>                         Store(Zero, BAYR)
>                         Store(Zero, BAYP)
>                         Sleep(0xa)
>                         Store(Zero, BAYE)
>                         Store(One, BAYR)
>                     }
>                     Else {
>                         Store(One, BAYE)
>                         Store(One, BAYP)
>                     }
>                 }
>                 Method(GBAY) {
>                     Return(Not(BAYE, ))
>                 }
>             }
>             Device(SIO_) {
>                 Name(_HID, 0x050ad041)
>                 Name(_UID, 0x2)
>                 Name(_STA, 0xb)
>                 Name(RDE1, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x=
1, 0x0, 0x22, 0x0, 0x0, 0x79, 0x0 })
>                 Name(RDE2, Buffer(0x10) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x0, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x79, 0x0 })
>                 Name(RDE3, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x22, 0x0, 0x0, 0x2a, 0x0=
, 0x0, 0x79, 0x0 })
>                 Device(COMA) {
>                     Name(_HID, 0x0105d041)
>                     Name(_UID, 0x1)
>                     Name(_EJD, "_SB_.PCI_.OAK_")
>                     Method(_CRS) {
>                         Return(PSCS)
>                         0x12
>                     }
>                     Method(_SRS, 1) {
>                         PSSS
>                         0x12
>                         Arg0
>                     }
>                     Method(_PRS) {
>                         Return(PSPS)
>                         0x12
>                     }
>                     Method(_DIS) {
>                         PSDI
>                         0x12
>                     }
>                     Method(_STA) {
>                         Return(PSST)
>                         0x12
>                     }
>                     Name(_PRW, Package(0x2) {
>                         0xb,
>                         0x3,
>                     })
>                 }
>                 Device(FIR_) {
>                     Name(_HID, 0x71004d24)
>                     Name(_CID, 0x1105d041)
>                     Method(_CRS) {
>                         Return(PSCS)
>                         0x13
>                     }
>                     Method(_SRS, 1) {
>                         PSSS
>                         0x13
>                         Arg0
>                     }
>                     Method(_PRS) {
>                         Return(PSPS)
>                         0x13
>                     }
>                     Method(_DIS) {
>                         PSDI
>                         0x13
>                     }
>                     Method(_STA) {
>                         Return(PSST)
>                         0x13
>                     }
>                 }
>                 Device(LPT_) {
>                     Name(_HID, 0x0004d041)
>                     Name(_UID, 0x1)
>                     Name(MCD_, 0x17)
>                     Name(_STA, 0x0)
>                     Name(B_PR, Buffer(0x4b) {0x30, 0x47, 0x1, 0x78, 0x3, =
0x78, 0x3, 0x1, 0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3=
, 0x1, 0x8, 0x22, 0x20, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x=
8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x1, 0x8, 0x22, =
0x20, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x22, 0x80, 0x0=
, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4, 0x22, 0x20, 0x0, 0x38, 0=
x79, 0x0 })
>                     Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0=
, 0x1, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
>                     Method(_CRS) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         If(LEqual(_STA, 0xf)) {
>                             CreateWordField(CRSB, 0x2, IO1B)
>                             CreateWordField(CRSB, 0x4, IO2B)
>                             CreateWordField(CRSB, 0x6, IO3B)
>                             CreateWordField(CRSB, 0x9, IRQB)
>                             Or(ShiftLeft(And(R430, 0xfc, ), 0x8, ), Shift=
Left(R420, 0x2, ), IO1B)
>                             Store(IO1B, IO2B)
>                             If(LEqual(IO1B, 0x03bc)) {
>                                 Store(0x0401, IO3B)
>                             }
>                             Store(Zero, IRQB)
>                             ShiftRight(READ, 0x1b, 0xf0)
>                             0x4
>                             Local0
>                             If(Local0) {
>                                 ShiftLeft(0x1, Local0, IRQB)
>                             }
>                             Return(CRSB)
>                         }
>                         Else {
>                             Return(RDE1)
>                         }
>                         Release(\_SB_.MPHS)
>                     }
>                     Method(B_SR, 1) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         Name(XRFI, Package(0x10) {
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x7,
>                             0x0,
>                             0x1,
>                             0x0,
>                             0x2,
>                             0x3,
>                             0x4,
>                             0x0,
>                             0x0,
>                             0x5,
>                             0x6,
>                         })
>                         CreateWordField(Arg0, 0x2, IO1A)
>                         CreateWordField(Arg0, 0x9, IRQB)
>                         WRIT
>                         0x0
>                         0xfe
>                         0x0
>                         PRDC
>                         Ones
>                         WRIT
>                         0x42
>                         0x0
>                         ShiftRight(IO1A, 0x2, )
>                         WRIT
>                         0x43
>                         0x3
>                         ShiftRight(IO1A, 0x8, )
>                         FindSetRightBit(IRQB, Local0)
>                         If(Local0) {
>                             Decrement(Local0)
>                             WRIT
>                             0x1b
>                             0xf
>                             ShiftLeft(Local0, 0x4, )
>                             WRIT
>                             0x1b
>                             0xf8
>                             DerefOf(Index(XRFI, Local0, ))
>                         }
>                         Else {
>                             WRIT
>                             0x1b
>                             0x8
>                             0x0
>                         }
>                         WRIT
>                         0x0
>                         0xfe
>                         0x1
>                         PRDC
>                         IO1A
>                         Store(0xf, _STA)
>                         Release(\_SB_.MPHS)
>                     }
>                     Method(B_DI) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         WRIT
>                         0x0
>                         0xfe
>                         0x0
>                         PRDC
>                         Ones
>                         Store(0xd, _STA)
>                         Release(\_SB_.MPHS)
>                     }
>                     Name(_EJD, "_SB_.PCI_.OAK_")
>                 }
>                 Device(LPTB) {
>                     Name(_HID, 0x0004d041)
>                     Name(_UID, 0x2)
>                     Name(MCD_, 0x18)
>                     Name(_STA, 0xd)
>                     Name(_PRS, Buffer(0x51) {0x30, 0x47, 0x1, 0x78, 0x3, =
0x78, 0x3, 0x1, 0x8, 0x23, 0x80, 0x0, 0x1, 0x30, 0x47, 0x1, 0x78, 0x3, 0x78=
, 0x3, 0x1, 0x8, 0x23, 0x20, 0x0, 0x1, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x=
2, 0x1, 0x8, 0x23, 0x80, 0x0, 0x1, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0=
x1, 0x8, 0x23, 0x20, 0x0, 0x1, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, =
0x4, 0x23, 0x80, 0x0, 0x1, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x1, 0x4,=
 0x23, 0x20, 0x0, 0x1, 0x38, 0x79, 0x0 })
>                     Name(CRSB, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0=
, 0x1, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
>                     Method(_CRS) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         If(LEqual(_STA, 0xf)) {
>                             CreateWordField(CRSB, 0x2, IO1B)
>                             CreateWordField(CRSB, 0x4, IO2B)
>                             CreateWordField(CRSB, 0x6, IO3B)
>                             CreateWordField(CRSB, 0x9, IRQB)
>                             Or(ShiftLeft(And(R430, 0xfc, ), 0x8, ), Shift=
Left(R420, 0x2, ), IO1B)
>                             Store(IO1B, IO2B)
>                             If(LEqual(IO1B, 0x03bc)) {
>                                 Store(0x0401, IO3B)
>                             }
>                             Store(Zero, IRQB)
>                             ShiftRight(READ, 0x1b, 0xf0)
>                             0x4
>                             Local0
>                             If(Local0) {
>                                 ShiftLeft(0x1, Local0, IRQB)
>                             }
>                             Return(CRSB)
>                         }
>                         Else {
>                             Return(RDE1)
>                         }
>                         Release(\_SB_.MPHS)
>                     }
>                     Method(_SRS, 1) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         Name(XRFI, Package(0x10) {
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x0,
>                             0x7,
>                             0x0,
>                             0x1,
>                             0x0,
>                             0x2,
>                             0x3,
>                             0x4,
>                             0x0,
>                             0x0,
>                             0x5,
>                             0x6,
>                         })
>                         CreateWordField(Arg0, 0x2, IO1A)
>                         CreateWordField(Arg0, 0x9, IRQB)
>                         WRIT
>                         0x0
>                         0xfe
>                         0x0
>                         PRDC
>                         Ones
>                         WRIT
>                         0x42
>                         0x0
>                         ShiftRight(IO1A, 0x2, )
>                         WRIT
>                         0x43
>                         0x3
>                         ShiftRight(IO1A, 0x8, )
>                         FindSetRightBit(IRQB, Local0)
>                         If(Local0) {
>                             Decrement(Local0)
>                             WRIT
>                             0x1b
>                             0xf
>                             ShiftLeft(Local0, 0x4, )
>                             WRIT
>                             0x1b
>                             0xf8
>                             DerefOf(Index(XRFI, Local0, ))
>                         }
>                         Else {
>                             WRIT
>                             0x1b
>                             0x8
>                             0x0
>                         }
>                         WRIT
>                         0x0
>                         0xfe
>                         0x1
>                         PRDC
>                         IO1A
>                         Store(0xf, _STA)
>                         Release(\_SB_.MPHS)
>                     }
>                     Method(_DIS) {
>                         Acquire(\_SB_.MPHS, 0xffff)
>                         WRIT
>                         0x0
>                         0xfe
>                         0x0
>                         PRDC
>                         Ones
>                         Store(0xd, _STA)
>                         Release(\_SB_.MPHS)
>                     }
>                     Name(_EJD, "_SB_.PCI_.OAK_")
>                 }
>                 Device(ECP_) {
>                     Name(_HID, 0x0104d041)
>                     Method(_CRS) {
>                         If(LEqual(_STA, 0xf)) {
>                             Return(PSCS)
>                             0x14
>                         }
>                         Else {
>                             Return(RDE3)
>                         }
>                     }
>                     Method(_SRS, 1) {
>                         PSSS
>                         0x14
>                         Arg0
>                     }
>                     Method(_PRS) {
>                         Return(PSPS)
>                         0x14
>                     }
>                     Method(_DIS) {
>                         PSDI
>                         0x14
>                     }
>                     Method(_STA) {
>                         Return(PSST)
>                         0x14
>                     }
>                     Name(_EJD, "_SB_.PCI_.OAK_")
>                 }
>                 Device(EPP_) {
>                     Name(_HID, 0x0004d041)
>                     Name(_UID, 0x3)
>                     Method(_CRS) {
>                         If(LEqual(_STA, 0xf)) {
>                             Return(PSCS)
>                             0x15
>                         }
>                         Else {
>                             Return(RDE1)
>                         }
>                     }
>                     Method(_SRS, 1) {
>                         PSSS
>                         0x15
>                         Arg0
>                     }
>                     Method(_PRS) {
>                         Return(PSPS)
>                         0x15
>                     }
>                     Method(_DIS) {
>                         PSDI
>                         0x15
>                     }
>                     Method(_STA) {
>                         Return(PSST)
>                         0x15
>                     }
>                     Name(_EJD, "_SB_.PCI_.OAK_")
>                 }
>                 Device(FDC_) {
>                     Name(_HID, 0x0007d041)
>                     OperationRegion(FDCR, SystemIO, 0x03f0, 0x7)
>                     Field(FDCR, ByteAcc, NoLock, Preserve) {
>                         Offset(0x3),
>                         TDR_,	8
>                     }
>                     Method(_CRS) {
>                         Return(PSCS)
>                         0x11
>                     }
>                     Method(_SRS, 1) {
>                         PSSS
>                         0x11
>                         Arg0
>                         If(LNot(\_SB_.PCI_.PWR_.GI13)) {
>                             If(\_SB_.PCI_.ISA_.PMGA.GBAY) {
>                                 And(TDR_, 0xf3, TDR_)
>                             }
>                             Else {
>                                 Or(And(TDR_, 0xf3, ), 0x4, TDR_)
>                             }
>                         }
>                         Else {
>                             Or(And(TDR_, 0xf3, ), 0x4, TDR_)
>                         }
>                     }
>                     Method(_PRS) {
>                         Return(PSPS)
>                         0x11
>                     }
>                     Method(_DIS) {
>                         PSDI
>                         0x11
>                     }
>                     Method(_STA) {
>                         Return(PSST)
>                         0x11
>                     }
>                 }
>                 OperationRegion(SIOR, SystemIO, 0x2e, 0x2)
>                 Field(SIOR, ByteAcc, NoLock, Preserve) {
>                     INDX,	8,
>                     DATA,	8
>                 }
>                 IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
>                     R000,	8,
>                     Offset(0x2),
>                     R020,	8,
>                     Offset(0x4),
>                     R040,	8,
>                     Offset(0x42),
>                     R420,	8,
>                     R430,	8,
>                     R440,	8,
>                     R450,	8,
>                     R460,	8,
>                     R470,	8,
>                     R480,	8,
>                     R490,	8,
>                     Offset(0x4f),
>                     R4F0,	8
>                 }
>                 Method(READ, 2) {
>                     Store(Arg0, INDX)
>                     Return(And(DATA, Arg1, ))
>                 }
>                 Method(WRIT, 3) {
>                     Store(Arg0, INDX)
>                     Or(And(DATA, Arg1, ), Arg2, Local0)
>                     Store(Arg0, INDX)
>                     Store(Local0, DATA)
>                     Store(Local0, DATA)
>                 }
>                 Name(LPT1, Package(0x3) {
>                     0x03bc,
>                     0x0378,
>                     0x0278,
>                 })
>                 Method(PRDC, 1) {
>                     If(LEqual(Arg0, Ones)) {
>                         Store(Zero, \_SB_.PCI_.PWR_.LPTE)
>                     }
>                     Else {
>                         Store(Sizeof(LPT1), Local0)
>                         While(Local0) {
>                             Decrement(Local0)
>                             If(LEqual(Arg0, DerefOf(Index(LPT1, Local0, )=
))) {
>                                 Store(Local0, \_SB_.PCI_.PWR_.LPTA)
>                                 Store(One, \_SB_.PCI_.PWR_.LPTE)
>                                 Store(One, \_SB_.PCI_.PWR_.LPTM)
>                             }
>                         }
>                     }
>                 }
>             }
>             Device(EC__) {
>                 Name(_HID, 0x050ad041)
>                 Name(_UID, 0x3)
>                 Name(BEJP, 0x0)
>                 Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,=
 0x1, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
>                 Name(_GPE, 0x9)
>                 OperationRegion(ECP0, SystemIO, 0x62, 0x1)
>                 Field(ECP0, ByteAcc, NoLock, Preserve) {
>                     ECDA,	8
>                 }
>                 OperationRegion(ECP1, SystemIO, 0x66, 0x1)
>                 Field(ECP1, ByteAcc, NoLock, Preserve) {
>                     ECST,	8
>                 }
>                 Field(ECP1, ByteAcc, NoLock, Preserve) {
>                     ECCM,	8
>                 }
>                 Mutex(ECMB, 0)
>                 Method(WIBE, 0, Serialized) {
>                     While(And(ECST, 0x2, )) {
>                         Stall(0x1)
>                     }
>                 }
>                 Method(WOBF, 0, Serialized) {
>                     While(LNot(And(ECST, 0x1, ))) {
>                         Stall(0x1)
>                     }
>                 }
>                 Method(ECRD, 1, Serialized) {
>                     Acquire(ECMB, 0xffff)
>                     WIBE
>                     Store(0xd2, ECCM)
>                     WIBE
>                     Store(0x80, ECCM)
>                     WIBE
>                     Store(Arg0, ECDA)
>                     WIBE
>                     WOBF
>                     Store(ECDA, Local0)
>                     Store(0xd3, ECCM)
>                     WIBE
>                     Release(ECMB)
>                     Return(Local0)
>                 }
>                 Method(ECWR, 2, Serialized) {
>                     Acquire(ECMB, 0xffff)
>                     WIBE
>                     Store(0xd2, ECCM)
>                     WIBE
>                     Store(0x81, ECCM)
>                     WIBE
>                     Store(Arg0, ECDA)
>                     WIBE
>                     Store(Arg1, ECDA)
>                     WIBE
>                     Store(0xd3, ECCM)
>                     WIBE
>                     Release(ECMB)
>                 }
>                 Method(ECQE, 0, Serialized) {
>                     Acquire(ECMB, 0xffff)
>                     Store(0x0, Local0)
>                     If(And(ECST, 0x20, )) {
>                         WIBE
>                         Store(0xd2, ECCM)
>                         WIBE
>                         Store(0x84, ECCM)
>                         WIBE
>                         WOBF
>                         Store(ECDA, Local0)
>                         Store(0xd3, ECCM)
>                         WIBE
>                     }
>                     Release(ECMB)
>                     Return(Local0)
>                 }
>                 Method(_Q11) {
>                     \_SB_.PHS_
>                     0x80
>                 }
>                 Method(_Q13) {
>                     Notify(\_SB_.SLPB, 0x80)
>                 }
>                 Method(_Q16) {
>                     Store("=3D=3D=3D=3D=3D FnF7 =3D=3D=3D=3D=3D", Debug)
>                     If(LEqual(\_SB_.PCI_.AGP_.VGA_.SWIT, 0x0)) {
>                         If(LEqual(\_SB_.PCI_.AGP_.VGA_.GDCS, 0x1)) {
>                             Store(Zero, \_SB_.PCI_.AGP_.VGA_.LCD_._DGS)
>                             Store(One, \_SB_.PCI_.AGP_.VGA_.CRT_._DGS)
>                         }
>                         If(LEqual(\_SB_.PCI_.AGP_.VGA_.GDCS, 0x2)) {
>                             Store(One, \_SB_.PCI_.AGP_.VGA_.LCD_._DGS)
>                             Store(One, \_SB_.PCI_.AGP_.VGA_.CRT_._DGS)
>                         }
>                         If(LEqual(\_SB_.PCI_.AGP_.VGA_.GDCS, 0x3)) {
>                             Store(One, \_SB_.PCI_.AGP_.VGA_.LCD_._DGS)
>                             Store(Zero, \_SB_.PCI_.AGP_.VGA_.CRT_._DGS)
>                         }
>                         Notify(\_SB_.PCI_.AGP_.VGA_, 0x80)
>                     }
>                     If(LEqual(\_SB_.PCI_.AGP_.VGA_.SWIT, 0x1)) {
>                         \_SB_.PHS_
>                         0x81
>                     }
>                 }
>                 Method(_Q17) {
>                     \_SB_.PHS_
>                     0x82
>                 }
>                 Method(_Q1B) {
>                     Notify(\_SB_.SLPB, 0x80)
>                 }
>                 Method(_Q1C) {
>                     \_SB_.PHS_
>                     0x83
>                 }
>                 Method(_Q1D) {
>                     \_SB_.PHS_
>                     0x84
>                 }
>                 Method(_Q1E) {
>                     \_SB_.PHS_
>                     0x85
>                 }
>                 Method(_Q20) {
>                     Notify(\_SB_.BAT1, 0x80)
>                     Notify(\_SB_.BAT2, 0x80)
>                 }
>                 Method(_Q21) {
>                     Notify(\_SB_.BAT1, 0x80)
>                     Notify(\_SB_.BAT2, 0x80)
>                 }
>                 Method(_Q22) {
>                     Notify(\_SB_.BAT1, 0x80)
>                     Notify(\_SB_.BAT2, 0x80)
>                 }
>                 Method(_Q23) {
>                     Store(Zero, Local0)
>                     If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x0, 0x80)) {
>                         Zero
>                         If(LEqual(\_SB_.BAT1._STA, 0xf)) {
>                             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local1)
>                             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local1)
>                             0x10
>                             Local2
>                             CreateByteField(Local2, 0x20, BST1)
>                             While(LEqual(BST1, 0x0)) {
>                                 Sleep(0xa)
>                                 Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local1)
>                                 0x10
>                                 Local2
>                             }
>                             Store(0x1f, \_SB_.BAT1._STA)
>                             Or(0x1, Local0, Local0)
>                         }
>                     }
>                     Else {
>                         If(LEqual(\_SB_.BAT1._STA, 0x1f)) {
>                             Store(0xf, \_SB_.BAT1._STA)
>                             Or(0x1, Local0, Local0)
>                         }
>                     }
>                     If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x80)) {
>                         Zero
>                         If(LEqual(\_SB_.BAT2._STA, 0xf)) {
>                             Store(\_SB_.PCI_.ISA_.EC__.GH8A, Local1)
>                             Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local1)
>                             0x11
>                             Local2
>                             CreateByteField(Local2, 0x20, BST2)
>                             While(LEqual(BST2, 0x0)) {
>                                 Sleep(0xa)
>                                 Store(\_SB_.PCI_.ISA_.EC__.SMRA, Local1)
>                                 0x11
>                                 Local2
>                             }
>                             Store(0x1f, \_SB_.BAT2._STA)
>                             Or(0x2, Local0, Local0)
>                         }
>                     }
>                     Else {
>                         If(LEqual(\_SB_.BAT2._STA, 0x1f)) {
>                             Store(0xf, \_SB_.BAT2._STA)
>                             Or(0x2, Local0, Local0)
>                         }
>                     }
>                     If(LEqual(Local0, 0x0)) {
>                         Notify(\_SB_.BAT1, 0x80)
>                         Notify(\_SB_.BAT2, 0x80)
>                     }
>                     Else {
>                         If(And(Local0, 0x1, )) {
>                             Notify(\_SB_.BAT1, 0x0)
>                         }
>                         If(And(Local0, 0x2, )) {
>                             Notify(\_SB_.BAT2, 0x0)
>                         }
>                     }
>                 }
>                 Method(_Q24) {
>                     Notify(\_SB_.BAT1, 0x80)
>                 }
>                 Method(_Q25) {
>                     Notify(\_SB_.BAT2, 0x80)
>                 }
>                 Method(_Q26) {
>                     Store(One, \_SB_.PCI_.ISA_.PMGA.BREN)
>                     Notify(\_SB_.AC__, 0x80)
>                 }
>                 Method(_Q27) {
>                     Store(Zero, \_SB_.PCI_.ISA_.PMGA.BREN)
>                     Notify(\_SB_.AC__, 0x80)
>                 }
>                 Method(_Q2A) {
>                     Notify(\_SB_.LID_, 0x80)
>                 }
>                 Method(_Q2B) {
>                     Notify(\_SB_.LID_, 0x80)
>                 }
>                 Method(_Q30) {
>                     \_SB_.PHS_
>                     0x8c
>                 }
>                 Method(_Q31) {
>                     \_SB_.PHS_
>                     0x8d
>                 }
>                 Method(_Q32) {
>                     \_SB_.PHS_
>                     0x8e
>                 }
>                 Method(_Q37) {
>                     If(LNot(\_SB_.PCI_.ISA_.PMGA.DOKS)) {
>                         If(LEqual(\_SB_.PCI_.ISA_.SLCE._STA, 0xf)) {
>                             \_SB_.PCI_.OAK_.SDCK
>                             One
>                             Notify(\_SB_.PCI_.OAK_, 0x0)
>                         }
>                     }
>                 }
>                 Method(_Q39) {
>                     Notify(\_SB_.SLPB, 0x2)
>                 }
>                 Method(_Q3E) {
>                     If(\_SB_.PCI_.CRD0.PMES) {
>                         \_SB_.PCI_.CRD0._PS0
>                     }
>                     If(\_SB_.PCI_.CRD1.PMES) {
>                         \_SB_.PCI_.CRD1._PS0
>                     }
>                     If(\_SB_.PCI_.OAK_._STA) {
>                         If(\_SB_.PCI_.OAK_.CRD0.PMES) {
>                             \_SB_.PCI_.OAK_.CRD0._PS0
>                         }
>                         If(\_SB_.PCI_.OAK_.CRD1.PMES) {
>                             \_SB_.PCI_.OAK_.CRD1._PS0
>                         }
>                     }
>                 }
>                 Method(_Q40) {
>                     Notify(\_TZ_.THM0, 0x80)
>                     Sleep(0x2710)
>                     Notify(\_TZ_.THM0, 0x81)
>                 }
>                 Method(_Q50) {
>                     Notify(\_SB_.PCI_.OAK_, 0x1)
>                 }
>                 Method(_Q51) {
>                     If(LEqual(\_SB_.PCI_.ISA_.PMGA.BAYP, Zero)) {
>                         \_SB_.HKEY.MHKF
>                         Notify(\_SB_.PCI_.ISA_.SLCE, 0x1)
>                     }
>                 }
>                 Method(_Q52) {
>                     \_SB_.PCI_.ISA_.SLCE.SSLC
>                     Zero
>                     \_SB_.PCI_.OAK_.SDCK
>                     One
>                     Notify(\_SB_.PCI_, 0x1)
>                 }
>                 Method(_Q53) {
>                     Store(0x53, Debug)
>                 }
>                 Mutex(SMMB, 0)
>                 Method(SMRA, 2) {
>                     Acquire(SMMB, 0xffff)
>                     Name(INVB, Buffer(0x21) {0xff, 0xff, 0xff, 0xff, 0xff=
, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0=
xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff=
, 0xff, 0xff, 0x0 })
>                     Store(SMBP, 0xb)
>                     Arg0
>                     Arg1
>                     Local0
>                     If(Local0) {
>                         Store(INVB, Local0)
>                     }
>                     Else {
>                         Store(0x0, Local1)
>                         While(LLess(Local1, 0x21)) {
>                             PUTB
>                             INVB
>                             Local1
>                             ECRD
>                             Add(0x54, Local1, )
>                             Increment(Local1)
>                         }
>                         Store(INVB, Local0)
>                     }
>                     Release(SMMB)
>                     Return(Local0)
>                 }
>                 Method(SMBP, 3, Serialized) {
>                     Store(0x1, Local0)
>                     While(Local0) {
>                         ECWR
>                         0x53
>                         Arg2
>                         ECWR
>                         0x52
>                         Arg1
>                         ECWR
>                         0x50
>                         Arg0
>                         While(ECRD) {
>                             0x50
>                             Sleep(0x2)
>                         }
>                         While(LNot(And(ECRD, 0x51, 0xbf))) {
>                             Local1
>                             Sleep(0x2)
>                         }
>                         And(Local1, 0x1f, Local1)
>                         If(LNot(LEqual(Local1, 0x11))) {
>                             Store(0x0, Local0)
>                         }
>                     }
>                     Return(Local1)
>                 }
>                 Method(PUTB, 3) {
>                     CreateByteField(Arg0, Arg1, TIDX)
>                     Store(Arg2, TIDX)
>                 }
>                 Method(GETB, 2) {
>                     CreateByteField(Arg0, Arg1, TIDX)
>                     Return(TIDX)
>                 }
>                 Method(GH8A) {
>                     Store(ECRD, 0xf)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(ACST) {
>                     And(ShiftRight(ECRD, 0x36, 0x4), Zero, 0x1)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(BTST, 1) {
>                     Store(ECRD, Add(Arg0, 0x38, ))
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(SB1I, 1) {
>                     If(Arg0) {
>                         ECWR
>                         0x3a
>                         And(ECRD, 0x3a, 0x7f)
>                         Zero
>                     }
>                     Else {
>                         ECWR
>                         0x3a
>                         Or(ECRD, 0x3a, 0x80)
>                         Zero
>                     }
>                 }
>                 Method(BEEP, 2) {
>                     Store(ECRD, 0x7)
>                     Local0
>                     ECWR
>                     0x7
>                     Arg1
>                     ShiftLeft(0x1, Arg0, Local1)
>                     If(LNot(LGreater(Arg0, 0x7))) {
>                         Store(ECRD, 0x4)
>                         Local2
>                     }
>                     Else {
>                         ShiftRight(Local1, 0x8, Local1)
>                         Store(ECRD, 0x5)
>                         Local2
>                     }
>                     If(And(Local2, Local1, )) {
>                         ECWR
>                         0x6
>                         Arg0
>                         While(LNot(And(ECRD, 0x34, 0x2))) {
>                             Zero
>                         }
>                         While(And(ECRD, 0x34, 0x2)) {
>                             Zero
>                         }
>                     }
>                     ECWR
>                     0x7
>                     Local0
>                 }
>                 Method(GFAN) {
>                     And(ECRD, 0x2f, 0x7)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(SFAN, 1) {
>                     ECWR
>                     0x2f
>                     Or(And(ECRD, 0x2f, 0xf8), Zero, Arg0)
>                     Zero
>                 }
>                 Method(SLED, 2) {
>                     Store(ECRD, 0xd)
>                     Local0
>                     And(Local0, Not(Arg0, ), Local0)
>                     If(And(Arg1, 0x2, )) {
>                         Or(Local0, Arg0, Local0)
>                     }
>                     ECWR
>                     0xd
>                     Local0
>                     Store(ECRD, 0xc)
>                     Local0
>                     And(Local0, Not(Arg0, ), Local0)
>                     If(And(Arg1, 0x1, )) {
>                         Or(Local0, Arg0, Local0)
>                     }
>                     ECWR
>                     0xc
>                     Local0
>                 }
>                 Method(GLED, 1) {
>                     Store(Zero, Local0)
>                     Store(ECRD, 0xc)
>                     Local1
>                     If(And(Local1, Arg0, )) {
>                         Or(Local0, 0x1, Local0)
>                         Store(ECRD, 0xd)
>                         Local1
>                         If(And(Local1, Arg0, )) {
>                             Or(Local0, 0x2, Local0)
>                         }
>                     }
>                     Return(Local0)
>                 }
>                 Method(GLID) {
>                     And(ShiftRight(ECRD, 0x36, 0x2), Zero, 0x1)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(GSST) {
>                     ShiftRight(ECRD, 0x37, 0x7)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(GDID) {
>                     ECWR
>                     0x28
>                     0x80
>                     While(And(ECRD, 0x28, 0x80)) {
>                         Zero
>                         Stall(0x1)
>                     }
>                     And(ECRD, 0x28, 0x7f)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(SISM, 1) {
>                     If(Arg0) {
>                         Store(0x3, Local0)
>                     }
>                     Else {
>                         Store(0x0, Local0)
>                     }
>                     ECWR
>                     0x3b
>                     Or(And(ECRD, 0x3b, 0xfc), Zero, Local0)
>                     Zero
>                 }
>                 Method(GWES) {
>                     Store(ECRD, 0x4e)
>                     Local0
>                     Return(Local0)
>                 }
>                 Method(GTHZ) {
>                     And(ECRD, 0x20, 0x83)
>                     Local0
>                     Return(Local0)
>                 }
>             }
>             Device(SLCE) {
>                 Name(_HID, 0x150cd041)
>                 Name(_UID, 0x4)
>                 Method(_STA) {
>                     If(\_SB_.PCI_.ISA_.EC__.GSST) {
>                         If(LEqual(\_SB_.PCI_.ISA_.PMGA.BAYP, 0x0)) {
>                             Return(0xf)
>                         }
>                     }
>                     Return(0x0)
>                 }
>                 Method(_DCK, 1) {
>                     If(\_SB_.PCI_.OAK_._STA) {
>                         Store(Zero, \_SB_.PCI_.ISA_.PMGA.LOKE)
>                         If(Arg0) {
>                             Store(Zero, \_SB_.PCI_.ISA_.PMGA.DOKC)
>                         }
>                         Else {
>                             Store(One, \_SB_.PCI_.ISA_.PMGA.DOKC)
>                             Store(One, \_SB_.PCI_.ISA_.EC__.BEJP)
>                         }
>                     }
>                     If(Arg0) {
>                         SSLC
>                         Zero
>                         Return(One)
>                     }
>                     Else {
>                         SSLC
>                         One
>                         Return(Zero)
>                     }
>                 }
>                 Method(_EJ0, 1) {
>                     If(\_SB_.PCI_.ISA_.EC__.BEJP) {
>                         Store(One, \_SB_.PCI_.ISA_.PMGA.UDOC)
>                         While(\_SB_.PCI_.ISA_.PMGA.DOKS) {
>                             Sleep(0x1)
>                         }
>                         Store(Zero, \_SB_.PCI_.ISA_.PMGA.UDOC)
>                         Store(Zero, \_SB_.PCI_.ISA_.EC__.BEJP)
>                     }
>                     \_SB_.HKEY.MHKQ
>                     0x4003
>                 }
>                 Method(SSLC, 1) {
>                     If(Arg0) {
>                         Store(One, \_SB_.PCI_.ISA_.SIDE)
>                         If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x80)) {
>                             Zero
>                             \_SB_.PCI_.ISA_.EC__.SB1I
>                             Zero
>                             Notify(\_SB_.BAT2, 0x0)
>                         }
>                         If(LEqual(\_SB_.PCI_.ISA_.SIO_.FDC_._STA, 0xf)) {
>                             Or(And(\_SB_.PCI_.ISA_.SIO_.FDC_.TDR_, 0xf3, =
), 0x4, \_SB_.PCI_.ISA_.SIO_.FDC_.TDR_)
>                         }
>                         \_SB_.PCI_.ISA_.PMGA.SBAY
>                         0x0
>                         Store(One, \_SB_.PCI_.PWR_.GO27)
>                         \_SB_.PCI_.ISA_.EC__.SISM
>                         Zero
>                         \_SB_.PCI_.ISA_.EC__.SLED
>                         0x10
>                         0x0
>                     }
>                     Else {
>                         \_SB_.PCI_.ISA_.PMGA.SBAY
>                         0x1
>                         Store(Zero, \_SB_.PCI_.ISA_.SIDE)
>                         If(And(\_SB_.PCI_.ISA_.EC__.BTST, 0x1, 0x80)) {
>                             Zero
>                             \_SB_.PCI_.ISA_.EC__.SB1I
>                             One
>                             Notify(\_SB_.BAT2, 0x0)
>                         }
>                         If(LNot(\_SB_.PCI_.PWR_.GI13)) {
>                             If(LEqual(\_SB_.PCI_.ISA_.SIO_.FDC_._STA, 0xf=
)) {
>                                 And(\_SB_.PCI_.ISA_.SIO_.FDC_.TDR_, 0xf3,=
 \_SB_.PCI_.ISA_.SIO_.FDC_.TDR_)
>                             }
>                         }
>                         \_SB_.PCI_.ISA_.EC__.SISM
>                         One
>                         Store(Zero, \_SB_.PCI_.PWR_.GO27)
>                         \_SB_.PCI_.ISA_.EC__.SLED
>                         0x10
>                         0x1
>                         Sleep(0x03e8)
>                     }
>                 }
>                 Method(_INI) {
>                     If(\_SB_.PCI_.ISA_.EC__.GSST) {
>                         If(LEqual(\_SB_.PCI_.ISA_.PMGA.BAYP, 0x1)) {
>                             \_SB_.PCI_.ISA_.PMGA.SBAY
>                             0x1
>                             \_SB_.PCI_.ISA_.EC__.SISM
>                             One
>                             Store(Zero, \_SB_.PCI_.PWR_.GO27)
>                             \_SB_.PCI_.ISA_.EC__.SLED
>                             0x10
>                             0x1
>                         }
>                     }
>                 }
>             }
>             Device(MBRD) {
>                 Name(_HID, 0x020cd041)
>                 Name(_UID, 0x1)
>                 Name(RSRC, Buffer(0xaa) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0,=
 0x1, 0x10, 0x47, 0x1, 0x24, 0x0, 0x24, 0x0, 0x1, 0x2, 0x47, 0x1, 0x28, 0x0=
, 0x28, 0x0, 0x1, 0x2, 0x47, 0x1, 0x2c, 0x0, 0x2c, 0x0, 0x1, 0x2, 0x47, 0x1=
, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x38, 0x0, 0x38, 0x0, 0x1, 0x2=
, 0x47, 0x1, 0x3c, 0x0, 0x3c, 0x0, 0x1, 0x2, 0x47, 0x1, 0x50, 0x0, 0x50, 0x=
0, 0x1, 0x4, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x6, 0x47, 0x1, 0x80, 0x=
0, 0x80, 0x0, 0x1, 0x1, 0x47, 0x1, 0x90, 0x0, 0x90, 0x0, 0x1, 0x10, 0x47, 0=
x1, 0xa4, 0x0, 0xa4, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa8, 0x0, 0xa8, 0x0, 0x1, 0=
x2, 0x47, 0x1, 0xac, 0x0, 0xac, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, =
0x0, 0x1, 0x6, 0x47, 0x1, 0xb8, 0x0, 0xb8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xbc, =
0x0, 0xbc, 0x0, 0x1, 0x2, 0x47, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1, 0x40, 0x47, 0=
x1, 0x40, 0x1, 0x40, 0x1, 0x1, 0x10, 0x47, 0x1, 0xea, 0x15, 0xea, 0x15, 0x1=
, 0x6, 0x47, 0x1, 0x0, 0xfe, 0x0, 0xfe, 0x1, 0x10, 0x79, 0x0 })
>                 Method(_CRS) {
>                     CreateWordField(RSRC, 0x8a, PMMN)
>                     CreateWordField(RSRC, 0x8c, PMMX)
>                     And(^^^PWR_.PMBA, 0xfffffffe, PMMN)
>                     Store(PMMN, PMMX)
>                     CreateWordField(RSRC, 0x92, SMMN)
>                     CreateWordField(RSRC, 0x94, SMMX)
>                     And(^^^PWR_.SBBA, 0xfffffffe, SMMN)
>                     Store(SMMN, SMMX)
>                     Return(RSRC)
>                 }
>             }
>             Device(ROM_) {
>                 Name(_HID, 0x020cd041)
>                 Name(_UID, 0x2)
>                 Name(_CRS, Buffer(0x1d) {0x87, 0x18, 0x0, 0x0, 0xc, 0x3, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x79, 0x0 })
>             }
>             Method(_INI) {
>                 \_SB_.PCI_.ISA_.SLCE._INI
>             }
>         }
>         Device(IDE_) {
>             Name(_ADR, 0x00060001)
>             Name(_PSC, 0x0)
>             OperationRegion(PCIC, PCI_Config, 0x0, 0x0100)
>             Field(PCIC, DWordAcc, NoLock, Preserve) {
>                 Offset(0x4),
>                 IOSE,	1,
>                 Offset(0x41),
>                 ,	7,
>                 PIDE,	1,
>                 Offset(0x43),
>                 ,	7,
>                 SIDE,	1
>             }
>             Field(PCIC, DWordAcc, NoLock, Preserve) {
>                 Offset(0x4),
>                 R04_,	32,
>                 Offset(0x20),
>                 R20_,	32,
>                 Offset(0x40),
>                 R40_,	32,
>                 R44_,	32,
>                 R48_,	32
>             }
>             Name(PCMD, 0x0)
>             Name(BMIB, 0x0)
>             Name(IDET, 0x0)
>             Name(SIDT, 0x0)
>             Name(UDMA, 0x0)
>             Name(CRSF, 0x0)
>             Method(_INI) {
>                 Store(Zero, CRSF)
>                 Store(One, \_SB_.PCI_.IDE_.SIDE)
>                 Store(Zero, \_SB_.PCI_.ISA_.SIDE)
>                 \_SB_.PHS_
>                 0x88
>             }
>             Method(_PS0) {
>                 If(LEqual(_PSC, 0x3)) {
>                     If(LEqual(IOSE, Zero)) {
>                         Store(PCMD, R04_)
>                         Store(BMIB, R20_)
>                     }
>                     Store(IDET, R40_)
>                     Store(SIDT, R44_)
>                     Store(UDMA, R48_)
>                     \_SB_.PHS_
>                     0x89
>                 }
>                 Store(Zero, CRSF)
>                 Store(Zero, _PSC)
>             }
>             Method(_PS3) {
>                 If(LAnd(LEqual(_PSC, Zero), LEqual(CRSF, Zero))) {
>                     Store(R04_, PCMD)
>                     Store(R20_, BMIB)
>                     Store(R40_, IDET)
>                     Store(R44_, SIDT)
>                     Store(R48_, UDMA)
>                     Store(One, CRSF)
>                 }
>                 Store(0x3, _PSC)
>             }
>             Device(PRIM) {
>                 Name(_ADR, 0x0)
>                 Method(_STA) {
>                     If(PIDE) {
>                         Return(0xf)
>                     }
>                     Else {
>                         Return(0xd)
>                     }
>                 }
>                 Device(MAST) {
>                     Name(_ADR, 0x0)
>                 }
>                 Device(SLAV) {
>                     Name(_ADR, 0x1)
>                 }
>             }
>             Device(SECN) {
>                 Name(_ADR, 0x1)
>                 Method(_STA) {
>                     If(SIDE) {
>                         Return(0xf)
>                     }
>                     Else {
>                         Return(0xd)
>                     }
>                 }
>                 Device(MAST) {
>                     Name(_ADR, 0x0)
>                     Name(_EJD, "_SB_.PCI_.ISA_.SLCE")
>                     Method(_STA) {
>                         If(LEqual(\_SB_.PCI_.ISA_.SLCE._STA, 0xf)) {
>                             Store(\_SB_.PCI_.ISA_.EC__.GDID, Local0)
>                             If(LNot(LEqual(Local0, 0xf))) {
>                                 Return(0xf)
>                             }
>                         }
>                         Return(0x0)
>                     }
>                 }
>                 Device(SLAV) {
>                     Name(_ADR, 0x1)
>                 }
>             }
>         }
>         Device(USB_) {
>             Name(_ADR, 0x00060002)
>             Name(_PRW, Package(0x2) {
>                 0x8,
>                 0x1,
>             })
>         }
>         Device(PWR_) {
>             Name(_ADR, 0x00060003)
>             OperationRegion(PMC_, SystemIO, 0x00001000, 0x00000038)
>             Field(PMC_, DWordAcc, NoLock, Preserve) {
>                 Offset(0x10),
>                 ,	4,
>                 THTE,	1,
>                 Offset(0x28),
>                 ,	2,
>                 TPOL,	1,
>                 Offset(0x31),
>                 ,	5,
>                 GI13,	1,
>                 Offset(0x37),
>                 ,	3,
>                 GO27,	1
>             }
>             OperationRegion(SMB_, SystemIO, 0x00001040, 0x0000000c)
>             Field(SMB_, ByteAcc, NoLock, Preserve) {
>                 HSTS,	8,
>                 LVTS,	8,
>                 CTLR,	8,
>                 CMDR,	8,
>                 ADDR,	8,
>                 DAT0,	8,
>                 DAT1,	8
>             }
>             OperationRegion(PCI_, PCI_Config, 0x40, 0x60)
>             Field(PCI_, DWordAcc, NoLock, Preserve) {
>                 PMBA,	32,
>                 Offset(0x12),
>                 ,	2,
>                 LPTM,	1,
>                 Offset(0x1f),
>                 ,	7,
>                 LPTE,	1,
>                 Offset(0x23),
>                 ,	1,
>                 LPTA,	2,
>                 Offset(0x50),
>                 SBBA,	32
>             }
>             Mutex(SMMB, 0)
>             Method(RE2R, 1) {
>                 Acquire(SMMB, 0xffff)
>                 Store(Arg0, CMDR)
>                 Store(0x8, CTLR)
>                 Store(0x0, DAT0)
>                 Store(0xa3, ADDR)
>                 Store(0x48, CTLR)
>                 While(LNot(And(HSTS, 0x6, Local0))) {
>                     Stall(0x1)
>                 }
>                 Store(HSTS, HSTS)
>                 Release(SMMB)
>                 If(And(Local0, 0x4, )) {
>                     Return(0xff)
>                 }
>                 Else {
>                     Return(DAT0)
>                 }
>             }
>         }
>         Device(MODM) {
>             Name(_ADR, 0x00070000)
>             Name(_PRW, Package(0x2) {
>                 0xb,
>                 0x4,
>             })
>         }
>     }
>     Device(HKEY) {
>         Name(_HID, 0x68004d24)
>         Name(_STA, 0xf)
>         Name(DHKC, 0x0)
>         Name(DHKB, 0x1)
>         Name(DHKF, 0x0)
>         Mutex(XDHK, 0)
>         Name(DHKW, 0x0)
>         Name(DHKD, 0x0)
>         Method(MHKC, 1) {
>             Store(Arg0, DHKC)
>         }
>         Method(MHKP) {
>             Acquire(XDHK, 0xffff)
>             Store(Zero, Local1)
>             If(DHKW) {
>                 Store(DHKW, Local1)
>                 Store(Zero, DHKW)
>             }
>             Else {
>                 If(DHKD) {
>                     Store(DHKD, Local1)
>                     Store(Zero, DHKD)
>                 }
>             }
>             Release(XDHK)
>             Return(Local1)
>         }
>         Method(MHKE, 1) {
>             Acquire(XDHK, 0xffff)
>             Store(Arg0, DHKB)
>             If(LEqual(DHKB, 0x0)) {
>                 Store(Zero, DHKW)
>                 Store(Zero, DHKD)
>                 Store(Zero, DHKF)
>             }
>             Release(XDHK)
>         }
>         Method(MHKQ, 1) {
>             Acquire(XDHK, 0xffff)
>             If(DHKB) {
>                 If(DHKC) {
>                     If(LAnd(LNot(LLess(Arg0, 0x2000)), LLess(Arg0, 0x3000=
))) {
>                         If(DHKF) {
>                             Store(Zero, DHKF)
>                             Store(Arg0, DHKW)
>                         }
>                     }
>                     If(LAnd(LNot(LLess(Arg0, 0x4000)), LLess(Arg0, 0x5000=
))) {
>                         Store(Arg0, DHKD)
>                     }
>                     Notify(HKEY, 0x80)
>                 }
>             }
>             Release(XDHK)
>         }
>         Method(MHKF) {
>             Acquire(XDHK, 0xffff)
>             If(LEqual(DHKB, 0x0)) {
>                 If(DHKC) {
>                     Store(One, DHKF)
>                 }
>             }
>             Release(XDHK)
>         }
>     }
> }
> Name(SSLV, 0x0)
> Name(DOKS, 0x0)
> Name(SSST, 0xf)
> Method(_WAK, 1) {
>     Store(0x0, \SSLV)
>     Store(Zero, Local0)
>     \_SB_.PHS2
>     0x8f
>     Or(Arg0, 0x80, )
>     If(\_SB_.PCI_.ISA_.EC__.ACST) {
>         Store(One, \_SB_.PCI_.ISA_.PMGA.BREN)
>     }
>     Else {
>         Store(Zero, \_SB_.PCI_.ISA_.PMGA.BREN)
>     }
>     If(\_SB_.PCI_.ISA_.EC__.GSST) {
>         If(LNot(\SSST)) {
>             \_SB_.PCI_.ISA_.SLCE.SSLC
>             Zero
>             Store(One, Local0)
>         }
>     }
>     If(LNot(LEqual(\_SB_.PCI_.OAK_._STA, \DOKS))) {
>         Store(One, Local0)
>     }
>     \_SB_.PCI_.OAK_.SDCK
>     One
>     If(Local0) {
>         Notify(\_SB_.PCI_, 0x1)
>     }
>     If(LEqual(Arg0, 0x4)) {
>         Store(One, \_SB_.PCI_.IDE_.SIDE)
>         Store(Zero, \_SB_.PCI_.ISA_.SIDE)
>         Notify(\_SB_.SLPB, 0x2)
>     }
>     If(LOr(LEqual(Arg0, 0x1), LEqual(Arg0, 0x3))) {
>         \_SB_.HKEY.MHKE
>         0x1
>         \_SB_.HKEY.MHKQ
>         Or(ShiftLeft(Or(Arg0, 0x20, ), 0x8, ), 0x4, )
>     }
>     Return(Package(0x2) {
>         0x0,
>         0x0,
>     })
> }
> Method(_PTS, 1) {
>     Store(Arg0, \SSLV)
>     If(LEqual(\_SB_.PCI_.IDE_.CRSF, Zero)) {
>         Store(\_SB_.PCI_.IDE_.R04_, \_SB_.PCI_.IDE_.PCMD)
>         Store(\_SB_.PCI_.IDE_.R20_, \_SB_.PCI_.IDE_.BMIB)
>         Store(\_SB_.PCI_.IDE_.R40_, \_SB_.PCI_.IDE_.IDET)
>         Store(\_SB_.PCI_.IDE_.R44_, \_SB_.PCI_.IDE_.SIDT)
>         Store(\_SB_.PCI_.IDE_.R48_, \_SB_.PCI_.IDE_.UDMA)
>         Store(One, \_SB_.PCI_.IDE_.CRSF)
>     }
>     If(LAnd(LNot(LLess(Arg0, 0x1)), LNot(LGreater(Arg0, 0x4)))) {
>         Store(\_SB_.PCI_.OAK_._STA, \DOKS)
>         Store(LNot(\_SB_.PCI_.ISA_.PMGA.BAYP), \SSST)
>         \_SB_.PCI_.ISA_.EC__.SLED
>         0x80
>         0x3
>         If(LNot(LLess(Arg0, 0x3))) {
>             \_SB_.PCI_.ISA_.EC__.SLED
>             0x1
>             0x0
>         }
>     }
>     If(LOr(LEqual(Arg0, 0x1), LEqual(Arg0, 0x3))) {
>         \_SB_.HKEY.MHKE
>         0x0
>     }
>     \_SB_.PHS2
>     0x8f
>     Arg0
> }
> BOOT: Lenth=3D39, Revision=3D1, Checksum=3D165,
> 	OEMID=3DPTLTD, OEM Table ID=3D$SBFTBL$, OEM Revision=3D0x6040000,
> 	Creator ID=3D LTP, Creator Revision=3D0x1



--=20
            Yes, I've heard of "decaf." What's your point?

--dDRMvlgZJXvWKvBx
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename="acpi_cmbat.c.patch"

--- acpi_cmbat.c.orig	Mon Mar  5 11:56:19 2001
+++ acpi_cmbat.c	Mon Mar  5 11:50:34 2001
@@ -67,6 +67,10 @@
 
 #define PKG_GETINT(res, tmp, idx, dest, label) do {			\
 	tmp = &res->Package.Elements[idx];				\
+	if (tmp == NULL) {						\
+		device_printf(dev, "sc == NULL");			\
+		goto label ;						\
+	}								\
 	if (tmp->Type != ACPI_TYPE_INTEGER)				\
 		goto label ;						\
 	dest = tmp->Integer.Value;					\

--dDRMvlgZJXvWKvBx--
