Attachment 298677 Details for Bug 436959 – acpidump output

acpidump output

acpidump.txt (text/plain), 124.11 KB, created by drago01 on 2008-03-20 09:58:07 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: drago01

Created: 2008-03-20 09:58:07 UTC

Size: 124.11 KB

patch

obsolete

>/*
>RSD PTR: Checksum=90, OEMID=PTLTD, RsdtAddress=0x7fe8f286
> */
>/*
>RSDT: Length=68, Revision=1, Checksum=61,
>	OEMID=PTLTD, OEM Table ID=Capell00, OEM Revision=0x6040000,
>	Creator ID= LTP, Creator Revision=0x0
> */
>/*
>	Entries={ 0x7fe94dee, 0x7fe94e62, 0x7fe94eca, 0x7fe94f02, 0x7fe94fd8, 0x7fe94f70, 0x7fe8fc9e, 0x7fe8f2ca }
> */
>/*
>	DSDT=0x7fe8feac
>	INT_MODEL=PIC
>	SCI_INT=9
>	SMI_CMD=0xb2, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0xf2
>	PM1a_EVT_BLK=0x1000-0x1003
>	PM1a_CNT_BLK=0x1004-0x1005
>	PM2_CNT_BLK=0x1020-0x1020
>	PM2_TMR_BLK=0x1008-0x100b
>	PM2_GPE0_BLK=0x1028-0x102f
>	P_LVL2_LAT=1ms, P_LVL3_LAT=35ms
>	FLUSH_SIZE=0, FLUSH_STRIDE=0
>	DUTY_OFFSET=1, DUTY_WIDTH=3
>	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
>	Flags={WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,DCK_CAP}
> */
>/*
>DSDT: Length=20290, Revision=1, Checksum=82,
>	OEMID=INVENT, OEM Table ID=SYMPHONY, OEM Revision=0x6040000,
>	Creator ID=INTL, Creator Revision=0x20050624
> */
>DefinitionBlock ( "acpi_dsdt.aml",	//Output filename 	"DSDT",		//Signature 	0x1,			//DSDT Revision 	"INVENT",			//OEMID 	"SYMPHONY",			//TABLE ID 	0x6040000			//OEM Revision
>)
>
>{
>OperationRegion(PRT0, SystemIO, 0x80, One)
>Field(PRT0, ByteAcc, Lock, Preserve) {
>    PO80,	8
>}
>OperationRegion(IO_T, SystemIO, 0x0800, 0x10)
>Field(IO_T, ByteAcc, NoLock, Preserve) {
>    Offset(0x8),
>    TRP0,	8
>}
>OperationRegion(PMIO, SystemIO, 0x1000, 0x80)
>Field(PMIO, ByteAcc, NoLock, Preserve) {
>    Offset(0x42),
>    ,	1,
>    GPEC,	1
>}
>OperationRegion(GPIO, SystemIO, 0x1180, 0x3c)
>Field(GPIO, ByteAcc, NoLock, Preserve) {
>    GU00,	8,
>    GU01,	8,
>    GU02,	8,
>    GU03,	8,
>    GIO0,	8,
>    GIO1,	8,
>    GIO2,	8,
>    GIO3,	8,
>    Offset(0xc),
>    GL00,	8,
>    ,	4,
>    GP12,	1,
>    Offset(0xe),
>    GL02,	8,
>    GL03,	8,
>    Offset(0x18),
>    GB00,	8,
>    GB01,	8,
>    GB02,	8,
>    GB03,	8,
>    Offset(0x2c),
>    GIV0,	8,
>    GIV1,	8,
>    GIV2,	8,
>    GIV3,	8,
>    GU04,	8,
>    GU05,	8,
>    GU06,	8,
>    GU07,	8,
>    GIO4,	8,
>    GIO5,	8,
>    GIO6,	8,
>    GIO7,	8,
>    ,	7,
>    GP39,	1,
>    GL05,	8,
>    GL06,	8,
>    GL07,	8
>}
>OperationRegion(GNVS, SystemMemory, 0x7fe95dbc, 0x0100)
>Field(GNVS, AnyAcc, Lock, Preserve) {
>    OSYS,	16,
>    SMIF,	8,
>    PRM0,	8,
>    PRM1,	8,
>    SCIF,	8,
>    PRM2,	8,
>    PRM3,	8,
>    LCKF,	8,
>    PRM4,	8,
>    PRM5,	8,
>    P80D,	32,
>    LIDS,	8,
>    PWRS,	8,
>    DBGS,	8,
>    Offset(0x14),
>    ACTT,	8,
>    PSVT,	8,
>    TC1V,	8,
>    TC2V,	8,
>    TSPV,	8,
>    CRTT,	8,
>    DTSE,	8,
>    DTS1,	8,
>    DTS2,	8,
>    FANS,	8,
>    BNUM,	8,
>    B0SC,	8,
>    B1SC,	8,
>    B2SC,	8,
>    B0SS,	8,
>    B1SS,	8,
>    B2SS,	8,
>    Offset(0x28),
>    APIC,	8,
>    MPEN,	8,
>    PPCS,	8,
>    PPCM,	8,
>    Offset(0x32),
>    NATP,	8,
>    CMAP,	8,
>    CMBP,	8,
>    LPTP,	8,
>    FDCP,	8,
>    CMCP,	8,
>    CIRP,	8,
>    Offset(0x3c),
>    IGDS,	8,
>    TLST,	8,
>    CADL,	8,
>    PADL,	8,
>    CSTE,	16,
>    NSTE,	16,
>    SSTE,	16,
>    NDID,	8,
>    DID1,	32,
>    DID2,	32,
>    DID3,	32,
>    DID4,	32,
>    DID5,	32,
>    Offset(0x67),
>    BLCS,	8,
>    BRTL,	8,
>    ALSE,	8,
>    ALAF,	8,
>    LLOW,	8,
>    LHIH,	8,
>    Offset(0x6e),
>    EMAE,	8,
>    EMAP,	16,
>    EMAL,	16,
>    Offset(0x74),
>    MEFE,	8,
>    Offset(0x78),
>    TPMP,	8,
>    TPME,	8,
>    Offset(0x82),
>    GTF0,	56,
>    GTF2,	56,
>    IDEM,	8
>}
>OperationRegion(RCRB, SystemMemory, 0xfed1c000, 0x4000)
>Field(RCRB, DWordAcc, Lock, Preserve) {
>    Offset(0x1000),
>    Offset(0x3000),
>    Offset(0x3404),
>    HPAS,	2,
>    ,	5,
>    HPAE,	1,
>    Offset(0x3418),
>    ,	1,
>    PATD,	1,
>    SATD,	1,
>    SMBD,	1,
>    HDAD,	1,
>    A97D,	1,
>    Offset(0x341a),
>    RP1D,	1,
>    RP2D,	1,
>    RP3D,	1,
>    RP4D,	1,
>    RP5D,	1,
>    RP6D,	1
>}
>OperationRegion(ECMB, SystemIO, 0x0400, 0x2)
>Field(ECMB, ByteAcc, NoLock, Preserve) {
>    MIDX,	8,
>    MDAT,	8
>}
>IndexField(MIDX, MDAT, ByteAcc, NoLock, Preserve) {
>    Offset(0x8e),
>    FLAS,	8,
>    Offset(0xa1),
>    COMD,	8,
>    IND0,	8,
>    IND1,	8,
>    DAT0,	8,
>    DAT1,	8,
>    Offset(0xa9),
>    CLMT,	2,
>    Offset(0xac),
>    CTMP,	8
>}
>Name(RTMP, One)
>Name(TMPI, Zero)
>Method(RDEC, 1) {
>    Acquire(\_SB_.PCI0.LPCB.EC0_.MUT1, 0xffff)
>    Store(IND0, TMPI)
>    Store(Arg0, IND0)
>    Store(0x90, COMD)
>    Sleep(0xa)
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    Store(DAT0, Local0)
>    Store(TMPI, IND0)
>    Sleep(One)
>    Release(\_SB_.PCI0.LPCB.EC0_.MUT1)
>    Return(Local0)
>}
>Method(WREC, 2) {
>    Acquire(\_SB_.PCI0.LPCB.EC0_.MUT1, 0xffff)
>    Store(IND0, TMPI)
>    Store(Arg0, IND0)
>    Store(Arg1, DAT0)
>    Store(0x91, COMD)
>    Sleep(0xa)
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    If(COMD) {
>        Sleep(0xa)
>    }
>    Store(TMPI, IND0)
>    Release(\_SB_.PCI0.LPCB.EC0_.MUT1)
>}
>Mutex(MUTX, 0)
>Name(_S0_, Package(0x3) {
>    Zero,
>    Zero,
>    Zero,
>})
>Name(_S3_, Package(0x3) {
>    0x5,
>    0x5,
>    Zero,
>})
>Name(_S4_, Package(0x3) {
>    0x6,
>    0x6,
>    Zero,
>})
>Name(_S5_, Package(0x3) {
>    0x7,
>    0x7,
>    Zero,
>})
>Scope(_PR_) {
>    Processor(CPU0, 0, 0x1010, 0x6) {
>    }
>    Processor(CPU1, 1, 0x1010, 0x6) {
>        Method(_INI) {
>            If(DTSE) {
>                Store(0x46, SMIF)
>                Store(Zero, TRP0)
>            }
>        }
>    }
>}
>Name(DSEN, One)
>Name(ECON, Zero)
>Name(GPIC, Zero)
>Name(CTYP, Zero)
>Name(L01C, Zero)
>Name(VFN0, Zero)
>Name(VFN1, Zero)
>Method(_PIC, 1) {
>    Store(Arg0, GPIC)
>}
>Method(_PTS, 1) {
>    Store(Arg0, PO80)
>    If(LEqual(DBGS, Zero)) {
>    }
>    Store(Zero, \_SB_.LIDF)
>    If(LEqual(Arg0, 0x5)) {
>        Store(0x8c, PO80)
>        Store(0x8c, SMIF)
>        Store(Zero, TRP0)
>    }
>    If(LEqual(Arg0, 0x4)) {
>        Store(One, \_SB_.PCI0.LPCB.EC0_.SWI4)
>    }
>    If(LEqual(Arg0, 0x3)) {
>        Store(0x8d, PO80)
>        Store(0x8d, SMIF)
>        Store(Zero, TRP0)
>    }
>}
>Method(_WAK, 1) {
>    If(LEqual(Arg0, 0x3)) {
>        Store(0x8b, PO80)
>        Store(0x8b, SMIF)
>        Store(Zero, TRP0)
>        If(LEqual(Zero, ACTT)) {
>        }
>    }
>    If(LAnd(LEqual(Arg0, 0x4), LEqual(OSYS, 0x07d1))) {
>        If(And(CFGD, One, )) {
>            If(LGreater(PPCS, Zero)) {
>                Subtract(PPCS, One, PPCS)
>                PNOT()
>                Add(PPCS, One, PPCS)
>                PNOT()
>            }
>            Else {
>                Add(PPCS, One, PPCS)
>                PNOT()
>                Subtract(PPCS, One, PPCS)
>                PNOT()
>            }
>        }
>        Store(0x8e, PO80)
>        Store(0x8e, SMIF)
>        Store(Zero, TRP0)
>    }
>    Notify(\_SB_.PCI0, Zero)
>    Store(One, \_SB_.LIDF)
>    WREC(0xb6, And(RDEC(0xb6), 0xfe, ))
>    Return(Package(0x2) {
>        Zero,
>        Zero,
>    })
>}
>Scope(_GPE) {
>    Method(_L01) {
>        Add(L01C, One, L01C)
>        Sleep(0x64)
>        If(LAnd(LEqual(RP1D, Zero), \_SB_.PCI0.RP01.HPCS)) {
>            If(\_SB_.PCI0.RP01.PDC1) {
>                Store(One, \_SB_.PCI0.RP01.PDC1)
>                Store(One, \_SB_.PCI0.RP01.HPCS)
>                Notify(\_SB_.PCI0.RP01, Zero)
>            }
>            Else {
>                Store(One, \_SB_.PCI0.RP01.HPCS)
>            }
>        }
>        If(LAnd(LEqual(RP2D, Zero), \_SB_.PCI0.RP02.HPCS)) {
>            If(\_SB_.PCI0.RP02.PDC2) {
>                Store(One, \_SB_.PCI0.RP02.PDC2)
>                Store(One, \_SB_.PCI0.RP02.HPCS)
>                Notify(\_SB_.PCI0.RP02, Zero)
>            }
>            Else {
>                Store(One, \_SB_.PCI0.RP02.HPCS)
>            }
>        }
>        If(LAnd(LEqual(RP3D, Zero), \_SB_.PCI0.RP03.HPCS)) {
>            If(\_SB_.PCI0.RP03.PDC3) {
>                Store(One, \_SB_.PCI0.RP03.PDC3)
>                Store(One, \_SB_.PCI0.RP03.HPCS)
>                Notify(\_SB_.PCI0.RP03, Zero)
>            }
>            Else {
>                Store(One, \_SB_.PCI0.RP03.HPCS)
>            }
>        }
>        If(LAnd(LEqual(RP4D, Zero), \_SB_.PCI0.RP04.HPCS)) {
>            If(\_SB_.PCI0.RP04.PDC4) {
>                Store(One, \_SB_.PCI0.RP04.PDC4)
>                Store(One, \_SB_.PCI0.RP04.HPCS)
>                Notify(\_SB_.PCI0.RP04, Zero)
>            }
>            Else {
>                Store(One, \_SB_.PCI0.RP04.HPCS)
>            }
>        }
>    }
>    Method(_L03) {
>        Notify(\_SB_.PCI0.USB1, 0x2)
>    }
>    Method(_L04) {
>        Notify(\_SB_.PCI0.USB2, 0x2)
>    }
>    Method(_L05) {
>        If(HDAD) {
>            Notify(\_SB_.PCI0.MODM, 0x2)
>        }
>        Else {
>            Notify(\_SB_.PCI0.HDEF, 0x2)
>        }
>    }
>    Method(_L09) {
>        If(\_SB_.PCI0.RP01.PSP1) {
>            Store(One, \_SB_.PCI0.RP01.PSP1)
>            Store(One, \_SB_.PCI0.RP01.PMCS)
>            Notify(\_SB_.PCI0.RP01, 0x2)
>        }
>        If(\_SB_.PCI0.RP02.PSP2) {
>            Store(One, \_SB_.PCI0.RP02.PSP2)
>            Store(One, \_SB_.PCI0.RP02.PMCS)
>            Notify(\_SB_.PCI0.RP02, 0x2)
>        }
>        If(\_SB_.PCI0.RP03.PSP3) {
>            Store(One, \_SB_.PCI0.RP03.PSP3)
>            Store(One, \_SB_.PCI0.RP03.PMCS)
>            Notify(\_SB_.PCI0.RP03, 0x2)
>        }
>        If(\_SB_.PCI0.RP04.PSP4) {
>            Store(One, \_SB_.PCI0.RP04.PSP4)
>            Store(One, \_SB_.PCI0.RP04.PMCS)
>            Notify(\_SB_.PCI0.RP04, 0x2)
>        }
>    }
>    Method(_L0B) {
>        Notify(\_SB_.PCI0.PCIB, 0x2)
>    }
>    Method(_L0C) {
>        Notify(\_SB_.PCI0.USB3, 0x2)
>    }
>    Method(_L0D) {
>        Notify(\_SB_.PCI0.USB7, 0x2)
>    }
>    Method(_L0E) {
>        Notify(\_SB_.PCI0.USB4, 0x2)
>    }
>    Method(_L19) {
>        Notify(\_SB_.LID_, 0x80)
>    }
>}
>Method(GETB, 3, Serialized) {
>    Multiply(Arg0, 0x8, Local0)
>    Multiply(Arg1, 0x8, Local1)
>    CreateField(Arg2, Local0, Local1, TBF3)
>    Return(TBF3)
>}
>Method(HKDS, 1, Serialized) {
>    If(LEqual(Zero, DSEN)) {
>        If(LEqual(TRAP(Arg0), Zero)) {
>            If(LNot(LEqual(CADL, PADL))) {
>                Store(CADL, PADL)
>                If(LNot(LLess(OSYS, 0x07d1))) {
>                    Notify(\_SB_.PCI0, Zero)
>                }
>                Else {
>                    Notify(\_SB_.PCI0.GFX0, Zero)
>                }
>                Sleep(0x02ee)
>            }
>            Notify(\_SB_.PCI0.GFX0, 0x80)
>        }
>    }
>    If(LEqual(One, DSEN)) {
>        If(LEqual(TRAP(Increment(Arg0)), Zero)) {
>            Notify(\_SB_.PCI0.GFX0, 0x81)
>        }
>    }
>}
>Method(LSDS, 1, Serialized) {
>    If(Arg0) {
>        HKDS(0xc)
>    }
>    Else {
>        HKDS(0xe)
>    }
>    If(LNot(LEqual(DSEN, One))) {
>        Sleep(0x32)
>        While(LEqual(DSEN, 0x2)) {
>            Sleep(0x32)
>        }
>    }
>}
>Method(PNOT, 0, Serialized) {
>    If(MPEN) {
>        If(And(PDC0, 0x8, )) {
>            Notify(\_PR_.CPU0, 0x80)
>            If(And(PDC0, 0x10, )) {
>                Sleep(0xc8)
>                Notify(\_PR_.CPU0, 0x81)
>            }
>        }
>        If(And(PDC1, 0x8, )) {
>            Notify(\_PR_.CPU1, 0x80)
>            If(And(PDC1, 0x10, )) {
>                Sleep(0xc8)
>                Notify(\_PR_.CPU1, 0x81)
>            }
>        }
>    }
>    Else {
>        Notify(\_PR_.CPU0, 0x80)
>        Sleep(0xc8)
>        Notify(\_PR_.CPU0, 0x81)
>    }
>}
>Method(TRAP, 1, Serialized) {
>    Store(Arg0, SMIF)
>    Store(Zero, TRP0)
>    Return(SMIF)
>}
>Name(DFEC, Zero)
>Scope(_TZ_) {
>    PowerResource(FN00, 0, 0) {
>        Method(_STA, 0, Serialized) {
>            If(LEqual(FANS, Zero)) {
>                Return(Zero)
>            }
>            Else {
>                Return(One)
>            }
>        }
>        Method(_ON_, 0, Serialized) {
>        }
>        Method(_OFF, 0, Serialized) {
>        }
>    }
>    Device(FAN0) {
>        Name(_HID, 0x0b0cd041)
>        Name(_UID, Zero)
>        Name(_PR0, Package(0x1) {
>            FN00,
>        })
>    }
>    ThermalZone(TZ00) {
>        Method(_AC0, 0, Serialized) {
>            Return(Add(0x0aac, Multiply(ACTT, 0xa, ), ))
>        }
>        Name(_AL0, Package(0x1) {
>            FAN0,
>        })
>        Method(_CRT, 0, Serialized) {
>            If(DTSE) {
>                Return(Add(0x0aac, Multiply(CRTT, 0xa, ), ))
>            }
>            Return(0x0ed0)
>        }
>        Method(_SCP, 1, Serialized) {
>            Store(Arg0, CTYP)
>        }
>        Method(_TMP, 0, Serialized) {
>            If(DTSE) {
>                If(LEqual(RTMP, One)) {
>                    Store(0x87, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Store(One, RTMP)
>                If(LNot(LLess(DTS1, DTS2))) {
>                    Return(Add(0x0aac, Multiply(DTS1, 0xa, ), ))
>                }
>                Return(Add(0x0aac, Multiply(DTS2, 0xa, ), ))
>            }
>            Return(0x0bb8)
>        }
>        Method(_PSL, 0, Serialized) {
>            If(MPEN) {
>                Return(Package(0x2) {
>                    \_PR_.CPU0,
>                    \_PR_.CPU1,
>                })
>            }
>            Return(Package(0x1) {
>                \_PR_.CPU0,
>            })
>        }
>        Method(_PSV, 0, Serialized) {
>            Return(Add(0x0aac, Multiply(PSVT, 0xa, ), ))
>        }
>        Method(_TSP, 0, Serialized) {
>            Return(0x96)
>        }
>    }
>    ThermalZone(TZVR) {
>        Method(_TMP, 0, Serialized) {
>            Store(RDEC(0xcb), Local0)
>            If(And(Local0, 0x80, )) {
>                Subtract(Local0, 0x0100, Local0)
>            }
>            Return(Add(0x0aac, Multiply(Local0, 0xa, ), ))
>        }
>        Method(_CRT) {
>            Return(0x0ed0)
>        }
>    }
>    ThermalZone(TZVL) {
>        Method(_TMP, 0, Serialized) {
>            Store(RDEC(0xcc), Local0)
>            If(And(Local0, 0x80, )) {
>                Subtract(Local0, 0x0100, Local0)
>            }
>            Return(Add(0x0aac, Multiply(Local0, 0xa, ), ))
>        }
>        Method(_CRT) {
>            Return(0x0ed0)
>        }
>    }
>    ThermalZone(TZCR) {
>        Method(_TMP, 0, Serialized) {
>            Store(RDEC(0x9c), Local0)
>            Store(Local0, CTMP)
>            Return(Add(0x0aac, Multiply(CTMP, 0xa, ), ))
>        }
>        Method(_CRT) {
>            Return(0x0ed0)
>        }
>    }
>    ThermalZone(TZCL) {
>        Method(_TMP, 0, Serialized) {
>            Store(RDEC(0xce), Local0)
>            If(And(Local0, 0x80, )) {
>                Subtract(Local0, 0x0100, Local0)
>            }
>            Return(Add(0x0aac, Multiply(Local0, 0xa, ), ))
>        }
>        Method(_CRT) {
>            Return(0x0ed0)
>        }
>    }
>    ThermalZone(TZ01) {
>        Method(_CRT, 0, Serialized) {
>            Return(0x0ed0)
>        }
>        Method(_TMP, 0, Serialized) {
>            Store(CTMP, Local0)
>            If(And(Local0, 0x80, )) {
>                Subtract(Local0, 0x0100, Local0)
>            }
>            Return(Add(0x0aac, Multiply(Local0, 0xa, ), ))
>        }
>    }
>}
>Method(GETP, 1, Serialized) {
>    If(LEqual(And(Arg0, 0x9, ), Zero)) {
>        Return(Ones)
>    }
>    If(LEqual(And(Arg0, 0x9, ), 0x8)) {
>        Return(0x0384)
>    }
>    ShiftRight(And(Arg0, 0x0300, ), 0x8, Local0)
>    ShiftRight(And(Arg0, 0x3000, ), 0xc, Local1)
>    Return(Multiply(0x1e, Subtract(0x9, Add(Local0, Local1, ), ), ))
>}
>Method(GDMA, 5, Serialized) {
>    If(Arg0) {
>        If(LAnd(Arg1, Arg4)) {
>            Return(0x14)
>        }
>        If(LAnd(Arg2, Arg4)) {
>            Return(Multiply(Subtract(0x4, Arg3, ), 0xf, ))
>        }
>        Return(Multiply(Subtract(0x4, Arg3, ), 0x1e, ))
>    }
>    Return(Ones)
>}
>Method(GETT, 1, Serialized) {
>    Return(Multiply(0x1e, Subtract(0x9, Add(And(ShiftRight(Arg0, 0x2, ), 0x3, ), And(Arg0, 0x3, ), ), ), ))
>}
>Method(GETF, 3, Serialized) {
>    Name(TMPF, Zero)
>    If(Arg0) {
>        Or(TMPF, One, TMPF)
>    }
>    If(And(Arg2, 0x2, )) {
>        Or(TMPF, 0x2, TMPF)
>    }
>    If(Arg1) {
>        Or(TMPF, 0x4, TMPF)
>    }
>    If(And(Arg2, 0x20, )) {
>        Or(TMPF, 0x8, TMPF)
>    }
>    If(And(Arg2, 0x4000, )) {
>        Or(TMPF, 0x10, TMPF)
>    }
>    Return(TMPF)
>}
>Method(SETP, 3, Serialized) {
>    If(LGreater(Arg0, 0xf0)) {
>        Return(0x8)
>    }
>    Else {
>        If(And(Arg1, 0x2, )) {
>            If(LAnd(LNot(LGreater(Arg0, 0x78)), And(Arg2, 0x2, ))) {
>                Return(0x2301)
>            }
>            If(LAnd(LNot(LGreater(Arg0, 0xb4)), And(Arg2, One, ))) {
>                Return(0x2101)
>            }
>        }
>        Return(0x1001)
>    }
>}
>Method(SDMA, 1, Serialized) {
>    If(LNot(LGreater(Arg0, 0x14))) {
>        Return(One)
>    }
>    If(LNot(LGreater(Arg0, 0x1e))) {
>        Return(0x2)
>    }
>    If(LNot(LGreater(Arg0, 0x2d))) {
>        Return(One)
>    }
>    If(LNot(LGreater(Arg0, 0x3c))) {
>        Return(0x2)
>    }
>    If(LNot(LGreater(Arg0, 0x5a))) {
>        Return(One)
>    }
>    Return(Zero)
>}
>Method(SETT, 3, Serialized) {
>    If(And(Arg1, 0x2, )) {
>        If(LAnd(LNot(LGreater(Arg0, 0x78)), And(Arg2, 0x2, ))) {
>            Return(0xb)
>        }
>        If(LAnd(LNot(LGreater(Arg0, 0xb4)), And(Arg2, One, ))) {
>            Return(0x9)
>        }
>    }
>    Return(0x4)
>}
>Scope(_SB_) {
>    Name(LIDF, One)
>    Device(LID_) {
>        Name(_HID, 0x0d0cd041)
>        Method(_LID) {
>            Return(LIDF)
>        }
>        Name(_PRW, Package(0x2) {
>            0x19,
>            0x4,
>        })
>    }
>    Device(SLPB) {
>        Name(_HID, 0x0e0cd041)
>        Method(_STA) {
>            Return(0xb)
>        }
>    }
>    Device(BAT0) {
>        Name(_HID, 0x0a0cd041)
>        Name(_UID, One)
>        Name(_PCL, Package(0x1) {
>            _SB_,
>        })
>        Name(PBIF, Package(0xd) {
>            One,
>            0x10cc,
>            0x10cc,
>            One,
>            0x3a98,
>            Zero,
>            Zero,
>            Zero,
>            Zero,
>            "Main",
>            "0000",
>            "Li-ion",
>            "",
>        })
>        Name(PBST, Package(0x4) {
>            One,
>            0x0a90,
>            0x1000,
>            0x2a30,
>        })
>        Method(_STA) {
>            If(^^PCI0.LPCB.EC0_.ECOK) {
>                If(LAnd(RDEC(0x94), One)) {
>                    Return(0x1f)
>                }
>                Else {
>                    Return(0xf)
>                }
>            }
>            Else {
>                Return(0x1f)
>            }
>        }
>        Name(SERB, "0000")
>        Method(_BIF) {
>            If(^^PCI0.LPCB.EC0_.ECOK) {
>                Store(RDEC(0xaa), Local0)
>                Store(RDEC(0xab), Local5)
>                ShiftLeft(Local5, 0x8, Local5)
>                Add(Local0, Local5, Local0)
>                Store(RDEC(0xac), Local1)
>                Store(RDEC(0xad), Local5)
>                ShiftLeft(Local5, 0x8, Local5)
>                Add(Local1, Local5, Local1)
>                Store(Local1, Index(PBIF, One, ))
>                Store(Local0, Index(PBIF, 0x2, ))
>                Store(Zero, Index(PBIF, 0x8, ))
>                Store(RDEC(0xdf), Local0)
>                If(LEqual(Local0, 0x6)) {
>                    Store("NBP6A24A1", Index(PBIF, 0x9, ))
>                }
>                Else {
>                    Store("NBP6A24A1", Index(PBIF, 0x9, ))
>                }
>                Store(RDEC(0xb9), Local0)
>                Store(RDEC(0xba), Local5)
>                ShiftLeft(Local5, 0x8, Local5)
>                Add(Local0, Local5, Local0)
>                Store(ITOS(Local0), Local1)
>                Store(Local1, Index(PBIF, 0xa, ))
>            }
>            Return(PBIF)
>        }
>        Method(_BST) {
>            If(^^PCI0.LPCB.EC0_.ECOK) {
>                Store(RDEC(0x94), Local1)
>                Store(And(Local1, 0x10, ), Local1)
>                ShiftRight(Local1, 0x4, Local1)
>                Store(RDEC(0x95), Local0)
>                Store(And(Local0, One, ), Local0)
>                ShiftLeft(Local1, One, Local2)
>                Or(Local0, Local2, Local3)
>                Store(RDEC(0xc6), Local2)
>                Multiply(Local2, 0x0100, Local1)
>                Store(RDEC(0xc5), Local0)
>                Add(Local1, Local0, Local1)
>                Store(Local1, Index(PBST, One, ))
>                Store(And(RDEC(0xa4), 0x7f, ), Local0)
>                If(LLess(Local0, 0xf)) {
>                    Or(Local3, 0x4, Local3)
>                }
>                Store(Local3, Index(PBST, Zero, ))
>                Store(DerefOf(Index(PBIF, 0x2, )), Local1)
>                Multiply(Local1, Local0, Local2)
>                Divide(Local2, 0x64, Local3, Local2)
>                Add(Local2, 0xa, Local2)
>                Store(Local2, Index(PBST, 0x2, ))
>                Store(DerefOf(Index(PBIF, 0x4, )), Local3)
>                Store(Local3, Index(PBST, 0x3, ))
>            }
>            Else {
>                Store(One, Index(PBST, Zero, ))
>                Store(0x78, Index(PBST, One, ))
>                Store(0x0bb8, Index(PBST, 0x2, ))
>                Store(0x3a98, Index(PBST, 0x3, ))
>            }
>            Return(PBST)
>        }
>    }
>    Method(ITOS, 1) {
>        Store("", Local0)
>        Store(0x4, Local1)
>        While(Local1) {
>            Decrement(Local1)
>            And(ShiftRight(Arg0, ShiftLeft(Local1, 0x2, ), ), 0xf, Local4)
>            Store(DerefOf(Index(CHAR, Local4, )), Local2)
>            Concatenate(Local0, Local2, Local5)
>            Store(Local5, Local0)
>        }
>        Return(Local0)
>    }
>    Name(CHAR, Package(0x10) {
>        "0",
>        "1",
>        "2",
>        "3",
>        "4",
>        "5",
>        "6",
>        "7",
>        "8",
>        "9",
>        "A",
>        "B",
>        "C",
>        "D",
>        "E",
>        "F",
>    })
>    Name(PWRS, One)
>    Device(ADP0) {
>        Name(_PCL, Package(0x1) {
>            _SB_,
>        })
>        Name(_HID, "ACPI0003")
>        Method(_PSR) {
>            If(LAnd(^^PCI0.LPCB.EC0_.ECOK, LEqual(And(FLAS, 0x8, ), Zero))) {
>                Or(FLAS, 0x10, FLAS)
>                Store(RDEC(0x92), Local0)
>                Store(And(Local0, 0x8, ), Local0)
>                ShiftRight(Local0, 0x3, Local0)
>                If(Local0) {
>                    Store(One, PWRS)
>                    Return(One)
>                }
>                Else {
>                    Store(Zero, PWRS)
>                    Return(Zero)
>                }
>            }
>            Else {
>                Return(One)
>            }
>        }
>        Method(_STA) {
>            Return(0xf)
>        }
>    }
>    Device(PWRB) {
>        Name(_HID, 0x0c0cd041)
>        Name(_PRW, Package(0x2) {
>            0x1d,
>            0x4,
>        })
>    }
>    Device(PCI0) {
>        Method(_INI) {
>            If(CondRefOf(_OSI, Local0)) {
>                Store(0x07d1, OSYS)
>                If(MPEN) {
>                    Store(0x3d, SMIF)
>                    Store(Zero, TRP0)
>                }
>            }
>            Else {
>                Store(0x07d0, OSYS)
>            }
>        }
>        Name(_HID, 0x080ad041)
>        Name(_CID, 0x030ad041)
>        Name(_ADR, Zero)
>        Name(_BBN, Zero)
>        OperationRegion(HBUS, PCI_Config, 0x40, 0xc0)
>        Field(HBUS, DWordAcc, NoLock, Preserve) {
>            Offset(0x50),
>            ,	4,
>            PM0H,	2,
>            Offset(0x51),
>            PM1L,	2,
>            ,	2,
>            PM1H,	2,
>            Offset(0x52),
>            PM2L,	2,
>            ,	2,
>            PM2H,	2,
>            Offset(0x53),
>            PM3L,	2,
>            ,	2,
>            PM3H,	2,
>            Offset(0x54),
>            PM4L,	2,
>            ,	2,
>            PM4H,	2,
>            Offset(0x55),
>            PM5L,	2,
>            ,	2,
>            PM5H,	2,
>            Offset(0x56),
>            PM6L,	2,
>            ,	2,
>            PM6H,	2,
>            Offset(0x57),
>            ,	7,
>            HENA,	1,
>            Offset(0x5c),
>            ,	3,
>            TOUD,	5
>        }
>        Name(BUF0, Buffer(0x01ee) {0x88, 0xd, 0x0, 0x2, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x87, 0x17, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x87, 0x17, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xc, 0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0xff, 0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x7f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xe, 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0, 0xff, 0xff, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0x0, 0xff, 0xff, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xbf, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd4, 0xfe, 0xff, 0x4f, 0xd4, 0xfe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
>        Method(_CRS, 0, Serialized) {
>            If(PM1L) {
>                CreateDWordField(BUF0, 0x7c, C0LN)
>                Store(Zero, C0LN)
>            }
>            If(LEqual(PM1L, One)) {
>                CreateBitField(BUF0, 0x0358, C0RW)
>                Store(Zero, C0RW)
>            }
>            If(PM1H) {
>                CreateDWordField(BUF0, 0x96, C4LN)
>                Store(Zero, C4LN)
>            }
>            If(LEqual(PM1H, One)) {
>                CreateBitField(BUF0, 0x0428, C4RW)
>                Store(Zero, C4RW)
>            }
>            If(PM2L) {
>                CreateDWordField(BUF0, 0xb0, C8LN)
>                Store(Zero, C8LN)
>            }
>            If(LEqual(PM2L, One)) {
>                CreateBitField(BUF0, 0x04f8, C8RW)
>                Store(Zero, C8RW)
>            }
>            If(PM2H) {
>                CreateDWordField(BUF0, 0xca, CCLN)
>                Store(Zero, CCLN)
>            }
>            If(LEqual(PM2H, One)) {
>                CreateBitField(BUF0, 0x05c8, CCRW)
>                Store(Zero, CCRW)
>            }
>            If(PM3L) {
>                CreateDWordField(BUF0, 0xe4, D0LN)
>                Store(Zero, D0LN)
>            }
>            If(LEqual(PM3L, One)) {
>                CreateBitField(BUF0, 0x0698, D0RW)
>                Store(Zero, D0RW)
>            }
>            If(PM3H) {
>                CreateDWordField(BUF0, 0xfe, D4LN)
>                Store(Zero, D4LN)
>            }
>            If(LEqual(PM3H, One)) {
>                CreateBitField(BUF0, 0x0768, D4RW)
>                Store(Zero, D4RW)
>            }
>            If(PM4L) {
>                CreateDWordField(BUF0, 0x0118, D8LN)
>                Store(Zero, D8LN)
>            }
>            If(LEqual(PM4L, One)) {
>                CreateBitField(BUF0, 0x0838, D8RW)
>                Store(Zero, D8RW)
>            }
>            If(PM4H) {
>                CreateDWordField(BUF0, 0x0132, DCLN)
>                Store(Zero, DCLN)
>            }
>            If(LEqual(PM4H, One)) {
>                CreateBitField(BUF0, 0x0908, DCRW)
>                Store(Zero, DCRW)
>            }
>            If(PM5L) {
>                CreateDWordField(BUF0, 0x014c, E0LN)
>                Store(Zero, E0LN)
>            }
>            If(LEqual(PM5L, One)) {
>                CreateBitField(BUF0, 0x09d8, E0RW)
>                Store(Zero, E0RW)
>            }
>            If(PM5H) {
>                CreateDWordField(BUF0, 0x0166, E4LN)
>                Store(Zero, E4LN)
>            }
>            If(LEqual(PM5H, One)) {
>                CreateBitField(BUF0, 0x0aa8, E4RW)
>                Store(Zero, E4RW)
>            }
>            If(PM6L) {
>                CreateDWordField(BUF0, 0x0180, E8LN)
>                Store(Zero, E8LN)
>            }
>            If(LEqual(PM6L, One)) {
>                CreateBitField(BUF0, 0x0b78, E8RW)
>                Store(Zero, E8RW)
>            }
>            If(PM6H) {
>                CreateDWordField(BUF0, 0x019a, ECLN)
>                Store(Zero, ECLN)
>            }
>            If(LEqual(PM6H, One)) {
>                CreateBitField(BUF0, 0x0c48, ECRW)
>                Store(Zero, ECRW)
>            }
>            If(PM0H) {
>                CreateDWordField(BUF0, 0x01b4, F0LN)
>                Store(Zero, F0LN)
>            }
>            If(LEqual(PM0H, One)) {
>                CreateBitField(BUF0, 0x0d18, F0RW)
>                Store(Zero, F0RW)
>            }
>            If(TPMP) {
>                CreateDWordField(BUF0, 0x01e8, TPML)
>                Store(0x5000, TPML)
>            }
>            CreateDWordField(BUF0, 0x01c2, M1MN)
>            CreateDWordField(BUF0, 0x01c6, M1MX)
>            CreateDWordField(BUF0, 0x01ce, M1LN)
>            ShiftLeft(TOUD, 0x1b, M1MN)
>            Add(Subtract(M1MX, M1MN, ), One, M1LN)
>            Return(BUF0)
>        }
>        Method(_PRT) {
>            If(GPIC) {
>                Return(Package(0x11) {
>                    Package(0x4) {
>                        0x0001ffff,
>                        Zero,
>                        Zero,
>                        0x10,
>                    },
>                    Package(0x4) {
>                        0x0002ffff,
>                        Zero,
>                        Zero,
>                        0x10,
>                    },
>                    Package(0x4) {
>                        0x0007ffff,
>                        Zero,
>                        Zero,
>                        0x10,
>                    },
>                    Package(0x4) {
>                        0x001bffff,
>                        Zero,
>                        Zero,
>                        0x16,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        Zero,
>                        Zero,
>                        0x11,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        One,
>                        Zero,
>                        0x10,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        0x2,
>                        Zero,
>                        0x12,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        0x3,
>                        Zero,
>                        0x13,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        Zero,
>                        Zero,
>                        0x17,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        One,
>                        Zero,
>                        0x13,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        0x2,
>                        Zero,
>                        0x12,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        0x3,
>                        Zero,
>                        0x10,
>                    },
>                    Package(0x4) {
>                        0x001effff,
>                        Zero,
>                        Zero,
>                        0x16,
>                    },
>                    Package(0x4) {
>                        0x001effff,
>                        One,
>                        Zero,
>                        0x14,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        Zero,
>                        Zero,
>                        0x12,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        One,
>                        Zero,
>                        0x13,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        0x3,
>                        Zero,
>                        0x10,
>                    },
>                })
>            }
>            Else {
>                Return(Package(0x11) {
>                    Package(0x4) {
>                        0x0001ffff,
>                        Zero,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x0002ffff,
>                        Zero,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x0007ffff,
>                        Zero,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001bffff,
>                        Zero,
>                        ^LPCB.LNKG,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        Zero,
>                        ^LPCB.LNKB,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        One,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        0x2,
>                        ^LPCB.LNKC,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001cffff,
>                        0x3,
>                        ^LPCB.LNKD,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        Zero,
>                        ^LPCB.LNKH,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        One,
>                        ^LPCB.LNKD,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        0x2,
>                        ^LPCB.LNKC,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001dffff,
>                        0x3,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001effff,
>                        Zero,
>                        ^LPCB.LNKG,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001effff,
>                        One,
>                        ^LPCB.LNKE,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        Zero,
>                        ^LPCB.LNKC,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        One,
>                        ^LPCB.LNKD,
>                        Zero,
>                    },
>                    Package(0x4) {
>                        0x001fffff,
>                        0x3,
>                        ^LPCB.LNKA,
>                        Zero,
>                    },
>                })
>            }
>        }
>        Device(PDRC) {
>            Name(_HID, 0x020cd041)
>            Name(_UID, One)
>            Name(BUF0, Buffer(0x62) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0xe0, 0x0, 0x0, 0x0, 0x10, 0x86, 0x9, 0x0, 0x1, 0x0, 0x40, 0xd1, 0xfe, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x80, 0xd1, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x90, 0xd1, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0xc0, 0xd1, 0xfe, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xd2, 0xfe, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xd4, 0xfe, 0x0, 0x50, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x50, 0xd4, 0xfe, 0x0, 0xb0, 0x4, 0x0, 0x79, 0x0 })
>            Name(BUF1, Buffer(0x56) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0xe0, 0x0, 0x0, 0x0, 0x10, 0x86, 0x9, 0x0, 0x1, 0x0, 0x40, 0xd1, 0xfe, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x80, 0xd1, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x90, 0xd1, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0xc0, 0xd1, 0xfe, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xd2, 0xfe, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x50, 0xd4, 0xfe, 0x0, 0xb0, 0x4, 0x0, 0x79, 0x0 })
>            Method(_CRS, 0, Serialized) {
>                If(LNot(TPMP)) {
>                    Return(BUF0)
>                }
>                Return(BUF1)
>            }
>        }
>        Device(PEGP) {
>            Name(_ADR, 0x00010000)
>            Device(VGA_) {
>                Name(_ADR, Zero)
>                Name(CRTA, One)
>                Name(LCDA, One)
>                Name(TVAF, Zero)
>                Name(DVIA, Zero)
>                Name(TOGF, Zero)
>                Method(_DOD) {
>                    Return(Package(0x4) {
>                        0x00010100,
>                        0x00010110,
>                        0x0200,
>                        0x0120,
>                    })
>                }
>                Device(CRT_) {
>                    Name(_ADR, 0x0100)
>                    Method(_DCS) {
>                        If(CRTA) {
>                            Return(0x1f)
>                        }
>                        Else {
>                            Return(0x1d)
>                        }
>                    }
>                    Method(_DGS) {
>                        If(CRTA) {
>                            Return(One)
>                        }
>                        Else {
>                            Return(Zero)
>                        }
>                    }
>                }
>                Device(LCD_) {
>                    Name(_ADR, 0x0110)
>                    Method(_DCS) {
>                        If(LCDA) {
>                            Return(0x1f)
>                        }
>                        Else {
>                            Return(0x1d)
>                        }
>                    }
>                    Method(_DGS) {
>                        If(LCDA) {
>                            Return(One)
>                        }
>                        Else {
>                            Return(Zero)
>                        }
>                    }
>                }
>                Device(TV__) {
>                    Name(_ADR, 0x0200)
>                    Method(_DCS) {
>                        If(TVAF) {
>                            Return(0x1f)
>                        }
>                        Else {
>                            Return(0x1d)
>                        }
>                    }
>                    Method(_DGS) {
>                        If(TVAF) {
>                            Return(One)
>                        }
>                        Else {
>                            Return(Zero)
>                        }
>                    }
>                }
>                Device(DVI_) {
>                    Name(_ADR, 0x0120)
>                    Method(_DCS) {
>                        If(DVIA) {
>                            Return(0x1f)
>                        }
>                        Else {
>                            Return(0x1d)
>                        }
>                    }
>                    Method(_DGS) {
>                        If(DVIA) {
>                            Return(One)
>                        }
>                        Else {
>                            Return(Zero)
>                        }
>                    }
>                }
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            Zero,
>                            0x10,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            Zero,
>                            0x11,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            Zero,
>                            0x12,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            Zero,
>                            0x13,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(GFX0) {
>            Name(_ADR, 0x00020000)
>            Method(_DOS, 1) {
>                Store(And(Arg0, 0x3, ), DSEN)
>            }
>            Method(_DOD) {
>                If(LEqual(NDID, One)) {
>                    Name(TMP1, Package(0x1) {
>                        Ones,
>                    })
>                    Store(Or(0x00010000, DID1, ), Index(TMP1, Zero, ))
>                    Return(TMP1)
>                }
>                If(LEqual(NDID, 0x2)) {
>                    Name(TMP2, Package(0x2) {
>                        Ones,
>                        Ones,
>                    })
>                    Store(Or(0x00010000, DID1, ), Index(TMP2, Zero, ))
>                    Store(Or(0x00010000, DID2, ), Index(TMP2, One, ))
>                    Return(TMP2)
>                }
>                If(LEqual(NDID, 0x3)) {
>                    Name(TMP3, Package(0x3) {
>                        Ones,
>                        Ones,
>                        Ones,
>                    })
>                    Store(Or(0x00010000, DID1, ), Index(TMP3, Zero, ))
>                    Store(Or(0x00010000, DID2, ), Index(TMP3, One, ))
>                    Store(Or(0x00010000, DID3, ), Index(TMP3, 0x2, ))
>                    Return(TMP3)
>                }
>                If(LEqual(NDID, 0x4)) {
>                    Name(TMP4, Package(0x4) {
>                        Ones,
>                        Ones,
>                        Ones,
>                        Ones,
>                    })
>                    Store(Or(0x00010000, DID1, ), Index(TMP4, Zero, ))
>                    Store(Or(0x00010000, DID2, ), Index(TMP4, One, ))
>                    Store(Or(0x00010000, DID3, ), Index(TMP4, 0x2, ))
>                    Store(Or(0x00010000, DID4, ), Index(TMP4, 0x3, ))
>                    Return(TMP4)
>                }
>                Name(TMP5, Package(0x5) {
>                    Ones,
>                    Ones,
>                    Ones,
>                    Ones,
>                    Ones,
>                })
>                Store(Or(0x00010000, DID1, ), Index(TMP5, Zero, ))
>                Store(Or(0x00010000, DID2, ), Index(TMP5, One, ))
>                Store(Or(0x00010000, DID3, ), Index(TMP5, 0x2, ))
>                Store(Or(0x00010000, DID4, ), Index(TMP5, 0x3, ))
>                Store(Or(0x00010000, DID5, ), Index(TMP5, 0x4, ))
>                Return(TMP5)
>            }
>            Device(DD01) {
>                Method(_ADR, 0, Serialized) {
>                    Return(And(0xffff, DID1, ))
>                }
>                Method(_DCS) {
>                    TRAP(One)
>                    If(And(CSTE, One, )) {
>                        Return(0x1f)
>                    }
>                    Return(0x1d)
>                }
>                Method(_DGS) {
>                    If(And(NSTE, One, )) {
>                        Return(One)
>                    }
>                    Return(Zero)
>                }
>                Method(_DSS, 1) {
>                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
>                        Store(NSTE, CSTE)
>                    }
>                }
>            }
>            Device(DD02) {
>                Method(_ADR, 0, Serialized) {
>                    Return(And(0xffff, DID2, ))
>                }
>                Method(_DCS) {
>                    TRAP(One)
>                    If(And(CSTE, 0x2, )) {
>                        Return(0x1f)
>                    }
>                    Return(0x1d)
>                }
>                Method(_DGS) {
>                    If(And(NSTE, 0x2, )) {
>                        Return(One)
>                    }
>                    Return(Zero)
>                }
>                Method(_DSS, 1) {
>                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
>                        Store(NSTE, CSTE)
>                    }
>                }
>            }
>            Device(DD03) {
>                Method(_ADR, 0, Serialized) {
>                    Return(And(0xffff, DID3, ))
>                }
>                Method(_DCS) {
>                    TRAP(One)
>                    If(And(CSTE, 0x4, )) {
>                        Return(0x1f)
>                    }
>                    Return(0x1d)
>                }
>                Method(_DGS) {
>                    If(And(NSTE, 0x4, )) {
>                        Return(One)
>                    }
>                    Return(Zero)
>                }
>                Method(_DSS, 1) {
>                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
>                        Store(NSTE, CSTE)
>                    }
>                }
>            }
>            Device(DD04) {
>                Method(_ADR, 0, Serialized) {
>                    Return(And(0xffff, DID4, ))
>                }
>                Method(_DCS) {
>                    TRAP(One)
>                    If(And(CSTE, 0x8, )) {
>                        Return(0x1f)
>                    }
>                    Return(0x1d)
>                }
>                Method(_DGS) {
>                    If(And(NSTE, 0x8, )) {
>                        Return(One)
>                    }
>                    Return(Zero)
>                }
>                Method(_DSS, 1) {
>                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
>                        Store(NSTE, CSTE)
>                    }
>                }
>            }
>            Device(DD05) {
>                Method(_ADR, 0, Serialized) {
>                    Return(And(0xffff, DID5, ))
>                }
>                Method(_DCS) {
>                    TRAP(One)
>                    If(And(CSTE, 0x10, )) {
>                        Return(0x1f)
>                    }
>                    Return(0x1d)
>                }
>                Method(_DGS) {
>                    If(And(NSTE, 0x10, )) {
>                        Return(One)
>                    }
>                    Return(Zero)
>                }
>                Method(_DSS, 1) {
>                    If(LEqual(And(Arg0, 0xc0000000, ), 0xc0000000)) {
>                        Store(NSTE, CSTE)
>                    }
>                }
>            }
>        }
>        Device(HDEF) {
>            Name(_ADR, 0x001b0000)
>            Name(_PRW, Package(0x2) {
>                0x5,
>                0x4,
>            })
>        }
>        Device(RP01) {
>            Name(_ADR, 0x001c0000)
>            OperationRegion(P1CS, PCI_Config, 0x40, 0x0100)
>            Field(P1CS, AnyAcc, NoLock, WriteAsZeros) {
>                Offset(0x1a),
>                ABP1,	1,
>                ,	2,
>                PDC1,	1,
>                ,	2,
>                PDS1,	1,
>                Offset(0x20),
>                Offset(0x22),
>                PSP1,	1,
>                Offset(0x9c),
>                ,	30,
>                HPCS,	1,
>                PMCS,	1
>            }
>            Device(PXS1) {
>                Name(_ADR, Zero)
>                Name(_PRW, Package(0x2) {
>                    0x9,
>                    0x4,
>                })
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            Zero,
>                            0x10,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            Zero,
>                            0x11,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            Zero,
>                            0x12,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            Zero,
>                            0x13,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(RP02) {
>            Name(_ADR, 0x001c0001)
>            OperationRegion(P2CS, PCI_Config, 0x40, 0x0100)
>            Field(P2CS, AnyAcc, NoLock, WriteAsZeros) {
>                Offset(0x1a),
>                ABP2,	1,
>                ,	2,
>                PDC2,	1,
>                ,	2,
>                PDS2,	1,
>                Offset(0x20),
>                Offset(0x22),
>                PSP2,	1,
>                Offset(0x9c),
>                ,	30,
>                HPCS,	1,
>                PMCS,	1
>            }
>            Device(PXS2) {
>                Name(_ADR, Zero)
>                Method(_RMV) {
>                    Return(One)
>                }
>                Name(_PRW, Package(0x2) {
>                    0x9,
>                    0x4,
>                })
>                Name(_EJD, "\_SB.PCI0.USB7.HUB7.PRT7")
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            Zero,
>                            0x11,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            Zero,
>                            0x12,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            Zero,
>                            0x13,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            Zero,
>                            0x10,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(RP03) {
>            Name(_ADR, 0x001c0002)
>            OperationRegion(P3CS, PCI_Config, 0x40, 0x0100)
>            Field(P3CS, AnyAcc, NoLock, WriteAsZeros) {
>                Offset(0x1a),
>                ABP3,	1,
>                ,	2,
>                PDC3,	1,
>                ,	2,
>                PDS3,	1,
>                Offset(0x20),
>                Offset(0x22),
>                PSP3,	1,
>                Offset(0x9c),
>                ,	30,
>                HPCS,	1,
>                PMCS,	1
>            }
>            Device(PXS3) {
>                Name(_ADR, Zero)
>                Name(_PRW, Package(0x2) {
>                    0x9,
>                    0x4,
>                })
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            Zero,
>                            0x12,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            Zero,
>                            0x13,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            Zero,
>                            0x10,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            Zero,
>                            0x11,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(RP04) {
>            Name(_ADR, 0x001c0003)
>            OperationRegion(P4CS, PCI_Config, 0x40, 0x0100)
>            Field(P4CS, AnyAcc, NoLock, WriteAsZeros) {
>                Offset(0x1a),
>                ABP4,	1,
>                ,	2,
>                PDC4,	1,
>                ,	2,
>                PDS4,	1,
>                Offset(0x20),
>                Offset(0x22),
>                PSP4,	1,
>                Offset(0x9c),
>                ,	30,
>                HPCS,	1,
>                PMCS,	1
>            }
>            Device(PXS4) {
>                Name(_ADR, Zero)
>                Name(_PRW, Package(0x2) {
>                    0x9,
>                    0x4,
>                })
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            Zero,
>                            0x13,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            Zero,
>                            0x10,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            Zero,
>                            0x11,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            Zero,
>                            0x12,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x4) {
>                        Package(0x4) {
>                            0xffff,
>                            Zero,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            One,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x2,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0xffff,
>                            0x3,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(USB1) {
>            Name(_ADR, 0x001d0000)
>            Device(HUB1) {
>                Name(_ADR, Zero)
>                Device(PRT1) {
>                    Name(_ADR, One)
>                }
>                Device(PRT2) {
>                    Name(_ADR, 0x2)
>                }
>            }
>            OperationRegion(U1CS, PCI_Config, 0xc4, 0x4)
>            Field(U1CS, DWordAcc, NoLock, Preserve) {
>                U1EN,	2
>            }
>            Name(_PRW, Package(0x2) {
>                0x3,
>                0x4,
>            })
>            Method(_PSW, 1) {
>                If(Arg0) {
>                    Store(0x3, U1EN)
>                }
>                Else {
>                    Store(Zero, U1EN)
>                }
>            }
>        }
>        Device(USB2) {
>            Name(_ADR, 0x001d0001)
>            Device(HUB2) {
>                Name(_ADR, Zero)
>                Device(PRT1) {
>                    Name(_ADR, One)
>                }
>                Device(PRT2) {
>                    Name(_ADR, 0x2)
>                }
>            }
>            OperationRegion(U2CS, PCI_Config, 0xc4, 0x4)
>            Field(U2CS, DWordAcc, NoLock, Preserve) {
>                U2EN,	2
>            }
>            Name(_PRW, Package(0x2) {
>                0x4,
>                0x4,
>            })
>            Method(_PSW, 1) {
>                If(Arg0) {
>                    Store(0x3, U2EN)
>                }
>                Else {
>                    Store(Zero, U2EN)
>                }
>            }
>        }
>        Device(USB3) {
>            Name(_ADR, 0x001d0002)
>            Device(HUB3) {
>                Name(_ADR, Zero)
>                Device(PRT1) {
>                    Name(_ADR, One)
>                }
>                Device(PRT2) {
>                    Name(_ADR, 0x2)
>                }
>            }
>            OperationRegion(U2CS, PCI_Config, 0xc4, 0x4)
>            Field(U2CS, DWordAcc, NoLock, Preserve) {
>                U3EN,	2
>            }
>            Name(_PRW, Package(0x2) {
>                0xc,
>                0x4,
>            })
>            Method(_PSW, 1) {
>                If(Arg0) {
>                    Store(0x3, U3EN)
>                }
>                Else {
>                    Store(Zero, U3EN)
>                }
>            }
>        }
>        Device(USB4) {
>            Name(_ADR, 0x001d0003)
>            Device(HUB4) {
>                Name(_ADR, Zero)
>                Device(PRT1) {
>                    Name(_ADR, One)
>                    Name(_EJD, "\_SB.PCI0.RP02.PXS2")
>                }
>                Device(PRT2) {
>                    Name(_ADR, 0x2)
>                }
>            }
>            OperationRegion(U4CS, PCI_Config, 0xc4, 0x4)
>            Field(U4CS, DWordAcc, NoLock, Preserve) {
>                U4EN,	2
>            }
>            Name(_PRW, Package(0x2) {
>                0xe,
>                0x4,
>            })
>            Method(_PSW, 1) {
>                If(Arg0) {
>                    Store(0x3, U4EN)
>                }
>                Else {
>                    Store(Zero, U4EN)
>                }
>            }
>        }
>        Device(USB7) {
>            Name(_ADR, 0x001d0007)
>            Device(HUB7) {
>                Name(_ADR, Zero)
>                Device(PRT1) {
>                    Name(_ADR, One)
>                }
>                Device(PRT2) {
>                    Name(_ADR, 0x2)
>                }
>                Device(PRT3) {
>                    Name(_ADR, 0x3)
>                }
>                Device(PRT4) {
>                    Name(_ADR, 0x4)
>                }
>                Device(PRT5) {
>                    Name(_ADR, 0x5)
>                }
>                Device(PRT6) {
>                    Name(_ADR, 0x6)
>                }
>                Device(PRT7) {
>                    Name(_ADR, 0x7)
>                    Name(_EJD, "\_SB.PCI0.RP02.PXS2")
>                }
>                Device(PRT8) {
>                    Name(_ADR, 0x8)
>                }
>            }
>            Name(_PRW, Package(0x2) {
>                0xd,
>                0x4,
>            })
>        }
>        Device(PCIB) {
>            Name(_ADR, 0x001e0000)
>            Device(SLT0) {
>                Name(_ADR, Zero)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Device(SLT1) {
>                Name(_ADR, 0x00010000)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Device(SLT2) {
>                Name(_ADR, 0x00020000)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Device(SLT3) {
>                Name(_ADR, 0x00030000)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Device(SLT6) {
>                Name(_ADR, 0x00050000)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Device(LANC) {
>                Name(_ADR, 0x00080000)
>                Name(_PRW, Package(0x2) {
>                    0xb,
>                    0x4,
>                })
>            }
>            Method(_PRT) {
>                If(GPIC) {
>                    Return(Package(0x5) {
>                        Package(0x4) {
>                            0x0006ffff,
>                            Zero,
>                            Zero,
>                            0x12,
>                        },
>                        Package(0x4) {
>                            0x0006ffff,
>                            One,
>                            Zero,
>                            0x11,
>                        },
>                        Package(0x4) {
>                            0x0006ffff,
>                            0x2,
>                            Zero,
>                            0x10,
>                        },
>                        Package(0x4) {
>                            0x0004ffff,
>                            Zero,
>                            Zero,
>                            0x13,
>                        },
>                        Package(0x4) {
>                            0x0004ffff,
>                            One,
>                            Zero,
>                            0x14,
>                        },
>                    })
>                }
>                Else {
>                    Return(Package(0x5) {
>                        Package(0x4) {
>                            0x0006ffff,
>                            Zero,
>                            ^^LPCB.LNKC,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0x0006ffff,
>                            One,
>                            ^^LPCB.LNKB,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0x0006ffff,
>                            0x2,
>                            ^^LPCB.LNKA,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0x0004ffff,
>                            Zero,
>                            ^^LPCB.LNKD,
>                            Zero,
>                        },
>                        Package(0x4) {
>                            0x0004ffff,
>                            One,
>                            ^^LPCB.LNKE,
>                            Zero,
>                        },
>                    })
>                }
>            }
>        }
>        Device(AUD0) {
>            Name(_ADR, 0x001e0002)
>        }
>        Device(MODM) {
>            Name(_ADR, 0x001e0003)
>            Name(_PRW, Package(0x2) {
>                0x5,
>                0x4,
>            })
>        }
>        Device(LPCB) {
>            Name(_ADR, 0x001f0000)
>            OperationRegion(LPC0, PCI_Config, 0x40, 0xc0)
>            Field(LPC0, AnyAcc, NoLock, Preserve) {
>                Offset(0x20),
>                PARC,	8,
>                PBRC,	8,
>                PCRC,	8,
>                PDRC,	8,
>                Offset(0x28),
>                PERC,	8,
>                PFRC,	8,
>                PGRC,	8,
>                PHRC,	8,
>                Offset(0x40),
>                IOD0,	8,
>                IOD1,	8,
>                Offset(0x4c),
>                GD3L,	8,
>                GD3H,	8,
>                GD3M,	8
>            }
>            Device(LNKA) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, One)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PARC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd4, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLA, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PARC, 0xf, ), IRQ0)
>                    Return(RTLA)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PARC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PARC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKB) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x2)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PBRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd8, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLB, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLB, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PBRC, 0xf, ), IRQ0)
>                    Return(RTLB)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PBRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PBRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKC) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x3)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PCRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd4, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLC, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PCRC, 0xf, ), IRQ0)
>                    Return(RTLC)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PCRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PCRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKD) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x4)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PDRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd8, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLD, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLD, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PDRC, 0xf, ), IRQ0)
>                    Return(RTLD)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PDRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PDRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKE) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x5)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PERC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd4, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLE, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLE, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PERC, 0xf, ), IRQ0)
>                    Return(RTLE)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PERC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PERC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKF) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x6)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PFRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd8, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLF, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLF, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PFRC, 0xf, ), IRQ0)
>                    Return(RTLF)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PFRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PFRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKG) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x7)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PGRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd4, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLG, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLG, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PGRC, 0xf, ), IRQ0)
>                    Return(RTLG)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PGRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PGRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(LNKH) {
>                Name(_HID, 0x0f0cd041)
>                Name(_UID, 0x8)
>                Method(_DIS, 0, Serialized) {
>                    Store(0x80, PHRC)
>                }
>                Name(_PRS, Buffer(0x6) {0x23, 0xfa, 0xd8, 0x18, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    Name(RTLH, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
>                    CreateWordField(RTLH, One, IRQ0)
>                    Store(Zero, IRQ0)
>                    ShiftLeft(One, And(PHRC, 0xf, ), IRQ0)
>                    Return(RTLH)
>                }
>                Method(_SRS, 1, Serialized) {
>                    CreateWordField(Arg0, One, IRQ0)
>                    FindSetRightBit(IRQ0, Local0)
>                    Decrement(Local0)
>                    Store(Local0, PHRC)
>                }
>                Method(_STA, 0, Serialized) {
>                    If(And(PHRC, 0x80, )) {
>                        Return(0x9)
>                    }
>                    Else {
>                        Return(0xb)
>                    }
>                }
>            }
>            Device(EC0_) {
>                Name(_HID, 0x090cd041)
>                Name(_GPE, 0x16)
>                Name(ECOK, Zero)
>                Method(_REG, 2) {
>                    If(LEqual(Arg0, 0x3)) {
>                        Store(Arg1, ECOK)
>                        Notify(ADP0, Zero)
>                        Notify(BAT0, 0x80)
>                    }
>                }
>                OperationRegion(ERAM, EmbeddedControl, Zero, 0xff)
>                Field(ERAM, ByteAcc, NoLock, Preserve) {
>                    Offset(0x90),
>                    LSCI,	8,
>                    LHKY,	8,
>                    LIDS,	1,
>                    DOCK,	1,
>                    FNST,	1,
>                    ACST,	1,
>                    BL1_,	1,
>                    BL2_,	1,
>                    ,	1,
>                    DKIF,	1,
>                    SMIE,	1,
>                    WLST,	1,
>                    BTRT,	1,
>                    WLIF,	1,
>                    KSST,	1,
>                    BTST,	1,
>                    BION,	1,
>                    BTON,	1,
>                    B1EX,	1,
>                    ,	3,
>                    B1CG,	1,
>                    Offset(0x95),
>                    B1DC,	1,
>                    ,	3,
>                    B1CF,	1,
>                    Offset(0x96),
>                    L1B1,	1,
>                    L1B2,	1,
>                    Offset(0x97),
>                    Offset(0x99),
>                    BL1P,	7,
>                    Offset(0x9a),
>                    BL2P,	7,
>                    Offset(0x9b),
>                    BDED,	8,
>                    CCTV,	8,
>                    CCLT,	8,
>                    CCHT,	8,
>                    CCST,	8,
>                    CFAS,	8,
>                    Offset(0xa2),
>                    WKSV,	8,
>                    BNDT,	8,
>                    B1PT,	8,
>                    Offset(0xa8),
>                    B1RL,	8,
>                    B1RH,	8,
>                    B1FL,	8,
>                    B1FH,	8,
>                    B1DL,	8,
>                    B1DH,	8,
>                    Offset(0xb4),
>                    OTCD,	8,
>                    Offset(0xb6),
>                    WKLD,	1,
>                    WKKY,	1,
>                    WKLN,	1,
>                    Offset(0xb7),
>                    EBPS,	1,
>                    DKIN,	1,
>                    UDKN,	1,
>                    Offset(0xb8),
>                    CKCH,	1,
>                    SWI4,	1,
>                    SDPF,	1,
>                    Offset(0xb9),
>                    B1SL,	8,
>                    B1SH,	8,
>                    Offset(0xbd),
>                    B1PL,	8,
>                    B1PH,	8,
>                    Offset(0xc1),
>                    THON,	8,
>                    THOF,	8,
>                    VFON,	8,
>                    VFOF,	8,
>                    BPRL,	8,
>                    BPRH,	8,
>                    Offset(0xd1),
>                    DISP,	8,
>                    VGAT,	8,
>                    Offset(0xdf),
>                    BTCN,	8
>                }
>                Mutex(MUT1, 0)
>                Method(_PS0) {
>                    Store(Zero, DFEC)
>                }
>                Method(_PS3) {
>                    Store(One, DFEC)
>                }
>                Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x1, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
>                Method(_Q11) {
>                }
>                Method(_Q13) {
>                    Store(0x13, PO80)
>                    Notify(ADP0, Zero)
>                    Notify(BAT0, 0x80)
>                }
>                Method(_Q14) {
>                    Store(0x14, PO80)
>                    Store(0x14, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                    Notify(LID_, 0x80)
>                    Store(And(RDEC(0x92), One, ), Local0)
>                    If(LEqual(Local0, One)) {
>                        Store(Zero, LIDF)
>                    }
>                    Else {
>                        Store(One, LIDF)
>                    }
>                    Notify(LID_, 0x80)
>                }
>                Method(_Q19) {
>                    Store(0x19, PO80)
>                    Notify(ADP0, Zero)
>                    Notify(BAT0, 0x80)
>                }
>                Method(_Q25) {
>                    Store(0x25, PO80)
>                    Store(0x25, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                    If(LEqual(VGAT, Zero)) {
>                        Store(One, TLST)
>                        HKDS(0xa)
>                    }
>                    Else {
>                        VGA2()
>                    }
>                }
>                Method(_Q26) {
>                    Store(0x26, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q30) {
>                    Store(0x30, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q31) {
>                    Store(0x31, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q32) {
>                    Store(0x32, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q33) {
>                    Store(0x33, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q34) {
>                    Store(0x34, PRM0)
>                    Store(0x89, SMIF)
>                    Store(Zero, TRP0)
>                }
>                Method(_Q40) {
>                    Store(0x86, SMIF)
>                    Store(Zero, TRP0)
>                    Notify(\_TZ_.TZ00, 0x81)
>                    Notify(\_TZ_.TZ01, 0x81)
>                }
>            }
>            Device(DMAC) {
>                Name(_HID, 0x0002d041)
>                Name(_CRS, Buffer(0x25) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x20, 0x47, 0x1, 0x81, 0x0, 0x81, 0x0, 0x1, 0x11, 0x47, 0x1, 0x93, 0x0, 0x93, 0x0, 0x1, 0xd, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
>            }
>            Device(FWHD) {
>                Name(_HID, 0x0008d425)
>                Name(_CRS, Buffer(0xe) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x1, 0x79, 0x0 })
>            }
>            Device(HPET) {
>                Name(_HID, 0x0301d041)
>                Name(_CID, 0x010cd041)
>                Name(BUF0, Buffer(0xe) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xd0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0 })
>                Method(_STA) {
>                    If(LNot(LLess(OSYS, 0x07d1))) {
>                        If(HPAE) {
>                            Return(0xf)
>                        }
>                    }
>                    Else {
>                        If(HPAE) {
>                            Return(0xb)
>                        }
>                    }
>                    Return(Zero)
>                }
>                Method(_CRS, 0, Serialized) {
>                    If(HPAE) {
>                        CreateDWordField(BUF0, 0x4, HPT0)
>                        If(LEqual(HPAS, One)) {
>                            Store(0xfed01000, HPT0)
>                        }
>                        If(LEqual(HPAS, 0x2)) {
>                            Store(0xfed02000, HPT0)
>                        }
>                        If(LEqual(HPAS, 0x3)) {
>                            Store(0xfed03000, HPT0)
>                        }
>                    }
>                    Return(BUF0)
>                }
>            }
>            Device(IPIC) {
>                Name(_HID, 0xd041)
>                Name(_CRS, Buffer(0x8d) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x1, 0x2, 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, 0x30, 0x0, 0x30, 0x0, 0x1, 0x2, 0x47, 0x1, 0x34, 0x0, 0x34, 0x0, 0x1, 0x2, 0x47, 0x1, 0x38, 0x0, 0x38, 0x0, 0x1, 0x2, 0x47, 0x1, 0x3c, 0x0, 0x3c, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa4, 0x0, 0xa4, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa8, 0x0, 0xa8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xac, 0x0, 0xac, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb4, 0x0, 0xb4, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb8, 0x0, 0xb8, 0x0, 0x1, 0x2, 0x47, 0x1, 0xbc, 0x0, 0xbc, 0x0, 0x1, 0x2, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
>            }
>            Device(MATH) {
>                Name(_HID, 0x040cd041)
>                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 0x1, 0x22, 0x0, 0x20, 0x79, 0x0 })
>            }
>            Device(LDRC) {
>                Name(_HID, 0x020cd041)
>                Name(_UID, 0x2)
>                Name(_CRS, Buffer(0x7a) {0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0x1, 0x47, 0x1, 0x63, 0x0, 0x63, 0x0, 0x1, 0x1, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x1, 0x1, 0x47, 0x1, 0x67, 0x0, 0x67, 0x0, 0x1, 0x1, 0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x1, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x1, 0x47, 0x1, 0x92, 0x0, 0x92, 0x0, 0x1, 0x1, 0x47, 0x1, 0x0, 0x4, 0x0, 0x4, 0x1, 0x2, 0x47, 0x1, 0xb2, 0x0, 0xb2, 0x0, 0x1, 0x2, 0x47, 0x1, 0x80, 0x6, 0x80, 0x6, 0x1, 0x20, 0x47, 0x1, 0x0, 0x8, 0x0, 0x8, 0x1, 0x10, 0x47, 0x1, 0x0, 0x10, 0x0, 0x10, 0x1, 0x80, 0x47, 0x1, 0x80, 0x11, 0x80, 0x11, 0x1, 0x40, 0x47, 0x1, 0x40, 0x16, 0x40, 0x16, 0x1, 0x10, 0x79, 0x0 })
>            }
>            Device(CDRC) {
>                Name(_HID, 0x020cd041)
>                Name(_UID, 0x3)
>                Name(BUF0, Buffer(0xa) {0x47, 0x1, 0xb0, 0x6, 0xb0, 0x6, 0x1, 0x40, 0x79, 0x0 })
>                Name(BUF1, Buffer(0xa) {0x47, 0x1, 0xb0, 0x6, 0xb0, 0x6, 0x1, 0x50, 0x79, 0x0 })
>                Name(BUF2, Buffer(0x12) {0x47, 0x1, 0xa0, 0x6, 0xa0, 0x6, 0x1, 0x10, 0x47, 0x1, 0xb0, 0x6, 0xb0, 0x6, 0x1, 0x40, 0x79, 0x0 })
>                Name(BUF3, Buffer(0x12) {0x47, 0x1, 0xa0, 0x6, 0xa0, 0x6, 0x1, 0x10, 0x47, 0x1, 0xb0, 0x6, 0xb0, 0x6, 0x1, 0x50, 0x79, 0x0 })
>                Method(_CRS, 0, Serialized) {
>                    If(EMAE) {
>                        If(CIRP) {
>                            Return(BUF0)
>                        }
>                        Return(BUF1)
>                    }
>                    Else {
>                        If(CIRP) {
>                            Return(BUF2)
>                        }
>                        Return(BUF3)
>                    }
>                }
>            }
>            Device(RTC_) {
>                Name(_HID, 0x000bd041)
>                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x1, 0x8, 0x22, 0x0, 0x1, 0x79, 0x0 })
>            }
>            Device(TIMR) {
>                Name(_HID, 0x0001d041)
>                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x1, 0x4, 0x47, 0x1, 0x50, 0x0, 0x50, 0x0, 0x10, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
>            }
>            Device(SIO1) {
>                Name(_HID, 0x050ad041)
>                Name(_UID, One)
>                Mutex(MX00, 0)
>                OperationRegion(VSIO, SystemIO, 0x2e, 0x2)
>                Field(VSIO, ByteAcc, NoLock, Preserve) {
>                    I359,	8,
>                    D359,	8
>                }
>                IndexField(I359, D359, ByteAcc, NoLock, Preserve) {
>                    Offset(0x7),
>                    LDNM,	8,
>                    Offset(0x22),
>                    PWCT,	8,
>                    PWMG,	8,
>                    Offset(0x25),
>                    DEMD,	8
>                }
>                IndexField(I359, D359, ByteAcc, NoLock, Preserve) {
>                    Offset(0x30),
>                    ACTI,	8,
>                    Offset(0x60),
>                    IOBH,	8,
>                    IOBL,	8,
>                    I2BH,	8,
>                    I2BL,	8,
>                    Offset(0x70),
>                    IRQX,	8,
>                    Offset(0x74),
>                    DMAX,	8,
>                    Offset(0xe0),
>                    HAR_,	8,
>                    Offset(0xf0),
>                    MODX,	8,
>                    OPTX,	8
>                }
>                Method(ENCG) {
>                    Acquire(MX00, 0xffff)
>                    Store(0x55, I359)
>                }
>                Method(EXCG) {
>                    Store(0xaa, I359)
>                    Release(MX00)
>                }
>                Method(SDEV, 1) {
>                    Store(0x7, I359)
>                    Store(Arg0, D359)
>                }
>                Method(RDRG, 1) {
>                    Store(Arg0, I359)
>                    Store(D359, Local0)
>                    Return(Local0)
>                }
>                Method(WRRG, 2) {
>                    Store(Arg0, I359)
>                    Store(Arg1, D359)
>                }
>                Method(READ, 3) {
>                    Acquire(MX00, 0xffff)
>                    If(LEqual(Arg0, Zero)) {
>                        Store(RDRG(Arg1), Local1)
>                    }
>                    And(Local1, Arg2, Local1)
>                    Release(MX00)
>                    Return(Local1)
>                }
>                Method(WRIT, 3) {
>                    Acquire(MX00, 0xffff)
>                    If(LEqual(Arg0, Zero)) {
>                        WRRG(Arg1, Arg2)
>                    }
>                    Release(MX00)
>                }
>                Device(UAR1) {
>                    Name(_HID, 0x0105d041)
>                    Name(BUF0, Buffer(0xd) {0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x79, 0x0 })
>                    Name(RSRC, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x79, 0x0 })
>                    Method(_STA) {
>                        If(CMAP) {
>                            ENCG()
>                            SDEV(0x4)
>                            Store(ACTI, Local0)
>                            Store(PWCT, Local1)
>                            And(Local1, 0x10, Local1)
>                            EXCG()
>                            If(LEqual(Local0, Zero)) {
>                                Return(0xd)
>                            }
>                            If(LNot(LEqual(Local1, 0x10))) {
>                                Return(0xd)
>                            }
>                            Return(0xf)
>                        }
>                        Return(Zero)
>                    }
>                    Method(_DIS) {
>                        ENCG()
>                        SDEV(0x4)
>                        Store(Zero, ACTI)
>                        Store(PWCT, Local0)
>                        And(Local0, 0xef, Local0)
>                        Store(Local0, PWCT)
>                        EXCG()
>                    }
>                    Method(_CRS) {
>                        If(LEqual(_STA(), 0xf)) {
>                            CreateByteField(BUF0, 0x2, IOLO)
>                            CreateByteField(BUF0, 0x3, IOHI)
>                            CreateByteField(BUF0, 0x4, IORL)
>                            CreateByteField(BUF0, 0x5, IORH)
>                            CreateByteField(BUF0, 0x9, IRQL)
>                            ENCG()
>                            SDEV(0x4)
>                            Store(IOBH, Local0)
>                            Store(Local0, IOHI)
>                            Store(IOBL, Local0)
>                            Store(Local0, IOLO)
>                            Store(IOLO, IORL)
>                            Store(IOHI, IORH)
>                            Store(IRQX, Local0)
>                            Store(One, Local1)
>                            ShiftLeft(Local1, Local0, IRQL)
>                            EXCG()
>                            Return(BUF0)
>                        }
>                        Else {
>                            Return(RSRC)
>                        }
>                    }
>                    Name(_PRS, Buffer(0x37) {0x31, 0x4, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x31, 0x4, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x22, 0x10, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x22, 0x8, 0x0, 0x38, 0x79, 0x0 })
>                    Method(_SRS, 1) {
>                        CreateByteField(Arg0, 0x2, IOLO)
>                        CreateByteField(Arg0, 0x3, IOHI)
>                        CreateByteField(Arg0, 0x9, IRQL)
>                        ENCG()
>                        SDEV(0x4)
>                        Store(Zero, ACTI)
>                        Store(PWCT, Local0)
>                        And(Local0, 0xef, Local0)
>                        Store(Local0, PWCT)
>                        Store(IOHI, Local0)
>                        Store(Local0, IOBH)
>                        Store(IOLO, Local0)
>                        Store(Local0, IOBL)
>                        FindSetRightBit(IRQL, Local0)
>                        Decrement(Local0)
>                        Store(Local0, IRQX)
>                        Store(PWCT, Local0)
>                        Or(Local0, 0x10, Local0)
>                        Store(Local0, PWCT)
>                        Store(One, ACTI)
>                        EXCG()
>                        And(IOD0, 0xf8, IOD0)
>                        If(LEqual(IOHI, 0x3)) {
>                            If(LEqual(IOLO, 0xf8)) {
>                                Or(IOD0, Zero, IOD0)
>                            }
>                            Else {
>                                Or(IOD0, 0x7, IOD0)
>                            }
>                        }
>                        Else {
>                            If(LEqual(IOLO, 0xf8)) {
>                                Or(IOD0, One, IOD0)
>                            }
>                            Else {
>                                Or(IOD0, 0x5, IOD0)
>                            }
>                        }
>                    }
>                    Method(_PSC) {
>                        ENCG()
>                        And(PWCT, 0x10, Local0)
>                        EXCG()
>                        If(Local0) {
>                            Return(Zero)
>                        }
>                        Else {
>                            Return(0x3)
>                        }
>                    }
>                    Method(_PS0) {
>                        ENCG()
>                        Or(PWCT, 0x10, PWCT)
>                        EXCG()
>                    }
>                    Method(_PS3) {
>                        ENCG()
>                        And(PWCT, 0xef, PWCT)
>                        EXCG()
>                    }
>                }
>                Device(FIR_) {
>                    Name(_HID, 0x10f0a34d)
>                    Name(BUF0, Buffer(0x18) {0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x47, 0x1, 0x58, 0x1, 0x58, 0x1, 0x1, 0x8, 0x22, 0x8, 0x0, 0x2a, 0x8, 0x0, 0x79, 0x0 })
>                    Name(RSRC, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x79, 0x0 })
>                    Method(_STA) {
>                        If(CMBP) {
>                            ENCG()
>                            SDEV(0x5)
>                            Store(ACTI, Local0)
>                            Store(PWCT, Local1)
>                            And(Local1, 0x20, Local1)
>                            EXCG()
>                            If(LEqual(Local0, Zero)) {
>                                Return(0xd)
>                            }
>                            If(LNot(LEqual(Local1, 0x20))) {
>                                Return(0xd)
>                            }
>                            Return(0xf)
>                        }
>                        Return(Zero)
>                    }
>                    Method(_DIS) {
>                        ENCG()
>                        SDEV(0x5)
>                        Store(Zero, ACTI)
>                        Store(PWCT, Local0)
>                        And(Local0, 0xdf, Local0)
>                        Store(Local0, PWCT)
>                        EXCG()
>                    }
>                    Method(_CRS) {
>                        If(LEqual(_STA(), 0xf)) {
>                            CreateByteField(BUF0, 0x2, IOLO)
>                            CreateByteField(BUF0, 0x3, IOHI)
>                            CreateByteField(BUF0, 0x4, IORL)
>                            CreateByteField(BUF0, 0x5, IORH)
>                            CreateByteField(BUF0, 0xa, I2LO)
>                            CreateByteField(BUF0, 0xb, I2HI)
>                            CreateByteField(BUF0, 0xc, I2RL)
>                            CreateByteField(BUF0, 0xd, I2RH)
>                            CreateByteField(BUF0, 0x11, IRQL)
>                            CreateByteField(BUF0, 0x12, IRQH)
>                            CreateByteField(BUF0, 0x14, DMAC)
>                            ENCG()
>                            SDEV(0x5)
>                            Store(IOBH, Local0)
>                            Store(Local0, IOHI)
>                            Store(IOBL, Local0)
>                            Store(Local0, IOLO)
>                            Store(IOLO, IORL)
>                            Store(IOHI, IORH)
>                            Store(I2BH, Local0)
>                            Store(Local0, I2HI)
>                            Store(I2BL, Local0)
>                            Store(Local0, I2LO)
>                            Store(I2LO, I2RL)
>                            Store(I2HI, I2RH)
>                            Store(IRQX, Local0)
>                            Store(One, Local1)
>                            ShiftLeft(Local1, Local0, IRQL)
>                            Store(DMAX, Local0)
>                            Store(One, Local1)
>                            ShiftLeft(Local1, Local0, DMAC)
>                            EXCG()
>                            Return(BUF0)
>                        }
>                        Else {
>                            Return(RSRC)
>                        }
>                    }
>                    Name(_PRS, Buffer(0xc3) {0x31, 0x4, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x47, 0x1, 0x58, 0x1, 0x58, 0x1, 0x1, 0x8, 0x22, 0x8, 0x0, 0x2a, 0x8, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x47, 0x1, 0x48, 0x1, 0x48, 0x1, 0x1, 0x8, 0x22, 0x8, 0x0, 0x2a, 0x8, 0x0, 0x31, 0x4, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x47, 0x1, 0x58, 0x2, 0x58, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x2a, 0x8, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x47, 0x1, 0x48, 0x2, 0x48, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x2a, 0x8, 0x0, 0x31, 0x4, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x1, 0x8, 0x47, 0x1, 0x58, 0x1, 0x58, 0x1, 0x1, 0x8, 0x22, 0x8, 0x0, 0x2a, 0x2, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x1, 0x8, 0x47, 0x1, 0x48, 0x1, 0x48, 0x1, 0x1, 0x8, 0x22, 0x8, 0x0, 0x2a, 0x2, 0x0, 0x31, 0x4, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x1, 0x8, 0x47, 0x1, 0x58, 0x2, 0x58, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x2a, 0x2, 0x0, 0x31, 0x4, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x1, 0x8, 0x47, 0x1, 0x48, 0x2, 0x48, 0x2, 0x1, 0x8, 0x22, 0x10, 0x0, 0x2a, 0x2, 0x0, 0x38, 0x79, 0x0 })
>                    Method(_SRS, 1) {
>                        CreateByteField(Arg0, 0x2, IOLO)
>                        CreateByteField(Arg0, 0x3, IOHI)
>                        CreateByteField(Arg0, 0x4, IORL)
>                        CreateByteField(Arg0, 0x5, IORH)
>                        CreateByteField(Arg0, 0xa, I2LO)
>                        CreateByteField(Arg0, 0xb, I2HI)
>                        CreateByteField(Arg0, 0xc, I2RL)
>                        CreateByteField(Arg0, 0xd, I2RH)
>                        CreateByteField(Arg0, 0x11, IRQL)
>                        CreateByteField(Arg0, 0x12, IRQH)
>                        CreateByteField(Arg0, 0x14, DMAC)
>                        ENCG()
>                        SDEV(0x5)
>                        Store(IOHI, Local0)
>                        Store(Local0, IOBH)
>                        Store(IOLO, Local0)
>                        Store(Local0, IOBL)
>                        Store(I2HI, Local0)
>                        Store(Local0, I2BH)
>                        Store(I2LO, Local0)
>                        Store(Local0, I2BL)
>                        FindSetRightBit(IRQL, Local0)
>                        Decrement(Local0)
>                        Store(Local0, IRQX)
>                        FindSetRightBit(DMAC, Local0)
>                        Decrement(Local0)
>                        Store(Local0, DMAX)
>                        EXCG()
>                        And(IOD0, 0x8f, IOD0)
>                        If(LEqual(IOHI, 0x3)) {
>                            If(LEqual(IOLO, 0xf8)) {
>                                Or(IOD0, Zero, IOD0)
>                                Store(0x58, GD3L)
>                            }
>                            Else {
>                                Or(IOD0, 0x70, IOD0)
>                                Store(0x48, GD3L)
>                            }
>                            Store(0x2, GD3H)
>                            Store(0xc, GD3M)
>                            Or(GD3L, One, GD3L)
>                        }
>                        Else {
>                            If(LEqual(IOLO, 0xf8)) {
>                                Or(IOD0, 0x10, IOD0)
>                                Store(0x58, GD3L)
>                            }
>                            Else {
>                                Or(IOD0, 0x50, IOD0)
>                                Store(0x48, GD3L)
>                            }
>                            Store(One, GD3H)
>                            Store(0xc, GD3M)
>                            Or(GD3L, One, GD3L)
>                        }
>                    }
>                    Method(_PSC) {
>                        ENCG()
>                        And(PWCT, 0x20, Local0)
>                        EXCG()
>                        If(Local0) {
>                            Return(Zero)
>                        }
>                        Else {
>                            Return(0x3)
>                        }
>                    }
>                    Method(_PS0) {
>                        ENCG()
>                        Or(PWCT, 0x20, PWCT)
>                        EXCG()
>                    }
>                    Method(_PS3) {
>                        ENCG()
>                        And(PWCT, 0xdf, PWCT)
>                        EXCG()
>                    }
>                }
>            }
>            Device(SIO2) {
>                Name(_HID, 0x050ad041)
>                Name(_UID, 0x2)
>                Mutex(MX00, 0)
>                OperationRegion(S036, SystemIO, 0x164e, 0x2)
>                Field(S036, ByteAcc, NoLock, Preserve) {
>                    I036,	8,
>                    D036,	8
>                }
>                IndexField(I036, D036, ByteAcc, NoLock, Preserve) {
>                    AccessAs(ByteAcc, 0),
>                    ,	3,
>                    FPWR,	1,
>                    Offset(0x1),
>                    ,	2,
>                    PPWR,	1,
>                    PMOD,	1,
>                    Offset(0x2),
>                    ,	3,
>                    APWR,	1,
>                    ,	3,
>                    BPWR,	1,
>                    FDCM,	8,
>                    PEMD,	2,
>                    PFDC,	2,
>                    ,	2,
>                    EPPT,	1,
>                    Offset(0x5),
>                    FDCT,	1,
>                    FDCC,	1,
>                    FDCD,	1,
>                    DENS,	2,
>                    SWPD,	1,
>                    Offset(0x7),
>                    FBT_,	2,
>                    ,	2,
>                    PPAP,	1,
>                    BAPD,	1,
>                    AAPD,	1,
>                    FAPD,	1,
>                    Offset(0xa),
>                    ,	6,
>                    MMOD,	2,
>                    FDRT,	2,
>                    Offset(0xc),
>                    BRXI,	1,
>                    BTXO,	1,
>                    BDUX,	1,
>                    BMOD,	3,
>                    ASPD,	1,
>                    BSPD,	1,
>                    Offset(0x12),
>                    IADR,	8,
>                    Offset(0x17),
>                    DSKC,	2,
>                    Offset(0x20),
>                    FADR,	8,
>                    Offset(0x22),
>                    ECPD,	3,
>                    ECPI,	3,
>                    Offset(0x23),
>                    PADR,	8,
>                    AADR,	8,
>                    BADR,	8,
>                    PDMA,	4,
>                    FDMA,	4,
>                    PIRQ,	4,
>                    FIRQ,	4,
>                    BIRQ,	4,
>                    AIRQ,	4,
>                    Offset(0x2b),
>                    FBAR,	8,
>                    IDMA,	8
>                }
>                Method(ENFG) {
>                    Store(0x55, I036)
>                }
>                Method(EXFG) {
>                    Store(0xaa, I036)
>                }
>                Method(SECR, 2) {
>                    Store(Arg0, I036)
>                    Store(Arg1, D036)
>                }
>                Device(ECP_) {
>                    Name(_HID, 0x0104d041)
>                    Name(BUF0, Buffer(0x18) {0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x1, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x1, 0x8, 0x22, 0x20, 0x0, 0x2a, 0x2, 0x0, 0x79, 0x0 })
>                    Method(_STA) {
>                        Return(0xf)
>                    }
>                    Method(_DIS) {
>                    }
>                    Method(_CRS) {
>                        ENFG()
>                        SECR(One, 0x94)
>                        SECR(0x4, 0x2)
>                        SECR(0x23, 0xde)
>                        SECR(0x26, One)
>                        SECR(0x27, 0x5)
>                        EXFG()
>                        Return(BUF0)
>                    }
>                }
>            }
>            Device(PS2K) {
>                Name(_HID, 0x0303d041)
>                Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x23, 0x2, 0x0, 0x1, 0x79, 0x0 })
>            }
>            Device(PS2M) {
>                Name(_HID, 0x130fd041)
>                Name(_CRS, Buffer(0x6) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 })
>            }
>        }
>        Device(PATA) {
>            Name(_ADR, 0x001f0001)
>            OperationRegion(PACS, PCI_Config, 0x40, 0xc0)
>            Field(PACS, DWordAcc, NoLock, Preserve) {
>                PRIT,	16,
>                Offset(0x4),
>                PSIT,	4,
>                Offset(0x8),
>                SYNC,	4,
>                Offset(0xa),
>                SDT0,	2,
>                ,	2,
>                SDT1,	2,
>                Offset(0x14),
>                ICR0,	4,
>                ICR1,	4,
>                ICR2,	4,
>                ICR3,	4,
>                ICR4,	4,
>                ICR5,	4
>            }
>            Device(PRID) {
>                Name(_ADR, Zero)
>                Method(_GTM) {
>                    Name(PBUF, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
>                    CreateDWordField(PBUF, Zero, PIO0)
>                    CreateDWordField(PBUF, 0x4, DMA0)
>                    CreateDWordField(PBUF, 0x8, PIO1)
>                    CreateDWordField(PBUF, 0xc, DMA1)
>                    CreateDWordField(PBUF, 0x10, FLAG)
>                    Store(GETP(PRIT), PIO0)
>                    Store(GDMA(And(SYNC, One, ), And(ICR3, One, ), And(ICR0, One, ), SDT0, And(ICR1, One, )), DMA0)
>                    If(LEqual(DMA0, Ones)) {
>                        Store(PIO0, DMA0)
>                    }
>                    If(And(PRIT, 0x4000, )) {
>                        If(LEqual(And(PRIT, 0x90, ), 0x80)) {
>                            Store(0x0384, PIO1)
>                        }
>                        Else {
>                            Store(GETT(PSIT), PIO1)
>                        }
>                    }
>                    Else {
>                        Store(Ones, PIO1)
>                    }
>                    Store(GDMA(And(SYNC, 0x2, ), And(ICR3, 0x2, ), And(ICR0, 0x2, ), SDT1, And(ICR1, 0x2, )), DMA1)
>                    If(LEqual(DMA1, Ones)) {
>                        Store(PIO1, DMA1)
>                    }
>                    Store(GETF(And(SYNC, One, ), And(SYNC, 0x2, ), PRIT), FLAG)
>                    If(And(LEqual(PIO0, Ones), LEqual(DMA0, Ones), )) {
>                        Store(0x78, PIO0)
>                        Store(0x14, DMA0)
>                        Store(0x3, FLAG)
>                    }
>                    Return(PBUF)
>                }
>                Method(_STM, 3) {
>                    CreateDWordField(Arg0, Zero, PIO0)
>                    CreateDWordField(Arg0, 0x4, DMA0)
>                    CreateDWordField(Arg0, 0x8, PIO1)
>                    CreateDWordField(Arg0, 0xc, DMA1)
>                    CreateDWordField(Arg0, 0x10, FLAG)
>                    If(LEqual(SizeOf(Arg1), 0x0200)) {
>                        And(PRIT, 0x40f0, PRIT)
>                        And(SYNC, 0x2, SYNC)
>                        Store(Zero, SDT0)
>                        And(ICR0, 0x2, ICR0)
>                        And(ICR1, 0x2, ICR1)
>                        And(ICR3, 0x2, ICR3)
>                        And(ICR5, 0x2, ICR5)
>                        CreateWordField(Arg1, 0x62, W490)
>                        CreateWordField(Arg1, 0x6a, W530)
>                        CreateWordField(Arg1, 0x7e, W630)
>                        CreateWordField(Arg1, 0x80, W640)
>                        CreateWordField(Arg1, 0xb0, W880)
>                        CreateWordField(Arg1, 0xba, W930)
>                        Or(PRIT, 0x8004, PRIT)
>                        If(LAnd(And(FLAG, 0x2, ), And(W490, 0x0800, ))) {
>                            Or(PRIT, 0x2, PRIT)
>                        }
>                        Or(PRIT, SETP(PIO0, W530, W640), PRIT)
>                        If(And(FLAG, One, )) {
>                            Or(SYNC, One, SYNC)
>                            Store(SDMA(DMA0), SDT0)
>                            If(LLess(DMA0, 0x1e)) {
>                                Or(ICR3, One, ICR3)
>                            }
>                            If(LLess(DMA0, 0x3c)) {
>                                Or(ICR0, One, ICR0)
>                            }
>                            If(And(W930, 0x2000, )) {
>                                Or(ICR1, One, ICR1)
>                            }
>                        }
>                    }
>                    If(LEqual(SizeOf(Arg2), 0x0200)) {
>                        And(PRIT, 0x3f0f, PRIT)
>                        Store(Zero, PSIT)
>                        And(SYNC, One, SYNC)
>                        Store(Zero, SDT1)
>                        And(ICR0, One, ICR0)
>                        And(ICR1, One, ICR1)
>                        And(ICR3, One, ICR3)
>                        And(ICR5, One, ICR5)
>                        CreateWordField(Arg2, 0x62, W491)
>                        CreateWordField(Arg2, 0x6a, W531)
>                        CreateWordField(Arg2, 0x7e, W631)
>                        CreateWordField(Arg2, 0x80, W641)
>                        CreateWordField(Arg2, 0xb0, W881)
>                        CreateWordField(Arg2, 0xba, W931)
>                        Or(PRIT, 0x8040, PRIT)
>                        If(LAnd(And(FLAG, 0x8, ), And(W491, 0x0800, ))) {
>                            Or(PRIT, 0x20, PRIT)
>                        }
>                        If(And(FLAG, 0x10, )) {
>                            Or(PRIT, 0x4000, PRIT)
>                            If(LGreater(PIO1, 0xf0)) {
>                                Or(PRIT, 0x80, PRIT)
>                            }
>                            Else {
>                                Or(PRIT, 0x10, PRIT)
>                                Store(SETT(PIO1, W531, W641), PSIT)
>                            }
>                        }
>                        If(And(FLAG, 0x4, )) {
>                            Or(SYNC, 0x2, SYNC)
>                            Store(SDMA(DMA1), SDT1)
>                            If(LLess(DMA1, 0x1e)) {
>                                Or(ICR3, 0x2, ICR3)
>                            }
>                            If(LLess(DMA1, 0x3c)) {
>                                Or(ICR0, 0x2, ICR0)
>                            }
>                            If(And(W931, 0x2000, )) {
>                                Or(ICR1, 0x2, ICR1)
>                            }
>                        }
>                    }
>                }
>                Device(P_D0) {
>                    Name(_ADR, Zero)
>                    Method(_GTF) {
>                        Name(PIB0, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef })
>                        CreateByteField(PIB0, One, PMD0)
>                        CreateByteField(PIB0, 0x8, DMD0)
>                        If(And(PRIT, 0x2, )) {
>                            If(LEqual(And(PRIT, 0x9, ), 0x8)) {
>                                Store(0x8, PMD0)
>                            }
>                            Else {
>                                Store(0xa, PMD0)
>                                ShiftRight(And(PRIT, 0x0300, ), 0x8, Local0)
>                                ShiftRight(And(PRIT, 0x3000, ), 0xc, Local1)
>                                Add(Local0, Local1, Local2)
>                                If(LEqual(0x3, Local2)) {
>                                    Store(0xb, PMD0)
>                                }
>                                If(LEqual(0x5, Local2)) {
>                                    Store(0xc, PMD0)
>                                }
>                            }
>                        }
>                        Else {
>                            Store(One, PMD0)
>                        }
>                        If(And(SYNC, One, )) {
>                            Store(Or(SDT0, 0x40, ), DMD0)
>                            If(And(ICR1, One, )) {
>                                If(And(ICR0, One, )) {
>                                    Add(DMD0, 0x2, DMD0)
>                                }
>                                If(And(ICR3, One, )) {
>                                    Store(0x45, DMD0)
>                                }
>                            }
>                        }
>                        Else {
>                            Or(Subtract(And(PMD0, 0x7, ), 0x2, ), 0x20, DMD0)
>                        }
>                        Return(PIB0)
>                    }
>                }
>                Device(P_D1) {
>                    Name(_ADR, One)
>                    Method(_GTF) {
>                        Name(PIB1, Buffer(0xe) {0x3, 0x0, 0x0, 0x0, 0x0, 0xb0, 0xef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xb0, 0xef })
>                        CreateByteField(PIB1, One, PMD1)
>                        CreateByteField(PIB1, 0x8, DMD1)
>                        If(And(PRIT, 0x20, )) {
>                            If(LEqual(And(PRIT, 0x90, ), 0x80)) {
>                                Store(0x8, PMD1)
>                            }
>                            Else {
>                                Add(And(PSIT, 0x3, ), ShiftRight(And(PSIT, 0xc, ), 0x2, ), Local0)
>                                If(LEqual(0x5, Local0)) {
>                                    Store(0xc, PMD1)
>                                }
>                                Else {
>                                    If(LEqual(0x3, Local0)) {
>                                        Store(0xb, PMD1)
>                                    }
>                                    Else {
>                                        Store(0xa, PMD1)
>                                    }
>                                }
>                            }
>                        }
>                        Else {
>                            Store(One, PMD1)
>                        }
>                        If(And(SYNC, 0x2, )) {
>                            Store(Or(SDT1, 0x40, ), DMD1)
>                            If(And(ICR1, 0x2, )) {
>                                If(And(ICR0, 0x2, )) {
>                                    Add(DMD1, 0x2, DMD1)
>                                }
>                                If(And(ICR3, 0x2, )) {
>                                    Store(0x45, DMD1)
>                                }
>                            }
>                        }
>                        Else {
>                            Or(Subtract(And(PMD1, 0x7, ), 0x2, ), 0x20, DMD1)
>                        }
>                        Return(PIB1)
>                    }
>                }
>            }
>        }
>        Device(SATA) {
>            Name(_ADR, 0x001f0002)
>            OperationRegion(SACS, PCI_Config, 0x40, 0xc0)
>            Field(SACS, DWordAcc, NoLock, Preserve) {
>                PRIT,	16,
>                SECT,	16,
>                PSIT,	4,
>                SSIT,	4,
>                Offset(0x8),
>                SYNC,	4,
>                Offset(0xa),
>                SDT0,	2,
>                ,	2,
>                SDT1,	2,
>                Offset(0xb),
>                SDT2,	2,
>                ,	2,
>                SDT3,	2,
>                Offset(0x14),
>                ICR0,	4,
>                ICR1,	4,
>                ICR2,	4,
>                ICR3,	4,
>                ICR4,	4,
>                ICR5,	4,
>                Offset(0x50),
>                MAPV,	2
>            }
>        }
>        Device(SBUS) {
>            Name(_ADR, 0x001f0003)
>            OperationRegion(SMBP, PCI_Config, 0x40, 0xc0)
>            Field(SMBP, DWordAcc, NoLock, Preserve) {
>                ,	2,
>                I2CE,	1
>            }
>            OperationRegion(SMBI, SystemIO, 0x18e0, 0x10)
>            Field(SMBI, ByteAcc, NoLock, Preserve) {
>                HSTS,	8,
>                Offset(0x2),
>                HCON,	8,
>                HCOM,	8,
>                TXSA,	8,
>                DAT0,	8,
>                DAT1,	8,
>                HBDR,	8,
>                PECR,	8,
>                RXSA,	8,
>                SDAT,	16
>            }
>            Method(SSXB, 2, Serialized) {
>                If(STRT()) {
>                    Return(Zero)
>                }
>                Store(Zero, I2CE)
>                Store(0xbf, HSTS)
>                Store(Arg0, TXSA)
>                Store(Arg1, HCOM)
>                Store(0x48, HCON)
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(One)
>                }
>                Return(Zero)
>            }
>            Method(SRXB, 1, Serialized) {
>                If(STRT()) {
>                    Return(0xffff)
>                }
>                Store(Zero, I2CE)
>                Store(0xbf, HSTS)
>                Store(Or(Arg0, One, ), TXSA)
>                Store(0x44, HCON)
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(DAT0)
>                }
>                Return(0xffff)
>            }
>            Method(SWRB, 3, Serialized) {
>                If(STRT()) {
>                    Return(Zero)
>                }
>                Store(Zero, I2CE)
>                Store(0xbf, HSTS)
>                Store(Arg0, TXSA)
>                Store(Arg1, HCOM)
>                Store(Arg2, DAT0)
>                Store(0x48, HCON)
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(One)
>                }
>                Return(Zero)
>            }
>            Method(SRDB, 2, Serialized) {
>                If(STRT()) {
>                    Return(0xffff)
>                }
>                Store(Zero, I2CE)
>                Store(0xbf, HSTS)
>                Store(Or(Arg0, One, ), TXSA)
>                Store(Arg1, HCOM)
>                Store(0x48, HCON)
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(DAT0)
>                }
>                Return(0xffff)
>            }
>            Method(SBLW, 4, Serialized) {
>                If(STRT()) {
>                    Return(Zero)
>                }
>                Store(Arg3, I2CE)
>                Store(0xbf, HSTS)
>                Store(Arg0, TXSA)
>                Store(Arg1, HCOM)
>                Store(SizeOf(Arg2), DAT0)
>                Store(Zero, Local1)
>                Store(DerefOf(Index(Arg2, Zero, )), HBDR)
>                Store(0x54, HCON)
>                While(LGreater(SizeOf(Arg2), Local1)) {
>                    Store(0x0fa0, Local0)
>                    While(LAnd(LNot(And(HSTS, 0x80, )), Local0)) {
>                        Decrement(Local0)
>                        Stall(0x32)
>                    }
>                    If(LNot(Local0)) {
>                        KILL()
>                        Return(Zero)
>                    }
>                    Store(0x80, HSTS)
>                    Increment(Local1)
>                    If(LGreater(SizeOf(Arg2), Local1)) {
>                        Store(DerefOf(Index(Arg2, Local1, )), HBDR)
>                    }
>                }
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(One)
>                }
>                Return(Zero)
>            }
>            Method(SBLR, 3, Serialized) {
>                Name(TBUF, Buffer(0x0100) { })
>                If(STRT()) {
>                    Return(Zero)
>                }
>                Store(Arg2, I2CE)
>                Store(0xbf, HSTS)
>                Store(Or(Arg0, One, ), TXSA)
>                Store(Arg1, HCOM)
>                Store(0x54, HCON)
>                Store(0x0fa0, Local0)
>                While(LAnd(LNot(And(HSTS, 0x80, )), Local0)) {
>                    Decrement(Local0)
>                    Stall(0x32)
>                }
>                If(LNot(Local0)) {
>                    KILL()
>                    Return(Zero)
>                }
>                Store(DAT0, Index(TBUF, Zero, ))
>                Store(0x80, HSTS)
>                Store(One, Local1)
>                While(LLess(Local1, DerefOf(Index(TBUF, Zero, )))) {
>                    Store(0x0fa0, Local0)
>                    While(LAnd(LNot(And(HSTS, 0x80, )), Local0)) {
>                        Decrement(Local0)
>                        Stall(0x32)
>                    }
>                    If(LNot(Local0)) {
>                        KILL()
>                        Return(Zero)
>                    }
>                    Store(HBDR, Index(TBUF, Local1, ))
>                    Store(0x80, HSTS)
>                    Increment(Local1)
>                }
>                If(COMP()) {
>                    Or(HSTS, 0xff, HSTS)
>                    Return(TBUF)
>                }
>                Return(Zero)
>            }
>            Method(STRT, 0, Serialized) {
>                Store(0xc8, Local0)
>                While(Local0) {
>                    If(And(HSTS, 0x40, )) {
>                        Decrement(Local0)
>                        Sleep(One)
>                        If(LEqual(Local0, Zero)) {
>                            Return(One)
>                        }
>                    }
>                    Else {
>                        Store(Zero, Local0)
>                    }
>                }
>                Store(0x0fa0, Local0)
>                While(Local0) {
>                    If(And(HSTS, One, )) {
>                        Decrement(Local0)
>                        Stall(0x32)
>                        If(LEqual(Local0, Zero)) {
>                            KILL()
>                        }
>                    }
>                    Else {
>                        Return(Zero)
>                    }
>                }
>                Return(One)
>            }
>            Method(COMP, 0, Serialized) {
>                Store(0x0fa0, Local0)
>                While(Local0) {
>                    If(And(HSTS, 0x2, )) {
>                        Return(One)
>                    }
>                    Else {
>                        Decrement(Local0)
>                        Stall(0x32)
>                        If(LEqual(Local0, Zero)) {
>                            KILL()
>                        }
>                    }
>                }
>                Return(Zero)
>            }
>            Method(KILL, 0, Serialized) {
>                Or(HCON, 0x2, HCON)
>                Or(HSTS, 0xff, HSTS)
>            }
>        }
>    }
>}
>Method(VGA2) {
>    Store(\_SB_.PCI0.LPCB.EC0_.DISP, Local0)
>    Store(Local0, PO80)
>    Store(Zero, \_SB_.PCI0.PEGP.VGA_.LCDA)
>    Store(Zero, \_SB_.PCI0.PEGP.VGA_.CRTA)
>    Store(Zero, \_SB_.PCI0.PEGP.VGA_.TVAF)
>    If(LEqual(Local0, One)) {
>        Store(One, \_SB_.PCI0.PEGP.VGA_.LCDA)
>    }
>    If(LEqual(Local0, 0x2)) {
>        Store(One, \_SB_.PCI0.PEGP.VGA_.CRTA)
>    }
>    If(LEqual(Local0, 0x3)) {
>        Store(One, \_SB_.PCI0.PEGP.VGA_.LCDA)
>        Store(One, \_SB_.PCI0.PEGP.VGA_.CRTA)
>    }
>    If(LEqual(Local0, 0x4)) {
>        Store(One, \_SB_.PCI0.PEGP.VGA_.TVAF)
>    }
>    If(LEqual(Local0, 0x5)) {
>        Store(One, \_SB_.PCI0.PEGP.VGA_.LCDA)
>        Store(One, \_SB_.PCI0.PEGP.VGA_.TVAF)
>    }
>    Notify(\_SB_.PCI0.PEGP.VGA_, 0x80)
>}
>
>}
>/*
>APIC: Length=104, Revision=1, Checksum=228,
>	OEMID=INTEL, OEM Table ID=CALISTGA, OEM Revision=0x6040000,
>	Creator ID=LOHR, Creator Revision=0x5a
> */
>/*
>HPET: Length=56, Revision=1, Checksum=34,
>	OEMID=INTEL, OEM Table ID=CALISTGA, OEM Revision=0x6040000,
>	Creator ID=LOHR, Creator Revision=0x5a
> */
>/*
>MCFG: Length=60, Revision=1, Checksum=74,
>	OEMID=INTEL, OEM Table ID=CALISTGA, OEM Revision=0x6040000,
>	Creator ID=LOHR, Creator Revision=0x5a
> */
>/*
>BOOT: Length=40, Revision=1, Checksum=165,
>	OEMID=PTLTD, OEM Table ID=$SBFTBL$, OEM Revision=0x6040000,
>	Creator ID= LTP, Creator Revision=0x1
> */
>/*
>APIC: Length=104, Revision=1, Checksum=193,
>	OEMID=TOSINV, OEM Table ID=  APIC, OEM Revision=0x6040000,
>	Creator ID= LTP, Creator Revision=0x0
> */
>/*
>SSDT: Length=522, Revision=1, Checksum=2,
>	OEMID=SataRe, OEM Table ID=SataAhci, OEM Revision=0x1000,
>	Creator ID=INTL, Creator Revision=0x20050624
> */
>/*
>SSDT: Length=1280, Revision=1, Checksum=241,
>	OEMID=PmRef, OEM Table ID=CpuPm, OEM Revision=0x3000,
>	Creator ID=INTL, Creator Revision=0x20050624
> */

Actions: View

Attachments on bug 436959: 297627 | 297628 | 297809 | 297810 | 298166 | 298676 | 298677