From owner-acpi-jp@jp.FreeBSD.org Tue Nov 26 18:59:55 2002
Received: (from daemon@localhost)
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) id gAQ9xto21846;
	Tue, 26 Nov 2002 18:59:55 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from vbook.express.ru (asplinux.ru [195.133.213.194])
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) with ESMTP/inet id gAQ9xr221841
	for <acpi-jp@jp.freebsd.org>; Tue, 26 Nov 2002 18:59:53 +0900 (JST)
	(envelope-from vova@sw.ru)
Received: from vova by vbook.express.ru with local (Exim 4.10)
	id 18GcVQ-0000Dw-00
	for acpi-jp@jp.freebsd.org; Tue, 26 Nov 2002 12:59:48 +0300
From: "Vladimir B. "Grebenschikov <vova@sw.ru>
To: acpi-jp@jp.FreeBSD.org
In-Reply-To: <20021121.194205.48537091.iwasaki@jp.FreeBSD.org>
References: <20021121.194205.48537091.iwasaki@jp.FreeBSD.org>
Content-Type: multipart/mixed; boundary="=-sXMtsuFS4cZ5v/loDMdz"
Organization: SWsoft Inc.
Message-Id: <1038304785.734.9.camel@vbook>
Mime-Version: 1.0
X-Mailer: Ximian Evolution 1.1.2 (Preview Release)
Reply-To: acpi-jp@jp.FreeBSD.org
Precedence: list
Date: 26 Nov 2002 12:59:47 +0300
X-Sequence: acpi-jp 1980
Subject: [acpi-jp 1980] Re: Call for testers: acpica-unix-20021118.tar.gz
Errors-To: owner-acpi-jp@jp.FreeBSD.org
Sender: owner-acpi-jp@jp.FreeBSD.org
X-Originator: vova@sw.ru
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+021111


--=-sXMtsuFS4cZ5v/loDMdz
Content-Type: text/plain; charset=KOI8-R
Content-Transfer-Encoding: quoted-printable

=F7 Thu, 21.11.2002, =D7 13:42, Mitsuru IWASAKI =CE=C1=D0=C9=D3=C1=CC:
> Hi all,
>=20
> I've made patches for the latest ACPI CA snapshot between 20021002 and
> 20021118.
> http://people.freebsd.org/~iwasaki/acpi/acpica-20021002-20021118-test2002=
1121.diff
>=20
> A lot of bugs are fixed, please check the change log at:
> http://developer.intel.com/technology/iapc/acpi/downloads/CHANGES.txt


Have tried it on VAIO PCG-z505S

acpiconf -s1 panics system:

Fatal trap 12: page fault while in kernel mode
fault vistray irq 7
rtual address	=3D 0x0
fault code		=3D supervisor read, page not present
instruction pointer	=3D 0x8:0xc02f4ed1
stack pointer	        =3D 0x10:0xcb776978
frame pointer	        =3D 0x10:0xcb776990
code segment		=3D base 0x0, limit 0xfffff, type 0x1b
			=3D DPL 0, pres 1, def32 1, gran 1
processor eflags	=3D interrupt enabled, resume, IOPL =3D 0
current process		=3D 692 (acpiconf)
kernel: type 12 trap, code=3D0
Stopped at      scsuspend+0x11: movl    0(%eax),%eax
db> stray irq 7
stray irq 7
stray irq 7
stray irq 7
got 5 stray irq 7's: not logging anymore

db> trace
scsuspend(c1bb2200,c1b50058,c032cbec,0,c1b22058) at scsuspend+0x11
bus_generic_suspend(c1ba5880,c1b22058,c032cbec,0,c1b4d058) at
bus_generic_suspend+0x59
bus_generic_suspend(c1ba7180,c1b4d058,c032cbec,0,c1b7a058) at
bus_generic_suspend+0x59
bus_generic_suspend(c1ba7480,c1b7a058,c032cbec,c09ca400,c1b79058) at
bus_generic_suspend+0x59
bus_generic_suspend(c09ca380,c1b79058,c032cbec,0,c1b69058) at
bus_generic_suspend+0x59
bus_generic_suspend(c09ca800,c1b69058,c032cbec,0,c1b33058) at
bus_generic_suspend+0x59
bus_generic_suspend(c09c9800,c1b33058,c032cbec,c1b7e580,c09ca780) at
bus_generic_suspend+0x59
bus_generic_suspend(c09c9a80,c1b16058,c032cbec,0,4040000) at
bus_generic_suspend+0x59
acpi_SetSleepState(c09ca780,1,c01b399d,c048c000,cb776b34) at
acpi_SetSleepState+0x106
acpiioctl(c03611cc,80045003,cb776c48,3,c1c528c0) at acpiioctl+0xb2
spec_ioctl(cb776b34,cb776c00,c0233e3e,cb776b34,cbefda80) at
spec_ioctl+0x16b
spec_vnoperate(cb776b34,cbefda80,cb776b54,c02a7143,c033a8e0) at
spec_vnoperate+0x18
vn_ioctl(c236d564,80045003,cb776c48,c23ea500,c1c528c0) at vn_ioctl+0xae
ioctl(c1c528c0,cb776d10,c,c1c528c0,3) at ioctl+0x122
syscall(2f,2f,2f,1,2) at syscall+0x15d
Xint0x80_syscall() at Xint0x80_syscall+0x1d
--- syscall (54, FreeBSD ELF32, ioctl), eip =3D 0x280af2d3, esp =3D
0xbfbff85c, ebp =3D 0xbfbff878 ---
db>=20

part of ps output:

  37 c1c50588 cb751000    0     0     0 0000204 norm[SLPQ  syncer
c033bb8c][SLP] syncer
   36 c1c50760 cb752000    0     0     0 0000204 norm[SLPQ  vlruwt
c1c50760][SLP] vnlru
   35 c1c50938 cb753000    0     0     0 0000204 norm[SLPQ  psleep
c03668c4][SLP] bufdaemon
   34 c1c50b10 cb754000    0     0     0 000020c norm[SLPQ  pgzero
c0369bc4][SLP] pagezero
   33 c1c50ce8 cb755000    0     0     0 0000204 norm[SLPQ  psleep
c0369bdc][SLP] vmdaemon
    9 c1c53000 cb78c000    0     0     0 0000204 norm[SLPQ  psleep
c03496f8][SLP] pagedaemon
   32 c1c531d8 cb78d000    0     0     0 0000204 new [IWAIT] irq8: rtc
   31 c1b90588 cb205000    0     0     0 0000204 new [IWAIT] irq0: clk
   30 c1b90760 cb23c000    0     0     0 0000204 new [IWAIT] irq10: sio1
   29 c1b90938 cb23d000    0     0     0 0000204 new [IWAIT] irq4: sio0
   28 c1b90b10 cb23e000    0     0     0 0000204 norm[IWAIT] swi0:
tty:sio
   27 c1b90ce8 cb23f000    0     0     0 0000204 new [IWAIT] irq12: psm0
   26 c1baf000 cb245000    0     0     0 0000204 norm[IWAIT] irq1:
atkbd0
    8 c1baf1d8 cb246000    0     0     0 0000204 norm[CVQ  cbb cv
c1b8f74c][SLP] cbb0
   25 c1baf3b0 cb247000    0     0     0 0000204 norm[SLPQ  usbtsk
c0446a1c][SLP] usbtask
   24 c1baf588 cb248000    0     0     0 0000204 norm[SLPQ  usbevt
c1b85210][SLP] usb0
   23 c1baf760 cb249000    0     0     0 0000204 norm[IWAIT] irq15: ata1
   22 c1baf938 cb24a000    0     0     0 0000204 norm[IWAIT] irq14: ata0
   21 c09dd1d8 caa2a000    0     0     0 0000204 norm[SLPQ  nothing
c048d514][SLP] acpi_thermal
    7 c09dd3b0 caa2b000    0     0     0 0000204 norm[SLPQ  actask
c048cefc][SLP] acpi_task2
    6 c09dd588 caa2c000    0     0     0 0000204 norm[SLPQ  actask
c048cefc][SLP] acpi_task1
    5 c09dd760 caa2d000    0     0     0 0000204 norm[SLPQ  actask
c048cefc][SLP] acpi_task0
   20 c09dd938 caa2e000    0     0     0 0000204 norm[RUNQ] irq9: cbb0
fxp0++++
   19 c09ddb10 caa2f000    0     0     0 0000204 new [IWAIT] irq13:
   18 c09ddce8 caa30000    0     0     0 0000204 norm[IWAIT] swi5:
acpitaskq
   17 c1b90000 cb202000    0     0     0 0000204 new [IWAIT] swi5: task
queue
   16 c1b901d8 cb203000    0     0     0 0000204 new [IWAIT] swi3:
cambio
   15 c1b903b0 cb204000    0     0     0 0000204 new [IWAIT] swi2:
camnet
   14 c09d6000 ca9b5000    0     0     0 0000204 norm[SLPQ   sleep
c03531c0][SLP] random
    4 c09d61d8 caa22000    0     0     0 0000204 norm[SLPQ  g_down
c0334d50][SLP] g_down
    3 c09d63b0 caa23000    0     0     0 0000204 norm[SLPQ    g_up
c0334d4c][SLP] g_up
    2 c09d6588 caa24000    0     0     0 0000204 norm[SLPQ  g_events
c0334d44][SLP] g_event
   13 c09d6760 caa25000    0     0     0 0000204 norm[IWAIT] swi1: net
   12 c09d6938 caa26000    0     0     0 0000204 new [IWAIT] swi4: vm
   11 c09d6b10 caa27000    0     0     0 000020c norm[RUNQ] swi6:
tty:sio clock
   10 c09d6ce8 caa28000    0     0     0 000020c norm[Can run] idle
    1 c09dd000 caa29000    0     0     1 0004200 norm[SLPQ    wait
c09dd000][SLP] init
    0 c03360a0 c04bd000    0     0     0 0000200 norm[SLPQ   sched
c03360a0][SLP] swapper


> Thanks

--=20
Vladimir B. Grebenschikov <vova@sw.ru>
SWsoft Inc.

--=-sXMtsuFS4cZ5v/loDMdz
Content-Disposition: attachment; filename=acpidump
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; name=acpidump; charset=KOI8-R

/*
RSD PTR: Checksum=3D130, OEMID=3DPTLTD, RsdtAddress=3D0x0bffd0dd
 */
/*
RSDT: Length=3D40, Revision=3D1, Checksum=3D148,
	OEMID=3DPTLTD, OEM Table ID=3D  RSDT, OEM Revision=3D0x0,
	Creator ID=3D LTP, Creator Revision=3D0x0
 */
/*
	Entries=3D{ 0x0bfffb8c }
 */
/*
	DSDT=3D0xbffd105
	INT_MODEL=3DPIC
	SCI_INT=3D9
	SMI_CMD=3D0xb2, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1, S4BIOS_REQ=3D0x0
	PM1a_EVT_BLK=3D0x8000-0x8003
	PM1a_CNT_BLK=3D0x8042-0x8043
	PM2_TMR_BLK=3D0x8008-0x800b
	PM2_GPE0_BLK=3D0x800c-0x800f
	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}
 */
/*
DSDT: Length=3D10887, Revision=3D1, Checksum=3D244,
	OEMID=3DSONY, OEM Table ID=3D, OEM Revision=3D0x0,
	Creator ID=3DMSFT, Creator Revision=3D0x1000007
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "SONY",		//OEMID
    "",		//TABLE ID
    0x0		//OEM Revision
)

{
Scope(_PR_) {
    Processor(CPU0, 0, 0x8010, 0x6) {
    }
}
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,
})
OperationRegion(GPO_, SystemIO, 0x8034, 0x4)
Field(GPO_, DWordAcc, NoLock, Preserve) {
    GO00,	1,
    GO01,	1,
    GO02,	1,
    GO03,	1,
    GO04,	1,
    GO05,	1,
    GO06,	1,
    GO07,	1,
    GO08,	1,
    GO09,	1,
    GO10,	1,
    GO11,	1,
    GO12,	1,
    GO13,	1,
    GO14,	1,
    GO15,	1,
    GO16,	1,
    GO17,	1,
    GO18,	1,
    GO19,	1,
    GO20,	1,
    GO21,	1,
    GO22,	1,
    GO23,	1,
    GO24,	1,
    GO25,	1,
    GO26,	1,
    GO27,	1,
    GO28,	1,
    GO29,	1,
    GO30,	1,
    GO31,	1
}
Mutex(MLAT, 0)
Method(GLAT) {
    Acquire(MLAT, 0xffff)
    Store(One, GO14)
    Store(Zero, GO14)
    Release(MLAT)
}
OperationRegion(GLBL, SystemIO, 0x8028, 0x4)
Field(GLBL, DWordAcc, NoLock, Preserve) {
    Offset(0x3),
    ,	1,
    LPOL,	1
}
OperationRegion(SMI0, SystemMemory, 0x0bfffdbc, 0x00000200)
Field(SMI0, AnyAcc, NoLock, Preserve) {
    BCMD,	8,
    DID_,	32,
    INFO,	4000
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFB,	8
}
Field(SMI0, AnyAcc, NoLock, Preserve) {
    Offset(0x5),
    INFD,	32
}
OperationRegion(SMI1, SystemIO, 0x00008040, 0x00000002)
Field(SMI1, AnyAcc, NoLock, Preserve) {
    SMIC,	8
}
Mutex(MPHS, 0)
Method(PHS0, 1) {
    Store(Arg0, BCMD)
    Store(Zero, SMIC)
    While(LEqual(BCMD, Arg0)) {
    }
    Store(0x0, BCMD)
}
Method(PHS_, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    PHS0(Arg0)
    Store(INFD, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PHSB, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(0x0, DID_)
    Store(Arg1, INFB)
    PHS0(Arg0)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSCS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x0)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSSS, 2, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    Store(Arg1, INFO)
    PHS0(0x1)
    Release(MPHS)
}
Method(PSPS, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x2)
    Store(INFO, Local0)
    Release(MPHS)
    Return(Local0)
}
Method(PSDI, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x3)
    Release(MPHS)
}
Method(PSST, 1, Serialized) {
    Acquire(MPHS, 0xffff)
    Store(Arg0, DID_)
    PHS0(0x4)
    Store(INFB, Local0)
    Release(MPHS)
    Return(Local0)
}
Scope(\_GPE) {
    Method(_E09) {
        \_SB_.PCI0.ISA_.EC__.SCID()
    }
    Method(_L0A) {
        Store("Generated SWI", Debug)
        Notify(\_SB_.PCI0, 0x2)
    }
    Name(_PRW, Package(0x2) {
        0xb,
        0x4,
    })
}
Scope(_SB_) {
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Name(_PRW, Package(0x2) {
            0xb,
            0x4,
        })
        Method(_STA) {
            Return(0xf)
        }
        Method(_PS3) {
            Store(One, GO11)
        }
    }
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(_BBN, 0x0)
        Name(_PRT, Package(0x7) {
            Package(0x4) {
                0x0007ffff,
                0x3,
                LNKD,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x0,
                LNKC,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x0,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x0,
                LNKA,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x1,
                LNKB,
                0x0,
            },
            Package(0x4) {
                0x0006ffff,
                0x0,
                LNKA,
                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, 0x0,=
 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0=
x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x=
0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x=
0, 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, 0=
x80, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x=
0, 0x0, 0x87, 0x18, 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, 0=
x87, 0x18, 0x0, 0x0, 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, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x7f, 0=
xd, 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, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x=
3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0,=
 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0=
x0, 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, 0=
x0, 0x0, 0x40, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4=
0, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x80, 0xe, 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0=
x0, 0x0, 0x87, 0x18, 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, 0=
x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8=
, 0xc, 0x1, 0x8, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0=
xc, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0,=
 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
        Method(_CRS, 0, Serialized) {
            Store(Zero, Local1)
            If(T_EN) {
                ShiftLeft(0x1, Add(T_SZ, 0x11, ), Local1)
            }
            CreateDWordField(RSRC, 0x017a, BTMN)
            CreateDWordField(RSRC, 0x017e, BTMX)
            CreateDWordField(RSRC, 0x0186, 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, 0x0195, ATMN)
            CreateDWordField(RSRC, 0x0199, ATMX)
            CreateDWordField(RSRC, 0x01a1, 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, 0x0188, C0RW)
            CreateDWordField(RSRC, 0x36, C0MN)
            CreateDWordField(RSRC, 0x3a, C0MX)
            CreateDWordField(RSRC, 0x42, 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, 0x0260, C4RW)
            CreateDWordField(RSRC, 0x51, C4MN)
            CreateDWordField(RSRC, 0x55, C4MX)
            CreateDWordField(RSRC, 0x5d, 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, 0x0338, C8RW)
            CreateDWordField(RSRC, 0x6c, C8MN)
            CreateDWordField(RSRC, 0x70, C8MX)
            CreateDWordField(RSRC, 0x78, 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, 0x0410, CCRW)
            CreateDWordField(RSRC, 0x87, CCMN)
            CreateDWordField(RSRC, 0x8b, CCMX)
            CreateDWordField(RSRC, 0x93, 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, 0x04e8, D0RW)
            CreateDWordField(RSRC, 0xa2, D0MN)
            CreateDWordField(RSRC, 0xa6, D0MX)
            CreateDWordField(RSRC, 0xae, 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, 0x05c0, D4RW)
            CreateDWordField(RSRC, 0xbd, D4MN)
            CreateDWordField(RSRC, 0xc1, D4MX)
            CreateDWordField(RSRC, 0xc9, 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, 0x0698, D8RW)
            CreateDWordField(RSRC, 0xd8, D8MN)
            CreateDWordField(RSRC, 0xdc, D8MX)
            CreateDWordField(RSRC, 0xe4, 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, 0x0770, DCRW)
            CreateDWordField(RSRC, 0xf3, DCMN)
            CreateDWordField(RSRC, 0xf7, DCMX)
            CreateDWordField(RSRC, 0xff, 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, 0x0848, E0RW)
            CreateDWordField(RSRC, 0x010e, E0MN)
            CreateDWordField(RSRC, 0x0112, E0MX)
            CreateDWordField(RSRC, 0x011a, 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, 0x0920, E4RW)
            CreateDWordField(RSRC, 0x0129, E4MN)
            CreateDWordField(RSRC, 0x012d, E4MX)
            CreateDWordField(RSRC, 0x0135, 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, 0x09f8, E8RW)
            CreateDWordField(RSRC, 0x0144, E8MN)
            CreateDWordField(RSRC, 0x0148, E8MX)
            CreateDWordField(RSRC, 0x0150, 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, 0x0ad0, ECRW)
            CreateDWordField(RSRC, 0x015f, ECMN)
            CreateDWordField(RSRC, 0x0163, ECMX)
            CreateDWordField(RSRC, 0x016b, 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)
        }
        Device(USB0) {
            Name(_ADR, 0x00070002)
            OperationRegion(CFG2, PCI_Config, 0x0, 0x0100)
            Field(CFG2, DWordAcc, NoLock, Preserve) {
                Offset(0x20),
                USBB,	16
            }
            Method(_STA) {
                And(USBB, 0xffe0, Local0)
                If(LEqual(Local0, 0x0)) {
                    Return(0x0)
                }
                Else {
                    Return(0xf)
                }
            }
            Name(_PSC, 0x0)
            Method(_PS0) {
                If(LEqual(_PSC, 0x3)) {
                    PHS_(0xf2)
                    Store(0x0, _PSC)
                }
            }
            Method(_PS3) {
                If(LEqual(_PSC, 0x0)) {
                    PHS_(0xf1)
                    Store(0x3, _PSC)
                }
            }
        }
        Device(PWR_) {
            Name(_ADR, 0x00070003)
            OperationRegion(PCI_, PCI_Config, 0x50, 0x28)
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                Offset(0x1),
                ,	4,
                FDCM,	1,
                ,	1,
                U1M_,	1,
                Offset(0x2),
                U2M_,	1,
                ,	1,
                LPTM,	1,
                Offset(0xc),
                MDIE,	1,
                MDIA,	2,
                SBE_,	1,
                GME_,	1,
                SBA_,	2,
                MSSE,	1,
                MSSA,	2,
                Offset(0xf),
                ,	1,
                AUDM,	1,
                ,	2,
                KBCM,	1,
                G12M,	1,
                G13M,	1,
                LPTE,	1,
                G09A,	16,
                G09L,	4,
                ,	1,
                G09M,	1,
                G09E,	1,
                Offset(0x13),
                ,	1,
                LPTA,	2,
                ,	1,
                FDCA,	1,
                FDCE,	1,
                KBCE,	1,
                GMM_,	1,
                G10A,	16,
                G10L,	4,
                ,	1,
                G10M,	1,
                G10E,	1,
                G10C,	1,
                U1A_,	3,
                U1E_,	1,
                U2A_,	3,
                U2E_,	1,
                G12A,	16,
                G12L,	4,
                G12E,	1,
                Offset(0x20),
                G13A,	16,
                G13L,	4,
                G13E,	1
            }
        }
        Device(IDE_) {
            Name(_ADR, 0x00070001)
            OperationRegion(PCI_, PCI_Config, 0x40, 0x10)
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                Offset(0x3),
                ,	7,
                SIDE,	1
            }
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                R40_,	32,
                Offset(0x8),
                R48_,	32
            }
            Device(PRIM) {
                Name(_ADR, 0x0)
                Method(_STA) {
                    Return(0xf)
                }
                Method(_STM, 2) {
                }
                Device(MAST) {
                    Name(_ADR, 0x0)
                    Method(_STA) {
                        Return(PHSB(0xe3, 0x0))
                    }
                    Name(_PSC, 0x0)
                }
            }
            Device(SECN) {
                Name(_ADR, 0x1)
                Method(_STA) {
                    Return(0xf)
                }
                Method(_STM, 2) {
                }
                Device(MAST) {
                    Name(_ADR, 0x0)
                    Method(_STA) {
                        Return(PHSB(0xe3, 0x1))
                    }
                    Name(_PSC, 0x0)
                }
            }
            Name(_PSC, 0x0)
            Name(IDET, 0x0)
            Name(UDMA, 0x0)
            Method(_PS0) {
                If(LEqual(_PSC, 0x3)) {
                    Store(IDET, R40_)
                    Store(UDMA, R48_)
                    PHS_(0xf0)
                    PHS_(0xf9)
                }
                Store(0x0, _PSC)
            }
            Method(_PS3) {
                Store(R40_, IDET)
                Store(R48_, UDMA)
                Store(0x3, _PSC)
            }
        }
        Device(VID0) {
            Name(_ADR, 0x00080000)
            Method(_STA) {
                Return(0xf)
            }
        }
        Device(AUD0) {
            Name(_ADR, 0x00080001)
            Name(_STA, 0xf)
            Name(_PSC, 0x0)
            Method(_PS0) {
                Store(Zero, GO11)
                Store(0x0, _PSC)
            }
            Method(_PS3) {
                Store(One, GO11)
                Store(0x3, _PSC)
            }
        }
        Device(SD94) {
            Name(_ADR, 0x00090000)
            Name(_STA, 0xf)
            OperationRegion(SPCI, PCI_Config, 0x0, 0x0100)
            Field(SPCI, DWordAcc, NoLock, Preserve) {
                Offset(0x4),
                COMD,	8,
                Offset(0xc),
                CALS,	8,
                LATI,	8,
                Offset(0x10),
                MADR,	32,
                Offset(0x2c),
                SSID,	32,
                Offset(0x3c),
                IRQN,	8,
                Offset(0x4c),
                ESID,	8,
                Offset(0xe0),
                PWST,	8
            }
            Name(SSAV, Package(0x3) {
            })
            Name(_PSC, 0x0)
            Method(_PS0) {
                Store(0x0, PWST)
                Sleep(0x1)
                Store(0x8, CALS)
                Store(0x40, LATI)
                Store(0x1, ESID)
                Store(0x8054104d, SSID)
                Store(0x0, ESID)
                If(LEqual(_PSC, 0x3)) {
                    Store(DerefOf(Index(SSAV, 0x0, )), COMD)
                    Store(DerefOf(Index(SSAV, 0x1, )), MADR)
                    Store(DerefOf(Index(SSAV, 0x2, )), IRQN)
                }
                Store(0x0, _PSC)
            }
            Method(_PS3) {
                If(LEqual(_PSC, 0x0)) {
                    Store(COMD, Index(SSAV, 0x0, ))
                    Store(MADR, Index(SSAV, 0x1, ))
                    Store(IRQN, Index(SSAV, 0x2, ))
                }
                Store(0x3, _PSC)
            }
        }
        Device(CRD0) {
            Name(_ADR, 0x000a0000)
            Name(_PRW, Package(0x2) {
                0xa,
                0x3,
            })
            OperationRegion(CCRD, PCI_Config, 0x0, 0xe4)
            Field(CCRD, DWordAcc, NoLock, Preserve) {
                Offset(0x4),
                CD04,	32,
                Offset(0x3e),
                CD3E,	32,
                Offset(0x44),
                CD44,	32,
                Offset(0x82),
                CD82,	8,
                Offset(0xe0),
                CDE0,	8,
                CDE1,	8
            }
            OperationRegion(EXCA, SystemIO, 0x03e0, 0x2)
            Field(EXCA, ByteAcc, NoLock, Preserve) {
                INDX,	8,
                DATA,	8
            }
            IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                Offset(0x3),
                ,	7,
                ERIB,	1
            }
            Method(_INI) {
                Store(Zero, CDE0)
                Store(Zero, CD04)
                Store(Zero, CD3E)
                Store(One, CD44)
            }
            Method(_STA) {
                Return(0xf)
            }
            Name(_PSC, 0x0)
            Method(PSX_, 1) {
                Store(0x0, CDE0)
                Store(0x03e0, CD44)
                Store(One, ERIB)
                Store(0x0, CD44)
                Store(Arg0, CDE0)
                Store(Arg0, _PSC)
            }
            Method(_PS0) {
                Store(0x0, _PSC)
            }
            Method(_PS1) {
                PSX_(0x1)
                Or(CDE1, 0x1, CDE1)
            }
            Method(_PS2) {
                PSX_(0x2)
                Or(CDE1, 0x1, CDE1)
            }
            Method(_PS3) {
                PSX_(0x3)
                Or(CDE1, 0x1, CDE1)
            }
            Method(_PSW, 1) {
                If(Arg0) {
                    Store(0x0, GO03)
                }
                Else {
                    Store(0x1, GO03)
                }
                GLAT()
            }
        }
        Device(MODE) {
            Name(_ADR, 0x000b0000)
            Name(_STA, 0xf)
            Name(_PRW, Package(0x2) {
                0xa,
                0x4,
            })
        }
        Device(ETHR) {
            Name(_ADR, 0x00060000)
            OperationRegion(EPCI, PCI_Config, 0x0, 0x0100)
            Field(EPCI, DWordAcc, NoLock, Preserve) {
                Offset(0x4),
                ET04,	8,
                Offset(0xc),
                ET0C,	16,
                Offset(0xe0),
                Z000,	16
            }
            Method(_STA) {
                Return(0xf)
            }
            Name(_PSC, 0x0)
            Method(_PS0) {
                Store(0x0, Z000)
                Store(0x0, _PSC)
                Store(0x17, ET04)
                Store(0x4208, ET0C)
            }
            Method(_PS3) {
                Store(0x3, _PSC)
            }
        }
        Name(_PRW, Package(0x2) {
            0xa,
            0x4,
        })
        Device(ISA_) {
            Name(_ADR, 0x00070000)
            OperationRegion(PIRX, PCI_Config, 0x60, 0x4)
            Field(PIRX, ByteAcc, NoLock, Preserve) {
                PIRA,	8,
                PIRB,	8,
                PIRC,	8,
                PIRD,	8
            }
            Device(MOTH) {
                Name(_HID, 0x020cd041)
                Name(_CRS, Buffer(0x32) {0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0=
x1, 0x1, 0x47, 0x1, 0xb2, 0x0, 0xb2, 0x0, 0x1, 0x2, 0x47, 0x1, 0xd0, 0x4, 0=
xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x80, 0x21, 0x80, 0x21, 0x1, 0x10, 0x47, 0x1=
, 0x0, 0x80, 0x0, 0x80, 0x1, 0x50, 0x47, 0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x=
2, 0x79, 0x0 })
            }
            Device(MEM_) {
                Name(_HID, 0x010cd041)
                Name(MSRC, Buffer(0x3e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x1=
0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0x0, 0x40, 0x0, 0x0=
, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0=
x0, 0x0, 0x0, 0x0, 0xf8, 0xff, 0x0, 0x0, 0x8, 0x0, 0x79, 0x0 })
                Method(_CRS) {
                    CreateDWordField(MSRC, 0x8, MEMS)
                    If(LNot(MEMS)) {
                        Store(PHS_(0xef), MEMS)
                    }
                    Return(MSRC)
                }
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(DMAC) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1=
, 0x10, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0xf, 0x47, 0x1, 0xc0, 0x0, 0x=
c0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(RTC_) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x=
1, 0x2, 0x22, 0x0, 0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0=
x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x79, 0=
x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(FPU_) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x=
1, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x=
1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x=
1, 0x1, 0x79, 0x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(KBC_) {
                Name(_HID, 0x0303d041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0=
x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x79, 0=
x0 })
                Method(_STA) {
                    Return(0xf)
                }
            }
            Device(MOUE) {
                Name(_HID, 0x130fd041)
                Name(_CRS, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
            }
            Device(EC__) {
                Name(_HID, 0x050ad041)
                OperationRegion(SMC1, SystemIO, 0x0370, 0x2)
                Field(SMC1, ByteAcc, NoLock, Preserve) {
                    INDX,	8,
                    DATA,	8
                }
                IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                    Offset(0x2),
                    CFG_,	8,
                    Offset(0x7),
                    LDN_,	8,
                    Offset(0x22),
                    PCFD,	1,
                    ,	2,
                    PCPP,	1,
                    PCU1,	1,
                    PCU2,	1,
                    Offset(0x23),
                    Offset(0x30),
                    ACTR,	8,
                    Offset(0x60),
                    IOAH,	8,
                    IOAL,	8,
                    FIRH,	8,
                    FIRL,	8,
                    Offset(0x70),
                    INTR,	8,
                    INT1,	8,
                    Offset(0x74),
                    DMCH,	8,
                    Offset(0xc0),
                    GP40,	8,
                    Offset(0xf0),
                    OPT1,	8,
                    OPT2,	8,
                    OPT3,	8
                }
                Mutex(MUIO, 0)
                Method(ENFG) {
                    Acquire(MUIO, 0xffff)
                    Store(0x55, INDX)
                }
                Method(EXFG) {
                    Store(0xaa, INDX)
                    Release(MUIO)
                }
                Name(_PRW, Package(0x2) {
                    0xb,
                    0x4,
                })
                Method(_PSW, 1) {
                    OperationRegion(GPO_, SystemIO, 0x800e, 0x2)
                    Field(GPO_, ByteAcc, NoLock, Preserve) {
                        ,	10,
                        RIEN,	1
                    }
                    Store(Arg0, RIEN)
                }
                Method(RDMB, 1) {
                    ENFG()
                    Store(0x7, LDN_)
                    Store(Arg0, INDX)
                    Store(DATA, Local0)
                    EXFG()
                    Return(Local0)
                }
                Method(WRMB, 2) {
                    ENFG()
                    Store(0x7, LDN_)
                    Store(Arg0, INDX)
                    Store(Arg1, DATA)
                    EXFG()
                }
                Method(WIBE) {
                    While(RDMB(0x82)) {
                    }
                }
                Method(WOBF) {
                    Store(Zero, Local0)
                    While(LNot(Local0)) {
                        And(RDMB(0x86), 0x2, Local0)
                    }
                }
                Mutex(MSCI, 0)
                Method(SCID) {
                    Store("SCI generated", Debug)
                    Store(Ones, Local7)
                    While(Local7) {
                        And(RDMB(0x86), 0x1, Local0)
                        If(Local0) {
                            Acquire(MSCI, 0xffff)
                            WIBE()
                            WRMB(0x82, 0x84)
                            WOBF()
                            Store(RDMB(0x83), Local0)
                            Store(RDMB(0x86), Local1)
                            And(Local1, 0xfd, Local1)
                            WRMB(0x86, Local1)
                            Release(MSCI)
                            Store(Local0, Debug)
                            QREC(Local0)
                        }
                        Else {
                            Store(Zero, Local7)
                        }
                    }
                }
                Name(LCDT, Ones)
                Name(LID_, One)
                Method(QREC, 1) {
                    If(LEqual(Arg0, 0x51)) {
                        Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xa0)
                    }
                    Else {
                        If(LEqual(Arg0, 0x53)) {
                            Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xac)
                        }
                        Else {
                            If(LEqual(Arg0, 0x54)) {
                                EXCD(0x20)
                                Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xa2)
                            }
                            Else {
                                If(LEqual(Arg0, 0x55)) {
                                    EXCD(0x1f)
                                    Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xa3)
                                }
                                Else {
                                    If(LEqual(Arg0, 0x56)) {
                                        Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0=
xb3)
                                    }
                                    Else {
                                        If(LEqual(Arg0, 0x57)) {
                                            Store(RDMB(0x8e), Local0)
                                            Store(RDMB(0x8f), Local1)
                                            WRMB(0x8f, Local0)
                                            XOr(Local0, Local1, Local2)
                                            If(And(Local2, 0x1, )) {
                                                Notify(BAT1, 0x81)
                                            }
                                            If(And(Local2, 0x20, )) {
                                                Notify(ACAD, 0x80)
                                                Notify(\_SB_.PCI0.ISA_.EC__=
.SNC_, 0xba)
                                            }
                                            If(And(Local2, 0x80, )) {
                                                If(And(Local0, 0x80, )) {
                                                    Notify(\_SB_.PCI0.ISA_.=
EC__.SNC_, 0xb7)
                                                    Store(Zero, LID_)
                                                }
                                                Else {
                                                    Notify(\_SB_.PCI0.ISA_.=
EC__.SNC_, 0xb9)
                                                    Store(One, LID_)
                                                }
                                            }
                                        }
                                        Else {
                                            If(LEqual(Arg0, 0x58)) {
                                                EXCD(0x1f)
                                                Notify(\_SB_.PCI0.ISA_.EC__=
.SNC_, 0xa4)
                                            }
                                            Else {
                                                If(LEqual(Arg0, 0x59)) {
                                                    EXCD(0x1f)
                                                    Notify(\_SB_.PCI0.ISA_.=
EC__.SNC_, 0xa5)
                                                }
                                                Else {
                                                    If(LEqual(Arg0, 0x5a)) =
{
                                                        If(LEqual(LCDT, One=
s)) {
                                                            Store(PHSB(0xee=
, 0x0), LCDT)
                                                        }
                                                        If(LEqual(LCDT, 0x0=
)) {
                                                            EXCD(0x1f)
                                                            Notify(\_SB_.PC=
I0.ISA_.EC__.SNC_, 0xa6)
                                                        }
                                                    }
                                                    Else {
                                                        If(LEqual(Arg0, 0x5=
b)) {
                                                            Notify(\_SB_.PC=
I0.ISA_.EC__.SNC_, 0xb6)
                                                        }
                                                        Else {
                                                            If(LEqual(Arg0,=
 0x5f)) {
                                                                Notify(\_SB=
_.PCI0.ISA_.EC__.SNC_, 0xad)
                                                            }
                                                            Else {
                                                                If(LEqual(A=
rg0, 0x61)) {
                                                                    Notify(=
\_SB_.PCI0.ISA_.EC__.SNC_, 0xb1)
                                                                }
                                                                Else {
                                                                    If(LEqu=
al(Arg0, 0x64)) {
                                                                        Not=
ify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xb0)
                                                                    }
                                                                    Else {
                                                                        If(=
LEqual(Arg0, 0x65)) {
                                                                           =
 EXCD(0x21)
                                                                           =
 Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xb4)
                                                                        }
                                                                        Els=
e {
                                                                           =
 If(LEqual(Arg0, 0x66)) {
                                                                           =
     EXCD(0x21)
                                                                           =
     Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xb5)
                                                                           =
 }
                                                                           =
 Else {
                                                                           =
     If(LEqual(Arg0, 0x67)) {
                                                                           =
     }
                                                                           =
     Else {
                                                                           =
         If(LEqual(Arg0, 0x68)) {
                                                                           =
             Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xb8)
                                                                           =
         }
                                                                           =
         Else {
                                                                           =
             If(LEqual(Arg0, 0x76)) {
                                                                           =
                 Store(Zero, \_SB_.PCI0.ISA_.EC__.SNC_.PPST)
                                                                           =
                 Notify(\_SB_.PWRB, 0x80)
                                                                           =
             }
                                                                           =
             Else {
                                                                           =
                 If(LEqual(Arg0, 0x78)) {
                                                                           =
                     Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0x90)
                                                                           =
                 }
                                                                           =
                 Else {
                                                                           =
                     If(LEqual(Arg0, 0x79)) {
                                                                           =
                         EXCD(0x20)
                                                                           =
                         Notify(\_SB_.PCI0.ISA_.EC__.SNC_, 0xbb)
                                                                           =
                     }
                                                                           =
                     Else {
                                                                           =
                         If(LEqual(Arg0, 0x80)) {
                                                                           =
                             Notify(\_TZ_.ATF0, 0x80)
                                                                           =
                         }
                                                                           =
                         Else {
                                                                           =
                             If(LEqual(Arg0, 0x81)) {
                                                                           =
                                 Notify(\_TZ_.ATF0, 0x81)
                                                                           =
                             }
                                                                           =
                             Else {
                                                                           =
                                 Add(Arg0, 0x30, Local0)
                                                                           =
                                 PHS_(Local0)
                                                                           =
                             }
                                                                           =
                         }
                                                                           =
                     }
                                                                           =
                 }
                                                                           =
             }
                                                                           =
         }
                                                                           =
     }
                                                                           =
 }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                Mutex(MEEC, 0)
                Method(EXCD, 1) {
                    Store("Notify State to EC", Debug)
                    Acquire(MEEC, 0xffff)
                    WIBE()
                    WRMB(0x84, Arg0)
                    WRMB(0x82, 0x87)
                    WOBF()
                    And(RDMB(0x86), 0xfd, Local0)
                    WRMB(0x86, Local0)
                    Release(MEEC)
                }
                Method(EXRD, 1) {
                    Store("extended command to EC", Debug)
                    Acquire(MEEC, 0xffff)
                    WIBE()
                    WRMB(0x84, Arg0)
                    WRMB(0x82, 0x87)
                    WOBF()
                    Add(Multiply(RDMB(0x84), 0x0100, Local0), Store(RDMB(0x=
83), Local1), Local2)
                    And(RDMB(0x86), 0xfd, Local0)
                    WRMB(0x86, Local0)
                    Release(MEEC)
                    Return(Local2)
                }
                Method(EXWT, 2) {
                    Store("extended write command to EC", Debug)
                    Acquire(MEEC, 0xffff)
                    WIBE()
                    WRMB(0x84, Arg0)
                    WRMB(0x85, Arg1)
                    WRMB(0x82, 0x87)
                    WOBF()
                    And(RDMB(0x86), 0xfd, Local0)
                    WRMB(0x86, Local0)
                    Release(MEEC)
                }
                Method(PPK_) {
                    Store("PPK_STATUS", Debug)
                    Store(RDMB(0x8c), Local1)
                    If(LEqual(And(Local1, 0x2, Local0), 0x2)) {
                        Store(One, Local0)
                    }
                    Else {
                        If(LEqual(And(Local1, 0x4, Local0), 0x4)) {
                            Store(0x2, Local0)
                        }
                        Else {
                            If(LEqual(And(Local1, 0x8, Local0), 0x8)) {
                                Store(0x3, Local0)
                            }
                            Else {
                                If(LEqual(And(Local1, 0x20, Local0), 0x20))=
 {
                                    Store(0x10, Local0)
                                }
                                Else {
                                    Store(Zero, Local0)
                                }
                            }
                        }
                    }
                    Return(Local0)
                }
                Device(BAT1) {
                    Name(_HID, 0x0a0cd041)
                    Name(_UID, 0x1)
                    Name(_PCL, Package(0x1) {
                        \_SB_,
                    })
                    Name(BATI, Package(0xd) {
                        0x0,
                        0xffffffff,
                        0xffffffff,
                        0x0,
                        0x39d0,
                        0x0,
                        0x78,
                        0x0,
                        0xa,
                        "",
                        "",
                        "LION",
                        "Sony Corp.",
                    })
                    Name(BATS, Package(0x4) {
                        0x2,
                        0xffffffff,
                        0x0d7a,
                        0x3840,
                    })
                    Method(_STA) {
                        Store("BAT1 _STA", Debug)
                        If(And(RDMB(0x8f), 0x1, )) {
                            Store(0xf, Local0)
                        }
                        Else {
                            Store(0x1f, Local0)
                        }
                        Store(Local0, Debug)
                        Return(Local0)
                    }
                    Method(_BIF) {
                        Store("BAT1 _BIF", Debug)
                        If(And(RDMB(0x8f), 0x1, )) {
                        }
                        Else {
                            Multiply(EXRD(0x31), 0xa, Local0)
                            Store(Local0, Index(BATI, 0x1, ))
                            Store(Local0, Index(BATI, 0x2, ))
                        }
                        Return(BATI)
                    }
                    Method(_BST) {
                        Store("BAT1 _BST", Debug)
                        Store(EXRD(0xc), Index(BATS, 0x0, ))
                        Store(EXRD(0xd), Index(BATS, 0x1, ))
                        Multiply(EXRD(0xe), 0xa, Index(BATS, 0x2, ))
                        Store(EXRD(0xf), Index(BATS, 0x3, ))
                        Return(BATS)
                    }
                }
                Device(ACAD) {
                    Name(_HID, "ACPI0003")
                    Name(_PCL, Package(0x1) {
                        \_SB_,
                    })
                    Method(_PSR) {
                        Store(RDMB(0x8f), Local0)
                        If(And(Local0, 0x20, )) {
                            Return(0x0)
                        }
                        Return(0x1)
                    }
                    Method(_STA) {
                        Return(0xf)
                    }
                }
                Device(SNC_) {
                    Name(_HID, 0x0150d94d)
                    Name(PPST, 0x0)
                    Method(PWAK) {
                        Store(\_SB_.PCI0.ISA_.EC__.PPK_(), Local0)
                        Store(Local0, PPST)
                        \_SB_.PCI0.ISA_.EC__.EXCD(0x1c)
                        Return(PPST)
                    }
                    Method(STCS, 1) {
                        \_SB_.PCI0.ISA_.EC__.EXWT(0xb, Arg0)
                        Notify(\_TZ_.ATF0, 0x81)
                    }
                    Method(GBRT) {
                        Return(PHSB(0xe6, 0x0))
                    }
                    Method(SBRT, 1) {
                        Store(PHSB(0xe7, Arg0), Local0)
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x24, Local0)
                    }
                    Method(SPBR, 1) {
                        PHSB(0xe8, Arg0)
                    }
                    Method(GCTR) {
                        Return(PHSB(0xe9, 0x0))
                    }
                    Method(SCTR, 1) {
                        Store(PHSB(0xea, Arg0), Local0)
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x23, Local0)
                    }
                    Method(SPCR, 1) {
                        PHSB(0xeb, Arg0)
                    }
                    Method(GMGB) {
                        PHS_(0xf3)
                        Return(INFB)
                    }
                    Method(CMGB, 1) {
                        If(Arg0) {
                            Store(Zero, GO23)
                        }
                        Else {
                            Store(One, GO23)
                        }
                    }
                    Method(SMGB, 1) {
                        Store(Arg0, INFB)
                        PHS_(0xf4)
                    }
                    Method(GPKC) {
                        PHS_(0xf5)
                        Return(INFB)
                    }
                    Method(SPKC, 1) {
                        Store(Arg0, INFB)
                        PHS_(0xf6)
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x25, Arg0)
                        \_SB_.PCI0.ISA_.EC__.EXCD(0x1c)
                    }
                    Method(GPLR) {
                        PHS_(0xf7)
                        Return(INFB)
                    }
                    Method(SPLR, 1) {
                        Store(Arg0, INFB)
                        PHS_(0xf8)
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x26, Arg0)
                        \_SB_.PCI0.ISA_.EC__.EXCD(0x1c)
                    }
                    Method(GILS) {
                        Return(\_SB_.PCI0.ISA_.EC__.EXRD(0x28))
                    }
                    Method(SILS, 1) {
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x27, Arg0)
                    }
                    Method(GLID) {
                        Return(\_SB_.PCI0.ISA_.EC__.LID_)
                    }
                    Method(SLBH, 1) {
                        \_SB_.PCI0.ISA_.EC__.EXWT(0x2b, Arg0)
                    }
                }
            }
            Device(COMA) {
                Name(_HID, 0x0105d041)
                Name(_UID, 0x1)
                Name(MCD_, 0x10)
                Method(_CRS) {
                    Return(PSCS(0x10))
                }
                Method(_SRS, 1) {
                    PSSS(0x10, Arg0)
                }
                Method(_PRS) {
                    Return(PSPS(0x10))
                }
                Method(_DIS) {
                    PSDI(0x10)
                }
                Method(_STA) {
                    Return(PSST(0x10))
                }
                Method(_PS0) {
                    Store(One, GO30)
                    Store(0x0, _PSC)
                }
                Method(_PS3) {
                    Store(0x3, _PSC)
                }
                Name(_PSC, 0x0)
            }
            Device(FIR_) {
                Name(_HID, 0x10f0a34d)
                Name(_CID, 0x1005d041)
                Name(_UID, 0x2)
                Name(MCD_, 0x13)
                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))
                }
                Method(_PS0) {
                    \_SB_.PCI0.ISA_.EC__.EXWT(0x2a, One)
                    Store(0x0, _PSC)
                }
                Method(_PS3) {
                    \_SB_.PCI0.ISA_.EC__.EXWT(0x2a, Zero)
                    Store(0x3, _PSC)
                }
                Name(_PSC, 0x0)
            }
            Device(LPTA) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x1)
                Name(MCD_, 0xd)
                Method(B_CR) {
                    Return(PSCS(0xd))
                }
                Method(B_SR, 1) {
                    PSSS(0xd, Arg0)
                }
                Method(B_PR) {
                    Return(PSPS(0xd))
                }
                Method(B_DI) {
                    PSDI(0xd)
                }
                Method(_STA) {
                    Return(PSST(0xd))
                }
                Name(_PSC, 0x0)
            }
            Device(LPTB) {
                Name(_HID, 0x0004d041)
                Name(_UID, 0x2)
                Name(MCD_, 0xe)
                Method(B_CR) {
                    Return(PSCS(0xe))
                }
                Method(B_SR, 1) {
                    PSSS(0xe, Arg0)
                }
                Method(B_PR) {
                    Return(PSPS(0xe))
                }
                Method(B_DI) {
                    PSDI(0xe)
                }
                Method(_STA) {
                    Return(PSST(0xe))
                }
                Name(_PSC, 0x0)
            }
            Device(ECP_) {
                Name(_HID, 0x0104d041)
                Name(MCD_, 0xf)
                Method(_CRS) {
                    Return(PSCS(0xf))
                }
                Method(_SRS, 1) {
                    PSSS(0xf, Arg0)
                }
                Method(_PRS) {
                    Return(PSPS(0xf))
                }
                Method(_DIS) {
                    PSDI(0xf)
                }
                Method(_STA) {
                    Return(PSST(0xf))
                }
                Name(_PSC, 0x0)
            }
            Device(FDC_) {
                Name(_HID, 0x0007d041)
                Name(MCD_, 0xc)
                Method(B_CR) {
                    Return(PSCS(0xc))
                }
                Method(B_SR, 1) {
                    PSSS(0xc, Arg0)
                }
                Method(B_PR) {
                    Return(PSPS(0xc))
                }
                Method(B_DI) {
                    PSDI(0xc)
                }
                Method(_STA) {
                    Return(PSST(0xc))
                }
                Name(_PSC, 0x0)
            }
        }
        Device(PX4_) {
            Name(_ADR, 0x00070000)
            OperationRegion(GENC, PCI_Config, 0xb0, 0x4)
            Field(GENC, DWordAcc, NoLock, Preserve) {
                ISAS,	1,
                POSD,	1,
                ,	9,
                ID0T,	1,
                ID1T,	1
            }
            OperationRegion(PCI_, PCI_Config, 0x60, 0x4)
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                PIRQ,	32
            }
            Name(P1__, Buffer(0x4) {0x0 })
            Method(RESP) {
                Store(P1__, PIRQ)
            }
            Method(SAVP) {
                Store(PIRQ, P1__)
            }
        }
    }
}
Scope(\_SI_) {
    Method(_SST, 1) {
        If(LEqual(Arg0, 0x0)) {
        }
        If(LEqual(Arg0, 0x1)) {
        }
        If(LEqual(Arg0, 0x2)) {
        }
        If(LEqual(Arg0, 0x3)) {
        }
        If(LEqual(Arg0, 0x4)) {
        }
        If(LEqual(Arg0, 0x5)) {
        }
    }
}
Method(_WAK, 1) {
    Notify(\_SB_.PWRB, 0x2)
    Return(Zero)
}
Scope(\_TZ_) {
    Method(KELV, 1) {
        Store("Converted Kelvin", Debug)
        Store(Arg0, Local0)
        Multiply(Local0, 0xa, Local0)
        Add(Local0, 0x0aab, Local0)
        Return(Local0)
    }
    ThermalZone(ATF0) {
        Method(_TMP) {
            Store("Get ATF0 Tempareture", Debug)
            Return(KELV(\_SB_.PCI0.ISA_.EC__.EXRD(0x2)))
        }
        Method(_PSV) {
            Store("Get ATF0 Passive Trip point", Debug)
            Return(KELV(\_SB_.PCI0.ISA_.EC__.EXRD(0x18)))
        }
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Method(_CRT) {
            Store("Get ATF0 Critical Trip point", Debug)
            Return(KELV(\_SB_.PCI0.ISA_.EC__.EXRD(0x19)))
        }
        Method(_SCP, 1) {
            \_SB_.PCI0.ISA_.EC__.EXWT(0xb, Arg0)
        }
        Name(_TC1, 0x1)
        Name(_TC2, 0x1)
        Name(_TSP, 0x64)
    }
}
Scope(_SB_) {
    Name(IRQP, Package(0x10) {
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0200,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
    })
    Device(LNKA) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x1)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.ISA_.PIRA, 0x80, \_SB_.PCI0.ISA_.PIRA)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.ISA_.PIRA, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.ISA_.PIRA, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.ISA_.PIRA)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.ISA_.PIRA, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKB) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x2)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.ISA_.PIRB, 0x80, \_SB_.PCI0.ISA_.PIRB)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.ISA_.PIRB, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.ISA_.PIRB, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.ISA_.PIRB)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.ISA_.PIRB, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKC) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x3)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.ISA_.PIRC, 0x80, \_SB_.PCI0.ISA_.PIRC)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.ISA_.PIRC, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.ISA_.PIRC, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.ISA_.PIRC)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.ISA_.PIRC, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
    Device(LNKD) {
        Name(_HID, 0x0f0cd041)
        Name(_UID, 0x4)
        Name(_PRS, Buffer(0x6) {0x23, 0x0, 0x2, 0x18, 0x79, 0x0 })
        Method(_DIS) {
            Or(\_SB_.PCI0.ISA_.PIRD, 0x80, \_SB_.PCI0.ISA_.PIRD)
        }
        Method(_CRS) {
            Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
            CreateWordField(BUFA, 0x1, IRA1)
            And(\_SB_.PCI0.ISA_.PIRD, 0x8f, Local0)
            If(LLess(Local0, 0x80)) {
                And(Local0, 0xf, Local0)
                Store(DerefOf(Index(IRQP, Local0, )), Local4)
                Store(Local4, IRA1)
            }
            Return(BUFA)
        }
        Method(_SRS, 1) {
            CreateWordField(Arg0, 0x1, IRA1)
            Store(IRA1, Local0)
            Store(Match(IRQP, MEQ, Local0, MTR, 0x0, 0x0), Local1)
            And(\_SB_.PCI0.ISA_.PIRD, 0x70, Local0)
            Or(Local1, Local0, \_SB_.PCI0.ISA_.PIRD)
        }
        Method(_STA) {
            If(LEqual(\_SB_.PCI0.ISA_.PIRD, 0x80)) {
                Return(0x9)
            }
            Else {
                Return(0xb)
            }
        }
    }
}

}

--=-sXMtsuFS4cZ5v/loDMdz--
