lkml.org 
[lkml]   [2012]   [Jan]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    SubjectRe: [PATCH] x86 / reboot: Blacklist Dell OptiPlex 990 known to require PCI reboot
    From
    On Mon, Jan 16, 2012 at 1:41 AM, Matthew Garrett <mjg59@srcf.ucam.org> wrote:
    > On Mon, Jan 09, 2012 at 05:00:08PM +0100, bastien ROUCARIES wrote:
    >> Le Wednesday 16 November 2011 00:19:51, Rafael J. Wysocki a écrit :
    >> > From: Rafael J. Wysocki <rjw@sisk.pl>
    >> >
    >> > Dell OptiPlex 990 is known to require PCI reboot, so add it to the reboot
    >> > blacklist in pci_reboot_dmi_table[].
    >>
    >>
    >> Sorry to hi jack this thread but it seems that dell made the same crap with my precision T1600. See
    >> http://www.centos.org/modules/newbb/print.php?form=1&topic_id=32948&forum=55&order=ASC&start=0
    >> or
    >> https://bugzilla.redhat.com/show_bug.cgi?id=698239
    >
    > Does it work if you disable VT-d in the firmware? If so, then adding it
    > to the reboot method blacklist is the wrong fix - we need to figure out
    > why VT-d interferes with Dell's reboot code.

    Yes it work

    I suppose you need DSDT ? Join here

    >
    > --
    > Matthew Garrett | mjg59@srcf.ucam.org
    /*
    * Intel ACPI Component Architecture
    * AML Disassembler version 20100528
    *
    * Disassembly of DSDT, Mon Jan 16 12:26:10 2012
    *
    *
    * Original Table Header:
    * Signature "DSDT"
    * Length 0x00007341 (29505)
    * Revision 0x02
    * Checksum 0xF7
    * OEM ID "INT430"
    * OEM Table ID "SYSFexxx"
    * OEM Revision 0x00001001 (4097)
    * Compiler ID "INTL"
    * Compiler Version 0x20090903 (537463043)
    */
    DefinitionBlock ("DSDT.aml", "DSDT", 2, "INT430", "SYSFexxx", 0x00001001)
    {
    External (EPTR)
    External (DPTR, IntObj)
    External (HNOT, MethodObj) // 1 Arguments
    External (SNXD)
    External (HWID, IntObj)
    External (IDAB, MethodObj) // 0 Arguments
    External (HDOS, MethodObj) // 0 Arguments
    External (\_PR_.CPU0._PPC)

    Method (BCLR, 1, NotSerialized)
    {
    Store (0x00, Local0)
    While (LLess (Local0, SizeOf (Arg0)))
    {
    BBWR (Arg0, Local0, 0x00)
    Increment (Local0)
    }
    }

    Method (BBWR, 3, NotSerialized)
    {
    CreateByteField (Arg0, Arg1, VAL)
    Store (Arg2, VAL)
    }

    Method (BBRD, 2, NotSerialized)
    {
    CreateByteField (Arg0, Arg1, VAL)
    Return (VAL)
    }

    Method (BWWR, 3, NotSerialized)
    {
    CreateWordField (Arg0, Arg1, VAL)
    Store (Arg2, VAL)
    }

    Method (BWRD, 2, NotSerialized)
    {
    CreateWordField (Arg0, Arg1, VAL)
    Return (VAL)
    }

    Method (BDWR, 3, NotSerialized)
    {
    CreateDWordField (Arg0, Arg1, VAL)
    Store (Arg2, VAL)
    }

    Method (BDRD, 2, NotSerialized)
    {
    CreateDWordField (Arg0, Arg1, VAL)
    Return (VAL)
    }

    Method (STRE, 2, NotSerialized)
    {
    Name (STR1, Buffer (0x50) {})
    Name (STR2, Buffer (0x50) {})
    Store (Arg0, STR1)
    Store (Arg1, STR2)
    Store (Zero, Local0)
    Store (One, Local1)
    While (Local1)
    {
    Store (BBRD (STR1, Local0), Local1)
    Store (BBRD (STR2, Local0), Local2)
    If (LNotEqual (Local1, Local2))
    {
    Return (Zero)
    }

    Increment (Local0)
    }

    Return (One)
    }

    Method (XPTB, 1, NotSerialized)
    {
    Store (SizeOf (Arg0), Local0)
    If (LEqual (ObjectType (Arg0), 0x02))
    {
    Increment (Local0)
    }

    Name (OBUF, Buffer (Local0) {})
    Store (Arg0, OBUF)
    If (LEqual (ObjectType (Arg0), 0x02))
    {
    Decrement (Local0)
    Store (0x00, Index (OBUF, Local0))
    }

    Return (OBUF)
    }

    Method (STDG, 3, NotSerialized)
    {
    Store (Arg0, Local0)
    If (LGreaterEqual (Arg0, 0x0A))
    {
    Divide (Arg0, 0x0A, Local0, Local1)
    Store (STDG (Local1, Arg1, Arg2), Arg2)
    }

    Add (Local0, 0x30, Local0)
    Store (Local0, Index (Arg1, Arg2))
    Increment (Arg2)
    Return (Arg2)
    }

    Method (XPTS, 1, NotSerialized)
    {
    Name (LBUF, Buffer (0x20) {})
    Store (STDG (Arg0, LBUF, 0x00), Local0)
    Store (0x00, Index (LBUF, Local0))
    Increment (Local0)
    Name (OBUF, Buffer (Local0) {})
    Store (LBUF, OBUF)
    Return (OBUF)
    }

    Name (W98S, "Microsoft Windows")
    Name (NT5S, "Microsoft Windows NT")
    Name (WINM, "Microsoft WindowsME: Millennium Edition")
    Name (WXP, "Windows 2001")
    Name (WLG, "Windows 2006")
    Name (WIN7, "Windows 2009")
    Name (LINX, "Linux")
    Scope (\_SB)
    {
    Name (ACOS, 0x00)
    Method (OSID, 0, NotSerialized)
    {
    If (LEqual (ACOS, 0x00))
    {
    Store (0x01, ACOS)
    If (CondRefOf (\_OSI, Local0))
    {
    If (\_OSI (WXP))
    {
    Store (0x10, ACOS)
    }

    If (\_OSI (WLG))
    {
    Store (0x20, ACOS)
    }

    If (\_OSI (WIN7))
    {
    Store (0x80, ACOS)
    }

    If (\_OSI (LINX))
    {
    Store (0x40, ACOS)
    }
    }
    Else
    {
    If (STRE (\_OS, W98S))
    {
    Store (0x02, ACOS)
    }

    If (STRE (\_OS, WINM))
    {
    Store (0x04, ACOS)
    }

    If (STRE (\_OS, NT5S))
    {
    Store (0x08, ACOS)
    }
    }
    }

    Return (ACOS)
    }

    Method (STOS, 0, NotSerialized)
    {
    OSID ()
    GENS (0x06, ACOS, 0x00)
    }

    Method (SOS0, 2, NotSerialized)
    {
    STOS ()
    }

    Method (SOS4, 2, NotSerialized)
    {
    If (LEqual (Arg0, 0x04))
    {
    STOS ()
    }
    }
    }

    Name (SS1, 0x00)
    Name (SS2, 0x00)
    Name (SS3, 0x00)
    Name (SS4, 0x00)
    Name (IOST, 0x0001)
    Name (TOPM, 0xCFFFFFFF)
    Name (ROMS, 0xFFE00000)
    Name (MG1B, 0x00000000)
    Name (MG1L, 0x00000000)
    Name (MG2B, 0xD0000000)
    Name (MG2L, 0x2C80C000)
    Name (MCHB, 0xFED10000)
    Name (MCHL, 0x4000)
    Name (EGPB, 0xFED19000)
    Name (EGPL, 0x1000)
    Name (DMIB, 0xFED18000)
    Name (DMIL, 0x1000)
    Name (IFPB, 0xFED14000)
    Name (IFPL, 0x1000)
    Name (PEBS, 0xF8000000)
    Name (PELN, 0x04000000)
    Name (TTTB, 0xFED20000)
    Name (TTTL, 0x00020000)
    Name (PBLK, 0x0410)
    Name (PM30, 0x0430)
    Name (SRCB, 0xFED1C000)
    Name (SRCL, 0x4000)
    Name (SUSW, 0xFF)
    Name (FMBL, 0x01)
    Name (FDTP, 0x02)
    Name (FUPS, 0x03)
    Name (TCGM, 0x01)
    Name (ACPH, 0xDE)
    Name (ASSB, 0x00)
    Name (AOTB, 0x00)
    Name (AAXB, 0x00)
    Name (PEHP, 0x01)
    Name (SHPC, 0x01)
    Name (PEPM, 0x01)
    Name (PEER, 0x01)
    Name (PECS, 0x01)
    Name (ITKE, 0x00)
    Name (TRTP, 0x01)
    Name (WDTE, 0x01)
    Name (TRTD, 0x02)
    Name (TRTI, 0x03)
    Name (GCDD, 0x01)
    Name (DSTA, 0x0A)
    Name (DSLO, 0x0C)
    Name (DSLC, 0x0E)
    Name (PITS, 0x10)
    Name (SBCS, 0x12)
    Name (SALS, 0x13)
    Name (LSSS, 0x2A)
    Name (SOOT, 0x35)
    Name (PDBR, 0x4D)
    Name (SP1O, 0x2E)
    OperationRegion (GNVS, SystemMemory, 0xCF788E18, 0x01A9)
    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,
    THOF, 8,
    ACT1, 8,
    ACTT, 8,
    PSVT, 8,
    TC1V, 8,
    TC2V, 8,
    TSPV, 8,
    CRTT, 8,
    DTSE, 8,
    DTS1, 8,
    DTS2, 8,
    DTSF, 8,
    Offset (0x25),
    REVN, 8,
    Offset (0x28),
    APIC, 8,
    TCNT, 8,
    PCP0, 8,
    PCP1, 8,
    PPCM, 8,
    PPMF, 32,
    C67L, 8,
    NATP, 8,
    CMAP, 8,
    CMBP, 8,
    LPTP, 8,
    FDCP, 8,
    CMCP, 8,
    CIRP, 8,
    SMSC, 8,
    W381, 8,
    SMC1, 8,
    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,
    KSV0, 32,
    KSV1, 8,
    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,
    DSTS, 8,
    Offset (0x78),
    TPMP, 8,
    TPME, 8,
    MORD, 8,
    TCGP, 8,
    PPRP, 32,
    PPRQ, 8,
    LPPR, 8,
    GTF0, 56,
    GTF2, 56,
    IDEM, 8,
    GTF1, 56,
    BID, 8,
    Offset (0xA0),
    TCMP, 8,
    TCME, 8,
    Offset (0xAA),
    ASLB, 32,
    IBTT, 8,
    IPAT, 8,
    ITVF, 8,
    ITVM, 8,
    IPSC, 8,
    IBLC, 8,
    IBIA, 8,
    ISSC, 8,
    I409, 8,
    I509, 8,
    I609, 8,
    I709, 8,
    IPCF, 8,
    IDMS, 8,
    IF1E, 8,
    HVCO, 8,
    NXD1, 32,
    NXD2, 32,
    NXD3, 32,
    NXD4, 32,
    NXD5, 32,
    NXD6, 32,
    NXD7, 32,
    NXD8, 32,
    GSMI, 8,
    PAVP, 8,
    Offset (0xE1),
    OSCC, 8,
    NEXP, 8,
    SBV1, 8,
    SBV2, 8,
    Offset (0xEB),
    DSEN, 8,
    ECON, 8,
    GPIC, 8,
    CTYP, 8,
    L01C, 8,
    VFN0, 8,
    VFN1, 8,
    VFN2, 8,
    VFN3, 8,
    VFN4, 8,
    Offset (0x100),
    NVGA, 32,
    NVHA, 32,
    AMDA, 32,
    DID6, 32,
    DID7, 32,
    DID8, 32,
    EBAS, 32,
    CPSP, 32,
    EECP, 32,
    EVCP, 32,
    XBAS, 32,
    OBS1, 32,
    OBS2, 32,
    OBS3, 32,
    OBS4, 32,
    OBS5, 32,
    OBS6, 32,
    OBS7, 32,
    OBS8, 32,
    Offset (0x157),
    ATMC, 8,
    PTMC, 8,
    ATRA, 8,
    PTRA, 8,
    PNHM, 32,
    TBAB, 32,
    TBAH, 32,
    RTIP, 8,
    TSOD, 8,
    ATPC, 8,
    PTPC, 8,
    PFLV, 8,
    BREV, 8,
    SGMD, 8,
    SGFL, 8,
    PWOK, 8,
    HLRS, 8,
    DSEL, 8,
    ESEL, 8,
    PSEL, 8,
    PWEN, 8,
    PRST, 8,
    MXD1, 32,
    MXD2, 32,
    MXD3, 32,
    MXD4, 32,
    MXD5, 32,
    MXD6, 32,
    MXD7, 32,
    MXD8, 32,
    GBAS, 16,
    Offset (0x19D),
    ALFP, 8,
    IMON, 8,
    PDTS, 8,
    PKGA, 8,
    PAMT, 8,
    AC0F, 8,
    AC1F, 8,
    DTS3, 8,
    DTS4, 8,
    PECI, 8
    }

    Scope (\_SB)
    {
    Name (PR00, Package (0x29)
    {
    Package (0x04)
    {
    0x001FFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x00,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x01,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x02,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x03,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x01,
    LNKF,
    0x00
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x00,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x00,
    LNKE,
    0x00
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x01,
    LNKF,
    0x00
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x02,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x03,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x03,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x00,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x01,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x02,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x03,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x03,
    LNKD,
    0x00
    }
    })
    Name (AR00, Package (0x29)
    {
    Package (0x04)
    {
    0x001FFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x001FFFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x00,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x01,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x02,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x001DFFFF,
    0x03,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x01,
    0x00,
    0x15
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x001AFFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x00,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x001BFFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x00,
    0x00,
    0x14
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x01,
    0x00,
    0x15
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x02,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0x0019FFFF,
    0x03,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0016FFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x001CFFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x03,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x00,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x01,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x02,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0006FFFF,
    0x03,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0004FFFF,
    0x03,
    0x00,
    0x13
    }
    })
    Name (PR04, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKD,
    0x00
    }
    })
    Name (AR04, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x13
    }
    })
    Name (PR05, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKA,
    0x00
    }
    })
    Name (AR05, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x10
    }
    })
    Name (PR06, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKB,
    0x00
    }
    })
    Name (AR06, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x11
    }
    })
    Name (PR07, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKC,
    0x00
    }
    })
    Name (AR07, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x12
    }
    })
    Name (PR08, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKD,
    0x00
    }
    })
    Name (AR08, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x13
    }
    })
    Name (PR09, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKA,
    0x00
    }
    })
    Name (AR09, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x10
    }
    })
    Name (PR0A, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKA,
    0x00
    }
    })
    Name (AR0A, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x10
    }
    })
    Name (PR0B, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKB,
    0x00
    }
    })
    Name (AR0B, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x11
    }
    })
    Name (PR0E, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKB,
    0x00
    }
    })
    Name (AR0E, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x11
    }
    })
    Name (PR0F, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKC,
    0x00
    }
    })
    Name (AR0F, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x12
    }
    })
    Name (PR02, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKD,
    0x00
    }
    })
    Name (AR02, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x13
    }
    })
    Name (PR0C, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKC,
    0x00
    }
    })
    Name (AR0C, Package (0x04)
    {
    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x12
    }
    })
    Name (PR01, Package (0x14)
    {
    Package (0x04)
    {
    0x0003FFFF,
    0x00,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x01,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x02,
    LNKF,
    0x00
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x03,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x00,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x01,
    LNKD,
    0x00
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x02,
    LNKA,
    0x00
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x03,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x00,
    LNKF,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    LNKE,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x00,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x01,
    LNKF,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x02,
    LNKE,
    0x00
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x03,
    LNKB,
    0x00
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x00,
    LNKC,
    0x00
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x01,
    LNKE,
    0x00
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x02,
    LNKG,
    0x00
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x03,
    LNKF,
    0x00
    }
    })
    Name (AR01, Package (0x14)
    {
    Package (0x04)
    {
    0x0003FFFF,
    0x00,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x01,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x02,
    0x00,
    0x15
    },

    Package (0x04)
    {
    0x0003FFFF,
    0x03,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x00,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x01,
    0x00,
    0x13
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x02,
    0x00,
    0x10
    },

    Package (0x04)
    {
    0x0002FFFF,
    0x03,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x00,
    0x00,
    0x15
    },

    Package (0x04)
    {
    0xFFFF,
    0x01,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0xFFFF,
    0x02,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0xFFFF,
    0x03,
    0x00,
    0x14
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x00,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x01,
    0x00,
    0x15
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x02,
    0x00,
    0x14
    },

    Package (0x04)
    {
    0x0001FFFF,
    0x03,
    0x00,
    0x11
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x00,
    0x00,
    0x12
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x01,
    0x00,
    0x14
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x02,
    0x00,
    0x16
    },

    Package (0x04)
    {
    0x0005FFFF,
    0x03,
    0x00,
    0x15
    }
    })
    Name (PRSA, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {3,4,5,6,7,10,11,12,14,15}
    })
    Alias (PRSA, PRSB)
    Alias (PRSA, PRSC)
    Alias (PRSA, PRSD)
    Alias (PRSA, PRSE)
    Alias (PRSA, PRSF)
    Alias (PRSA, PRSG)
    Alias (PRSA, PRSH)
    Device (PCI0)
    {
    Name (_HID, EisaId ("PNP0A08"))
    Name (_CID, EisaId ("PNP0A03"))
    Name (_ADR, 0x00)
    Method (^BN00, 0, NotSerialized)
    {
    Return (0x00)
    }

    Method (_BBN, 0, NotSerialized)
    {
    Return (BN00 ())
    }

    Name (_UID, 0x00)
    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR00 ())
    }

    Return (PR00 ())
    }

    OperationRegion (HBUS, PCI_Config, 0x00, 0x0100)
    Field (HBUS, DWordAcc, NoLock, Preserve)
    {
    Offset (0x40),
    EPEN, 1,
    , 11,
    EPBR, 20,
    Offset (0x48),
    MHEN, 1,
    , 14,
    MHBR, 17,
    Offset (0x50),
    GCLK, 1,
    Offset (0x54),
    D0EN, 1,
    Offset (0x60),
    PXEN, 1,
    PXSZ, 2,
    , 23,
    PXBR, 6,
    Offset (0x68),
    DIEN, 1,
    , 11,
    DIBR, 20,
    Offset (0x70),
    , 20,
    MEBR, 12,
    Offset (0x80),
    , 4,
    PM0H, 2,
    Offset (0x81),
    PM1L, 2,
    , 2,
    PM1H, 2,
    Offset (0x82),
    PM2L, 2,
    , 2,
    PM2H, 2,
    Offset (0x83),
    PM3L, 2,
    , 2,
    PM3H, 2,
    Offset (0x84),
    PM4L, 2,
    , 2,
    PM4H, 2,
    Offset (0x85),
    PM5L, 2,
    , 2,
    PM5H, 2,
    Offset (0x86),
    PM6L, 2,
    , 2,
    PM6H, 2,
    Offset (0x87),
    Offset (0xA8),
    , 20,
    TUUD, 19,
    Offset (0xBC),
    , 20,
    TLUD, 12,
    Offset (0xC8),
    , 7,
    HTSE, 1
    }

    OperationRegion (MCHT, SystemMemory, 0xFED10000, 0x1100)
    Field (MCHT, ByteAcc, NoLock, Preserve)
    {
    }

    Name (BUF0, ResourceTemplate ()
    {
    WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
    0x0000, // Granularity
    0x0000, // Range Minimum
    0x00FF, // Range Maximum
    0x0000, // Translation Offset
    0x0100, // Length
    ,, )
    DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
    0x00000000, // Granularity
    0x00000000, // Range Minimum
    0x00000CF7, // Range Maximum
    0x00000000, // Translation Offset
    0x00000CF8, // Length
    ,, , TypeStatic)
    IO (Decode16,
    0x0CF8, // Range Minimum
    0x0CF8, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
    0x00000000, // Granularity
    0x00000D00, // Range Minimum
    0x0000FFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x0000F300, // Length
    ,, , TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000A0000, // Range Minimum
    0x000BFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00020000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000C0000, // Range Minimum
    0x000C3FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000C4000, // Range Minimum
    0x000C7FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000C8000, // Range Minimum
    0x000CBFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000CC000, // Range Minimum
    0x000CFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000D0000, // Range Minimum
    0x000D3FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000D4000, // Range Minimum
    0x000D7FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000D8000, // Range Minimum
    0x000DBFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000DC000, // Range Minimum
    0x000DFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000E0000, // Range Minimum
    0x000E3FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000E4000, // Range Minimum
    0x000E7FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000E8000, // Range Minimum
    0x000EBFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000EC000, // Range Minimum
    0x000EFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00004000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x000F0000, // Range Minimum
    0x000FFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00010000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0x00000000, // Range Minimum
    0xFEAFFFFF, // Range Maximum
    0x00000000, // Translation Offset
    0xFEB00000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
    0x00000000, // Granularity
    0xFED40000, // Range Minimum
    0xFED44FFF, // Range Maximum
    0x00000000, // Translation Offset
    0x00005000, // Length
    ,, , AddressRangeMemory, TypeStatic)
    })
    Method (_CRS, 0, Serialized)
    {
    CreateWordField (BUF0, 0x0A, PBMX)
    Store (Subtract (ShiftRight (\PELN, 0x14), 0x02), PBMX)
    CreateWordField (BUF0, 0x0E, PBLN)
    Store (Subtract (ShiftRight (\PELN, 0x14), 0x01), PBLN)
    If (PM1L)
    {
    CreateDWordField (BUF0, 0x7C, C0LN)
    Store (Zero, C0LN)
    }

    If (LEqual (PM1L, 0x01))
    {
    CreateBitField (BUF0, 0x0358, C0RW)
    Store (Zero, C0RW)
    }

    If (PM1H)
    {
    CreateDWordField (BUF0, 0x96, C4LN)
    Store (Zero, C4LN)
    }

    If (LEqual (PM1H, 0x01))
    {
    CreateBitField (BUF0, 0x0428, C4RW)
    Store (Zero, C4RW)
    }

    If (PM2L)
    {
    CreateDWordField (BUF0, 0xB0, C8LN)
    Store (Zero, C8LN)
    }

    If (LEqual (PM2L, 0x01))
    {
    CreateBitField (BUF0, 0x04F8, C8RW)
    Store (Zero, C8RW)
    }

    If (PM2H)
    {
    CreateDWordField (BUF0, 0xCA, CCLN)
    Store (Zero, CCLN)
    }

    If (LEqual (PM2H, 0x01))
    {
    CreateBitField (BUF0, 0x05C8, CCRW)
    Store (Zero, CCRW)
    }

    If (PM3L)
    {
    CreateDWordField (BUF0, 0xE4, D0LN)
    Store (Zero, D0LN)
    }

    If (LEqual (PM3L, 0x01))
    {
    CreateBitField (BUF0, 0x0698, D0RW)
    Store (Zero, D0RW)
    }

    If (PM3H)
    {
    CreateDWordField (BUF0, 0xFE, D4LN)
    Store (Zero, D4LN)
    }

    If (LEqual (PM3H, 0x01))
    {
    CreateBitField (BUF0, 0x0768, D4RW)
    Store (Zero, D4RW)
    }

    If (PM4L)
    {
    CreateDWordField (BUF0, 0x0118, D8LN)
    Store (Zero, D8LN)
    }

    If (LEqual (PM4L, 0x01))
    {
    CreateBitField (BUF0, 0x0838, D8RW)
    Store (Zero, D8RW)
    }

    If (PM4H)
    {
    CreateDWordField (BUF0, 0x0132, DCLN)
    Store (Zero, DCLN)
    }

    If (LEqual (PM4H, 0x01))
    {
    CreateBitField (BUF0, 0x0908, DCRW)
    Store (Zero, DCRW)
    }

    If (PM5L)
    {
    CreateDWordField (BUF0, 0x014C, E0LN)
    Store (Zero, E0LN)
    }

    If (LEqual (PM5L, 0x01))
    {
    CreateBitField (BUF0, 0x09D8, E0RW)
    Store (Zero, E0RW)
    }

    If (PM5H)
    {
    CreateDWordField (BUF0, 0x0166, E4LN)
    Store (Zero, E4LN)
    }

    If (LEqual (PM5H, 0x01))
    {
    CreateBitField (BUF0, 0x0AA8, E4RW)
    Store (Zero, E4RW)
    }

    If (PM6L)
    {
    CreateDWordField (BUF0, 0x0180, E8LN)
    Store (Zero, E8LN)
    }

    If (LEqual (PM6L, 0x01))
    {
    CreateBitField (BUF0, 0x0B78, E8RW)
    Store (Zero, E8RW)
    }

    If (PM6H)
    {
    CreateDWordField (BUF0, 0x019A, ECLN)
    Store (Zero, ECLN)
    }

    If (LEqual (PM6H, 0x01))
    {
    CreateBitField (BUF0, 0x0C48, ECRW)
    Store (Zero, ECRW)
    }

    If (PM0H)
    {
    CreateDWordField (BUF0, 0x01B4, F0LN)
    Store (Zero, F0LN)
    }

    If (LEqual (PM0H, 0x01))
    {
    CreateBitField (BUF0, 0x0D18, F0RW)
    Store (Zero, F0RW)
    }

    CreateDWordField (BUF0, 0x01C2, M1MN)
    CreateDWordField (BUF0, 0x01C6, M1MX)
    CreateDWordField (BUF0, 0x01CE, M1LN)
    ShiftLeft (TLUD, 0x14, M1MN)
    Add (Subtract (M1MX, M1MN), 0x01, M1LN)
    Return (BUF0)
    }

    Name (GUID, Buffer (0x10)
    {
    /* 0000 */ 0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
    /* 0008 */ 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66
    })
    Name (SUPP, 0x00)
    Name (CTRL, 0x00)
    Method (_OSC, 4, Serialized)
    {
    Store (Arg3, Local0)
    CreateDWordField (Local0, 0x00, CDW1)
    CreateDWordField (Local0, 0x04, CDW2)
    CreateDWordField (Local0, 0x08, CDW3)
    If (LAnd (LEqual (Arg0, GUID), NEXP))
    {
    Store (CDW2, SUPP)
    Store (CDW3, CTRL)
    If (Not (And (CDW1, 0x01)))
    {
    If (And (CTRL, 0x01))
    {
    NHPG ()
    }

    If (And (CTRL, 0x04))
    {
    NPME ()
    }
    }

    If (LNotEqual (Arg1, One))
    {
    Or (CDW1, 0x08, CDW1)
    }

    If (LNotEqual (CDW3, CTRL))
    {
    Or (CDW1, 0x10, CDW1)
    }

    Store (CTRL, CDW3)
    Store (CTRL, OSCC)
    Return (Local0)
    }
    Else
    {
    Or (CDW1, 0x04, CDW1)
    Return (Local0)
    }
    }

    Scope (\_SB.PCI0)
    {
    Method (AR00, 0, NotSerialized)
    {
    Return (\_SB.AR00)
    }

    Method (PR00, 0, NotSerialized)
    {
    Return (\_SB.PR00)
    }

    Method (AR01, 0, NotSerialized)
    {
    Return (\_SB.AR01)
    }

    Method (PR01, 0, NotSerialized)
    {
    Return (\_SB.PR01)
    }

    Method (AR02, 0, NotSerialized)
    {
    Return (\_SB.AR02)
    }

    Method (PR02, 0, NotSerialized)
    {
    Return (\_SB.PR02)
    }

    Method (AR04, 0, NotSerialized)
    {
    Return (\_SB.AR04)
    }

    Method (PR04, 0, NotSerialized)
    {
    Return (\_SB.PR04)
    }

    Method (AR05, 0, NotSerialized)
    {
    Return (\_SB.AR05)
    }

    Method (PR05, 0, NotSerialized)
    {
    Return (\_SB.PR05)
    }

    Method (AR06, 0, NotSerialized)
    {
    Return (\_SB.AR06)
    }

    Method (PR06, 0, NotSerialized)
    {
    Return (\_SB.PR06)
    }

    Method (AR07, 0, NotSerialized)
    {
    Return (\_SB.AR07)
    }

    Method (PR07, 0, NotSerialized)
    {
    Return (\_SB.PR07)
    }

    Method (AR08, 0, NotSerialized)
    {
    Return (\_SB.AR08)
    }

    Method (PR08, 0, NotSerialized)
    {
    Return (\_SB.PR08)
    }

    Method (AR09, 0, NotSerialized)
    {
    Return (\_SB.AR09)
    }

    Method (PR09, 0, NotSerialized)
    {
    Return (\_SB.PR09)
    }

    Method (AR0A, 0, NotSerialized)
    {
    Return (\_SB.AR0A)
    }

    Method (PR0A, 0, NotSerialized)
    {
    Return (\_SB.PR0A)
    }

    Method (AR0B, 0, NotSerialized)
    {
    Return (\_SB.AR0B)
    }

    Method (PR0B, 0, NotSerialized)
    {
    Return (\_SB.PR0B)
    }
    }

    Device (GFX0)
    {
    Name (_ADR, 0x00020000)
    Method (_DOS, 1, NotSerialized)
    {
    Store (And (Arg0, 0x07), DSEN)
    If (LEqual (And (Arg0, 0x03), 0x00))
    {
    If (CondRefOf (HDOS))
    {
    HDOS ()
    }
    }
    }

    Method (_DOD, 0, NotSerialized)
    {
    If (CondRefOf (IDAB))
    {
    IDAB ()
    }
    Else
    {
    Store (0x00, NDID)
    If (LNotEqual (DIDL, Zero))
    {
    Store (SDDL (DIDL), DID1)
    }

    If (LNotEqual (DDL2, Zero))
    {
    Store (SDDL (DDL2), DID2)
    }

    If (LNotEqual (DDL3, Zero))
    {
    Store (SDDL (DDL3), DID3)
    }

    If (LNotEqual (DDL4, Zero))
    {
    Store (SDDL (DDL4), DID4)
    }

    If (LNotEqual (DDL5, Zero))
    {
    Store (SDDL (DDL5), DID5)
    }

    If (LNotEqual (DDL6, Zero))
    {
    Store (SDDL (DDL6), DID6)
    }

    If (LNotEqual (DDL7, Zero))
    {
    Store (SDDL (DDL7), DID7)
    }

    If (LNotEqual (DDL8, Zero))
    {
    Store (SDDL (DDL8), DID8)
    }
    }

    If (LEqual (NDID, 0x01))
    {
    Name (TMP1, Package (0x01)
    {
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP1, 0x00))
    Return (TMP1)
    }

    If (LEqual (NDID, 0x02))
    {
    Name (TMP2, Package (0x02)
    {
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP2, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP2, 0x01))
    Return (TMP2)
    }

    If (LEqual (NDID, 0x03))
    {
    Name (TMP3, Package (0x03)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP3, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP3, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP3, 0x02))
    Return (TMP3)
    }

    If (LEqual (NDID, 0x04))
    {
    Name (TMP4, Package (0x04)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP4, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP4, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP4, 0x02))
    Store (Or (0x00010000, DID4), Index (TMP4, 0x03))
    Return (TMP4)
    }

    If (LEqual (NDID, 0x05))
    {
    Name (TMP5, Package (0x05)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP5, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP5, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP5, 0x02))
    Store (Or (0x00010000, DID4), Index (TMP5, 0x03))
    Store (Or (0x00010000, DID5), Index (TMP5, 0x04))
    Return (TMP5)
    }

    If (LEqual (NDID, 0x06))
    {
    Name (TMP6, Package (0x06)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP6, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP6, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP6, 0x02))
    Store (Or (0x00010000, DID4), Index (TMP6, 0x03))
    Store (Or (0x00010000, DID5), Index (TMP6, 0x04))
    Store (Or (0x00010000, DID6), Index (TMP6, 0x05))
    Return (TMP6)
    }

    If (LEqual (NDID, 0x07))
    {
    Name (TMP7, Package (0x07)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP7, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP7, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP7, 0x02))
    Store (Or (0x00010000, DID4), Index (TMP7, 0x03))
    Store (Or (0x00010000, DID5), Index (TMP7, 0x04))
    Store (Or (0x00010000, DID6), Index (TMP7, 0x05))
    Store (Or (0x00010000, DID7), Index (TMP7, 0x06))
    Return (TMP7)
    }

    If (LEqual (NDID, 0x08))
    {
    Name (TMP8, Package (0x08)
    {
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF,
    0xFFFFFFFF
    })
    Store (Or (0x00010000, DID1), Index (TMP8, 0x00))
    Store (Or (0x00010000, DID2), Index (TMP8, 0x01))
    Store (Or (0x00010000, DID3), Index (TMP8, 0x02))
    Store (Or (0x00010000, DID4), Index (TMP8, 0x03))
    Store (Or (0x00010000, DID5), Index (TMP8, 0x04))
    Store (Or (0x00010000, DID6), Index (TMP8, 0x05))
    Store (Or (0x00010000, DID7), Index (TMP8, 0x06))
    Store (Or (0x00010000, DID8), Index (TMP8, 0x07))
    Return (TMP8)
    }

    If (LEqual (NDID, 0x09))
    {
    If (CondRefOf (HWID))
    {
    Return (HWID)
    }
    }

    Return (Package (0x01)
    {
    0x0400
    })
    }

    Device (DD01)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID1, 0x00))
    {
    Return (0x01)
    }
    Else
    {
    Return (And (0xFFFF, DID1))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    Return (CDDS (DID1))
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD1)
    }

    Return (NDDS (DID1))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD02)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID2, 0x00))
    {
    Return (0x02)
    }
    Else
    {
    Return (And (0xFFFF, DID2))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (LIDS, 0x00))
    {
    Return (0x00)
    }

    Return (CDDS (DID2))
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD2)
    }

    Return (NDDS (DID2))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }

    Method (_BCL, 0, NotSerialized)
    {
    Return (Package (0x17)
    {
    0x50,
    0x32,
    0x00,
    0x05,
    0x0A,
    0x0F,
    0x14,
    0x19,
    0x1E,
    0x23,
    0x28,
    0x2D,
    0x32,
    0x37,
    0x3C,
    0x41,
    0x46,
    0x4B,
    0x50,
    0x55,
    0x5A,
    0x5F,
    0x64
    })
    }

    Method (_BCM, 1, NotSerialized)
    {
    If (LAnd (LGreaterEqual (Arg0, 0x00), LLessEqual (Arg0, 0x64)))
    {
    \_SB.PCI0.GFX0.AINT (0x01, Arg0)
    Store (Arg0, BRTL)
    }
    }

    Method (_BQC, 0, NotSerialized)
    {
    Return (BRTL)
    }
    }

    Device (DD03)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID3, 0x00))
    {
    Return (0x03)
    }
    Else
    {
    Return (And (0xFFFF, DID3))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID3, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID3))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD3)
    }

    Return (NDDS (DID3))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD04)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID4, 0x00))
    {
    Return (0x04)
    }
    Else
    {
    Return (And (0xFFFF, DID4))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID4, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID4))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD4)
    }

    Return (NDDS (DID4))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD05)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID5, 0x00))
    {
    Return (0x05)
    }
    Else
    {
    Return (And (0xFFFF, DID5))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID5, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID5))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD5)
    }

    Return (NDDS (DID5))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD06)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID6, 0x00))
    {
    Return (0x06)
    }
    Else
    {
    Return (And (0xFFFF, DID6))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID6, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID6))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD6)
    }

    Return (NDDS (DID6))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD07)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID7, 0x00))
    {
    Return (0x07)
    }
    Else
    {
    Return (And (0xFFFF, DID7))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID7, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID7))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD7)
    }

    Return (NDDS (DID7))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Device (DD08)
    {
    Method (_ADR, 0, Serialized)
    {
    If (LEqual (DID8, 0x00))
    {
    Return (0x08)
    }
    Else
    {
    Return (And (0xFFFF, DID8))
    }
    }

    Method (_DCS, 0, NotSerialized)
    {
    If (LEqual (DID8, 0x00))
    {
    Return (0x0B)
    }
    Else
    {
    Return (CDDS (DID8))
    }
    }

    Method (_DGS, 0, NotSerialized)
    {
    If (LAnd (LEqual (SGMD, 0x01), CondRefOf (SNXD)))
    {
    Return (NXD8)
    }

    Return (NDDS (DID8))
    }

    Method (_DSS, 1, NotSerialized)
    {
    If (LEqual (And (Arg0, 0xC0000000), 0xC0000000))
    {
    Store (NSTE, CSTE)
    }
    }
    }

    Method (SDDL, 1, NotSerialized)
    {
    Increment (NDID)
    Store (And (Arg0, 0x0F0F), Local0)
    Or (0x80000000, Local0, Local1)
    If (LEqual (DIDL, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL2, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL3, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL4, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL5, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL6, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL7, Local0))
    {
    Return (Local1)
    }

    If (LEqual (DDL8, Local0))
    {
    Return (Local1)
    }

    Return (0x00)
    }

    Method (CDDS, 1, NotSerialized)
    {
    Store (And (Arg0, 0x0F0F), Local0)
    If (LEqual (0x00, Local0))
    {
    Return (0x1D)
    }

    If (LEqual (CADL, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL2, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL3, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL4, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL5, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL6, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL7, Local0))
    {
    Return (0x1F)
    }

    If (LEqual (CAL8, Local0))
    {
    Return (0x1F)
    }

    Return (0x1D)
    }

    Method (NDDS, 1, NotSerialized)
    {
    Store (And (Arg0, 0x0F0F), Local0)
    If (LEqual (0x00, Local0))
    {
    Return (0x00)
    }

    If (LEqual (NADL, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL2, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL3, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL4, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL5, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL6, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL7, Local0))
    {
    Return (0x01)
    }

    If (LEqual (NDL8, Local0))
    {
    Return (0x01)
    }

    Return (0x00)
    }

    Scope (\_GPE)
    {
    Method (_L06, 0, NotSerialized)
    {
    If (LAnd (\_SB.PCI0.GFX0.GSSE, LNot (GSMI)))
    {
    \_SB.PCI0.GFX0.GSCI ()
    }
    }
    }

    Scope (\_SB.PCI0)
    {
    OperationRegion (MCHP, PCI_Config, 0x40, 0xC0)
    Field (MCHP, AnyAcc, NoLock, Preserve)
    {
    Offset (0x60),
    TASM, 10,
    Offset (0x62)
    }
    }

    OperationRegion (IGDP, PCI_Config, 0x40, 0xC0)
    Field (IGDP, AnyAcc, NoLock, Preserve)
    {
    Offset (0x12),
    , 1,
    GIVD, 1,
    , 2,
    GUMA, 3,
    Offset (0x14),
    , 4,
    GMFN, 1,
    Offset (0x18),
    Offset (0xA4),
    ASLE, 8,
    Offset (0xA8),
    GSSE, 1,
    GSSB, 14,
    GSES, 1,
    Offset (0xB0),
    , 12,
    CDVL, 1,
    Offset (0xB2),
    Offset (0xB5),
    LBPC, 8,
    Offset (0xBC),
    ASLS, 32
    }

    OperationRegion (IGDM, SystemMemory, ASLB, 0x2000)
    Field (IGDM, AnyAcc, NoLock, Preserve)
    {
    SIGN, 128,
    SIZE, 32,
    OVER, 32,
    SVER, 256,
    VVER, 128,
    GVER, 128,
    MBOX, 32,
    DMOD, 32,
    Offset (0x100),
    DRDY, 32,
    CSTS, 32,
    CEVT, 32,
    Offset (0x120),
    DIDL, 32,
    DDL2, 32,
    DDL3, 32,
    DDL4, 32,
    DDL5, 32,
    DDL6, 32,
    DDL7, 32,
    DDL8, 32,
    CPDL, 32,
    CPL2, 32,
    CPL3, 32,
    CPL4, 32,
    CPL5, 32,
    CPL6, 32,
    CPL7, 32,
    CPL8, 32,
    CADL, 32,
    CAL2, 32,
    CAL3, 32,
    CAL4, 32,
    CAL5, 32,
    CAL6, 32,
    CAL7, 32,
    CAL8, 32,
    NADL, 32,
    NDL2, 32,
    NDL3, 32,
    NDL4, 32,
    NDL5, 32,
    NDL6, 32,
    NDL7, 32,
    NDL8, 32,
    ASLP, 32,
    TIDX, 32,
    CHPD, 32,
    CLID, 32,
    CDCK, 32,
    SXSW, 32,
    EVTS, 32,
    CNOT, 32,
    NRDY, 32,
    Offset (0x200),
    SCIE, 1,
    GEFC, 4,
    GXFC, 3,
    GESF, 8,
    Offset (0x204),
    PARM, 32,
    DSLP, 32,
    Offset (0x300),
    ARDY, 32,
    ASLC, 32,
    TCHE, 32,
    ALSI, 32,
    BCLP, 32,
    PFIT, 32,
    CBLV, 32,
    BCLM, 320,
    CPFM, 32,
    EPFM, 32,
    PLUT, 592,
    PFMB, 32,
    CCDV, 32,
    PCFT, 32,
    Offset (0x400),
    GVD1, 49152,
    PHED, 32,
    BDDC, 2048
    }

    Name (DBTB, Package (0x15)
    {
    0x00,
    0x07,
    0x38,
    0x01C0,
    0x0E00,
    0x3F,
    0x01C7,
    0x0E07,
    0x01F8,
    0x0E38,
    0x0FC0,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x7000,
    0x7007,
    0x7038,
    0x71C0,
    0x7E00
    })
    Name (CDCT, Package (0x05)
    {
    Package (0x02)
    {
    0xE4,
    0x0140
    },

    Package (0x02)
    {
    0xDE,
    0x014D
    },

    Package (0x02)
    {
    0xDE,
    0x014D
    },

    Package (0x02)
    {
    0x00,
    0x00
    },

    Package (0x02)
    {
    0xDE,
    0x014D
    }
    })
    Name (SUCC, 0x01)
    Name (NVLD, 0x02)
    Name (CRIT, 0x04)
    Name (NCRT, 0x06)
    Method (GSCI, 0, Serialized)
    {
    Method (GBDA, 0, Serialized)
    {
    If (LEqual (GESF, 0x00))
    {
    Store (0x0679, PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x01))
    {
    Store (0x0240, PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x04))
    {
    And (PARM, 0xEFFF0000, PARM)
    And (PARM, ShiftLeft (DerefOf (Index (DBTB, IBTT)), 0x10),
    PARM)
    Or (IBTT, PARM, PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x05))
    {
    Store (IPSC, PARM)
    Or (PARM, ShiftLeft (IPAT, 0x08), PARM)
    Add (PARM, 0x0100, PARM)
    Or (PARM, ShiftLeft (LIDS, 0x10), PARM)
    Add (PARM, 0x00010000, PARM)
    Or (PARM, ShiftLeft (IBIA, 0x14), PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x06))
    {
    Store (ITVF, PARM)
    Or (PARM, ShiftLeft (ITVM, 0x04), PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x07))
    {
    Store (GIVD, PARM)
    XOr (PARM, 0x01, PARM)
    Or (PARM, ShiftLeft (GMFN, 0x01), PARM)
    Or (PARM, ShiftLeft (0x03, 0x0B), PARM)
    Or (PARM, ShiftLeft (IDMS, 0x11), PARM)
    Or (ShiftLeft (DerefOf (Index (DerefOf (Index (CDCT, HVCO)), CDVL
    )), 0x15), PARM, PARM)
    Store (0x01, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x0A))
    {
    Store (0x00, PARM)
    If (ISSC)
    {
    Or (PARM, 0x03, PARM)
    }

    Store (0x00, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x0B))
    {
    Store (KSV0, PARM)
    Store (KSV1, GESF)
    Return (SUCC)
    }

    Store (Zero, GESF)
    Return (CRIT)
    }

    Method (SBCB, 0, Serialized)
    {
    If (LEqual (GESF, 0x00))
    {
    Store (0x00, PARM)
    Store (0x000F87FD, PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x01))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x03))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x04))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x05))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x06))
    {
    Store (And (PARM, 0x0F), ITVF)
    Store (ShiftRight (And (PARM, 0xF0), 0x04), ITVM)
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x07))
    {
    If (LEqual (PARM, 0x00))
    {
    Store (CLID, Local0)
    If (And (0x80000000, Local0))
    {
    And (CLID, 0x0F, CLID)
    GLID (CLID)
    }
    }

    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x08))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x09))
    {
    And (PARM, 0xFF, IBTT)
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x0A))
    {
    And (PARM, 0xFF, IPSC)
    If (And (ShiftRight (PARM, 0x08), 0xFF))
    {
    And (ShiftRight (PARM, 0x08), 0xFF, IPAT)
    Decrement (IPAT)
    }

    And (ShiftRight (PARM, 0x14), 0x07, IBIA)
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x0B))
    {
    And (ShiftRight (PARM, 0x01), 0x01, IF1E)
    If (And (PARM, ShiftLeft (0x0F, 0x0D)))
    {
    And (ShiftRight (PARM, 0x0D), 0x0F, IDMS)
    }
    Else
    {
    And (ShiftRight (PARM, 0x11), 0x0F, IDMS)
    }

    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x10))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x11))
    {
    Store (ShiftLeft (LIDS, 0x08), PARM)
    Add (PARM, 0x0100, PARM)
    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x12))
    {
    If (And (PARM, 0x01))
    {
    If (LEqual (ShiftRight (PARM, 0x01), 0x01))
    {
    Store (0x01, ISSC)
    }
    Else
    {
    Store (Zero, GESF)
    Return (CRIT)
    }
    }
    Else
    {
    Store (0x00, ISSC)
    }

    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x13))
    {
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    If (LEqual (GESF, 0x14))
    {
    And (PARM, 0x0F, PAVP)
    Store (Zero, GESF)
    Store (Zero, PARM)
    Return (SUCC)
    }

    Store (Zero, GESF)
    Return (SUCC)
    }

    If (LEqual (GEFC, 0x04))
    {
    Store (GBDA (), GXFC)
    }

    If (LEqual (GEFC, 0x06))
    {
    Store (SBCB (), GXFC)
    }

    Store (0x00, GEFC)
    Store (0x01, SCIS)
    Store (0x00, GSSE)
    Store (0x00, SCIE)
    Return (Zero)
    }

    Method (PDRD, 0, NotSerialized)
    {
    If (LNot (DRDY))
    {
    Sleep (ASLP)
    }

    Return (LNot (DRDY))
    }

    Method (PSTS, 0, NotSerialized)
    {
    If (LGreater (CSTS, 0x02))
    {
    Sleep (ASLP)
    }

    Return (LEqual (CSTS, 0x03))
    }

    Method (GNOT, 2, NotSerialized)
    {
    If (PDRD ())
    {
    Return (0x01)
    }

    Store (Arg0, CEVT)
    Store (0x03, CSTS)
    If (LAnd (LEqual (CHPD, 0x00), LEqual (Arg1, 0x00)))
    {
    If (LOr (LGreater (OSYS, 0x07D0), LLess (OSYS, 0x07D6)))
    {
    Notify (\_SB.PCI0, Arg1)
    }
    Else
    {
    Notify (\_SB.PCI0.GFX0, Arg1)
    }
    }

    If (CondRefOf (HNOT))
    {
    HNOT (Arg0)
    }
    Else
    {
    Notify (\_SB.PCI0.GFX0, 0x80)
    }

    Return (0x00)
    }

    Method (GHDS, 1, NotSerialized)
    {
    Store (Arg0, TIDX)
    Return (GNOT (0x01, 0x00))
    }

    Method (GLID, 1, NotSerialized)
    {
    If (LEqual (Arg0, 0x01))
    {
    Store (0x03, CLID)
    }
    Else
    {
    Store (Arg0, CLID)
    }

    Return (GNOT (0x02, 0x00))
    }

    Method (GDCK, 1, NotSerialized)
    {
    Store (Arg0, CDCK)
    Return (GNOT (0x04, 0x00))
    }

    Method (PARD, 0, NotSerialized)
    {
    If (LNot (ARDY))
    {
    Sleep (ASLP)
    }

    Return (LNot (ARDY))
    }

    Method (AINT, 2, NotSerialized)
    {
    If (LNot (And (TCHE, ShiftLeft (0x01, Arg0))))
    {
    Return (0x01)
    }

    If (PARD ())
    {
    Return (0x01)
    }

    If (LEqual (Arg0, 0x02))
    {
    If (CPFM)
    {
    And (CPFM, 0x0F, Local0)
    And (EPFM, 0x0F, Local1)
    If (LEqual (Local0, 0x01))
    {
    If (And (Local1, 0x06))
    {
    Store (0x06, PFIT)
    }
    Else
    {
    If (And (Local1, 0x08))
    {
    Store (0x08, PFIT)
    }
    Else
    {
    Store (0x01, PFIT)
    }
    }
    }

    If (LEqual (Local0, 0x06))
    {
    If (And (Local1, 0x08))
    {
    Store (0x08, PFIT)
    }
    Else
    {
    If (And (Local1, 0x01))
    {
    Store (0x01, PFIT)
    }
    Else
    {
    Store (0x06, PFIT)
    }
    }
    }

    If (LEqual (Local0, 0x08))
    {
    If (And (Local1, 0x01))
    {
    Store (0x01, PFIT)
    }
    Else
    {
    If (And (Local1, 0x06))
    {
    Store (0x06, PFIT)
    }
    Else
    {
    Store (0x08, PFIT)
    }
    }
    }
    }
    Else
    {
    XOr (PFIT, 0x07, PFIT)
    }

    Or (PFIT, 0x80000000, PFIT)
    Store (0x04, ASLC)
    }
    Else
    {
    If (LEqual (Arg0, 0x01))
    {
    And (BCLP, 0xFFFF0000, BCLP)
    If (LEqual (And (BCLP, 0x30000000), 0x30000000))
    {
    Or (Multiply (Arg1, 0x64), BCLP, BCLP)
    }
    Else
    {
    If (LEqual (And (BCLP, 0x30000000), 0x20000000))
    {
    Or (Multiply (Arg1, 0x0A), BCLP, BCLP)
    }
    Else
    {
    If (LEqual (And (BCLP, 0x30000000), 0x10000000))
    {
    Or (Arg1, BCLP, BCLP)
    }
    Else
    {
    Or (Divide (Multiply (Arg1, 0xFF), 0x64, ), BCLP,
    BCLP)
    }
    }
    }

    Or (BCLP, 0x80000000, BCLP)
    Store (0x02, ASLC)
    }
    Else
    {
    If (LEqual (Arg0, 0x00))
    {
    Store (Arg1, ALSI)
    Store (0x01, ASLC)
    }
    Else
    {
    Return (0x01)
    }
    }
    }

    Store (0x01, ASLE)
    Return (0x00)
    }

    Method (SCIP, 0, NotSerialized)
    {
    If (LNotEqual (OVER, 0x00))
    {
    Return (LNot (GSMI))
    }

    Return (0x00)
    }

    Device (\_SB.MEM2)
    {
    Name (_HID, EisaId ("PNP0C01"))
    Name (_UID, 0x02)
    Name (CRS, ResourceTemplate ()
    {
    Memory32Fixed (ReadWrite,
    0x20000000, // Address Base
    0x00200000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x40000000, // Address Base
    0x00200000, // Address Length
    )
    })
    Method (_CRS, 0, NotSerialized)
    {
    If (IGDS)
    {
    Return (CRS)
    }
    }
    }
    }

    Device (LPCB)
    {
    Name (_ADR, 0x001F0000)
    Scope (\_SB)
    {
    OperationRegion (\_SB.PCI0.LPCB.LPC1, PCI_Config, 0x40, 0xC0)
    Field (\_SB.PCI0.LPCB.LPC1, AnyAcc, NoLock, Preserve)
    {
    Offset (0x20),
    PARC, 8,
    PBRC, 8,
    PCRC, 8,
    PDRC, 8,
    Offset (0x28),
    PERC, 8,
    PFRC, 8,
    PGRC, 8,
    PHRC, 8
    }

    Device (LNKA)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x01)
    Method (_DIS, 0, Serialized)
    {
    Or (PARC, 0x80, PARC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,10,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLA, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLA, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PARC, 0x0F), IRQ0)
    Return (RTLA)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PARC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PARC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKB)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x02)
    Method (_DIS, 0, Serialized)
    {
    Or (PBRC, 0x80, PBRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,11,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLB, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLB, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PBRC, 0x0F), IRQ0)
    Return (RTLB)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PBRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PBRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKC)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x03)
    Method (_DIS, 0, Serialized)
    {
    Or (PCRC, 0x80, PCRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,10,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLC, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLC, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PCRC, 0x0F), IRQ0)
    Return (RTLC)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PCRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PCRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKD)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x04)
    Method (_DIS, 0, Serialized)
    {
    Or (PDRC, 0x80, PDRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,11,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLD, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLD, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PDRC, 0x0F), IRQ0)
    Return (RTLD)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PDRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PDRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKE)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x05)
    Method (_DIS, 0, Serialized)
    {
    Or (PERC, 0x80, PERC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,10,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLE, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLE, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PERC, 0x0F), IRQ0)
    Return (RTLE)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PERC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PERC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKF)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x06)
    Method (_DIS, 0, Serialized)
    {
    Or (PFRC, 0x80, PFRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,11,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLF, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLF, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PFRC, 0x0F), IRQ0)
    Return (RTLF)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PFRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PFRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKG)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x07)
    Method (_DIS, 0, Serialized)
    {
    Or (PGRC, 0x80, PGRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,10,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLG, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLG, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PGRC, 0x0F), IRQ0)
    Return (RTLG)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PGRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PGRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }

    Device (LNKH)
    {
    Name (_HID, EisaId ("PNP0C0F"))
    Name (_UID, 0x08)
    Method (_DIS, 0, Serialized)
    {
    Or (PHRC, 0x80, PHRC)
    }

    Name (_PRS, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {1,3,4,5,6,7,11,12,14,15}
    })
    Method (_CRS, 0, Serialized)
    {
    Name (RTLH, ResourceTemplate ()
    {
    IRQ (Level, ActiveLow, Shared, )
    {}
    })
    CreateWordField (RTLH, 0x01, IRQ0)
    Store (Zero, IRQ0)
    ShiftLeft (0x01, And (PHRC, 0x0F), IRQ0)
    Return (RTLH)
    }

    Method (_SRS, 1, Serialized)
    {
    CreateWordField (Arg0, 0x01, IRQ0)
    FindSetRightBit (IRQ0, Local0)
    Decrement (Local0)
    Store (Local0, PHRC)
    }

    Method (_STA, 0, Serialized)
    {
    If (And (PHRC, 0x80))
    {
    Return (0x09)
    }
    Else
    {
    Return (0x0B)
    }
    }
    }
    }

    OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
    Field (LPC0, AnyAcc, NoLock, Preserve)
    {
    Offset (0x40),
    IOD0, 8,
    IOD1, 8,
    Offset (0xB0),
    RAEN, 1,
    , 13,
    RCBA, 18
    }

    Device (DMAC)
    {
    Name (_HID, EisaId ("PNP0200"))
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x0000, // Range Minimum
    0x0000, // Range Maximum
    0x01, // Alignment
    0x20, // Length
    )
    IO (Decode16,
    0x0081, // Range Minimum
    0x0081, // Range Maximum
    0x01, // Alignment
    0x11, // Length
    )
    IO (Decode16,
    0x0093, // Range Minimum
    0x0093, // Range Maximum
    0x01, // Alignment
    0x0D, // Length
    )
    IO (Decode16,
    0x00C0, // Range Minimum
    0x00C0, // Range Maximum
    0x01, // Alignment
    0x20, // Length
    )
    DMA (Compatibility, NotBusMaster, Transfer8_16, )
    {4}
    })
    }

    Device (FWHD)
    {
    Name (_HID, EisaId ("INT0800"))
    Name (_CRS, ResourceTemplate ()
    {
    Memory32Fixed (ReadOnly,
    0xFF000000, // Address Base
    0x01000000, // Address Length
    )
    })
    }

    Device (HPET)
    {
    Name (_HID, EisaId ("PNP0103"))
    Name (_UID, 0x00)
    Name (BUF0, ResourceTemplate ()
    {
    Memory32Fixed (ReadWrite,
    0xFED00000, // Address Base
    0x00000400, // Address Length
    )
    })
    Method (_STA, 0, NotSerialized)
    {
    If (LGreaterEqual (OSYS, 0x07D1))
    {
    If (HPAE)
    {
    Return (0x0F)
    }
    }
    Else
    {
    If (HPAE)
    {
    Return (0x0B)
    }
    }

    Return (0x00)
    }

    Method (_CRS, 0, Serialized)
    {
    If (HPAE)
    {
    CreateDWordField (BUF0, 0x04, HPT0)
    If (LEqual (HPAS, 0x01))
    {
    Store (0xFED01000, HPT0)
    }

    If (LEqual (HPAS, 0x02))
    {
    Store (0xFED02000, HPT0)
    }

    If (LEqual (HPAS, 0x03))
    {
    Store (0xFED03000, HPT0)
    }
    }

    Return (BUF0)
    }
    }

    Device (IPIC)
    {
    Name (_HID, EisaId ("PNP0000"))
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x0020, // Range Minimum
    0x0020, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0024, // Range Minimum
    0x0024, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0028, // Range Minimum
    0x0028, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x002C, // Range Minimum
    0x002C, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0030, // Range Minimum
    0x0030, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0034, // Range Minimum
    0x0034, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0038, // Range Minimum
    0x0038, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x003C, // Range Minimum
    0x003C, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00A0, // Range Minimum
    0x00A0, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00A4, // Range Minimum
    0x00A4, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00A8, // Range Minimum
    0x00A8, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00AC, // Range Minimum
    0x00AC, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00B0, // Range Minimum
    0x00B0, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00B4, // Range Minimum
    0x00B4, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00B8, // Range Minimum
    0x00B8, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x00BC, // Range Minimum
    0x00BC, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x04D0, // Range Minimum
    0x04D0, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IRQNoFlags ()
    {2}
    })
    }

    Device (MATH)
    {
    Name (_HID, EisaId ("PNP0C04"))
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x00F0, // Range Minimum
    0x00F0, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IRQNoFlags ()
    {13}
    })
    }

    Device (LDRC)
    {
    Name (_HID, EisaId ("PNP0C02"))
    Name (_UID, 0x02)
    Name (BUF0, ResourceTemplate ()
    {
    IO (Decode16,
    0x002E, // Range Minimum
    0x002E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x004E, // Range Minimum
    0x004E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0061, // Range Minimum
    0x0061, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0063, // Range Minimum
    0x0063, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0065, // Range Minimum
    0x0065, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0067, // Range Minimum
    0x0067, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0070, // Range Minimum
    0x0070, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0080, // Range Minimum
    0x0080, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0092, // Range Minimum
    0x0092, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x00B2, // Range Minimum
    0x00B2, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0680, // Range Minimum
    0x0680, // Range Maximum
    0x01, // Alignment
    0x20, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0400, // Range Minimum
    0x0400, // Range Maximum
    0x01, // Alignment
    0x80, // Length
    )
    IO (Decode16,
    0x0500, // Range Minimum
    0x0500, // Range Maximum
    0x01, // Alignment
    0x80, // Length
    )
    IO (Decode16,
    0x164E, // Range Minimum
    0x164E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    })
    Name (BUF1, ResourceTemplate ()
    {
    IO (Decode16,
    0x002E, // Range Minimum
    0x002E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x004E, // Range Minimum
    0x004E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0061, // Range Minimum
    0x0061, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0063, // Range Minimum
    0x0063, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0065, // Range Minimum
    0x0065, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0067, // Range Minimum
    0x0067, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0070, // Range Minimum
    0x0070, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0080, // Range Minimum
    0x0080, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0092, // Range Minimum
    0x0092, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x00B2, // Range Minimum
    0x00B2, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    IO (Decode16,
    0x0680, // Range Minimum
    0x0680, // Range Maximum
    0x01, // Alignment
    0x20, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0xFFFF, // Range Minimum
    0xFFFF, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0400, // Range Minimum
    0x0400, // Range Maximum
    0x01, // Alignment
    0x54, // Length
    )
    IO (Decode16,
    0x0458, // Range Minimum
    0x0458, // Range Maximum
    0x01, // Alignment
    0x28, // Length
    )
    IO (Decode16,
    0x0500, // Range Minimum
    0x0500, // Range Maximum
    0x01, // Alignment
    0x80, // Length
    )
    IO (Decode16,
    0x164E, // Range Minimum
    0x164E, // Range Maximum
    0x01, // Alignment
    0x02, // Length
    )
    })
    Method (_CRS, 0, Serialized)
    {
    If (LEqual (WDTE, 0x01))
    {
    Return (BUF1)
    }
    Else
    {
    Return (BUF0)
    }
    }
    }

    Device (RTC)
    {
    Name (_HID, EisaId ("PNP0B00"))
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x0070, // Range Minimum
    0x0070, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {8}
    })
    }

    Device (TIMR)
    {
    Name (_HID, EisaId ("PNP0100"))
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x0040, // Range Minimum
    0x0040, // Range Maximum
    0x01, // Alignment
    0x04, // Length
    )
    IO (Decode16,
    0x0050, // Range Minimum
    0x0050, // Range Maximum
    0x10, // Alignment
    0x04, // Length
    )
    IRQNoFlags ()
    {0}
    })
    }

    Device (CWDT)
    {
    Name (_HID, EisaId ("INT3F0D"))
    Name (_CID, EisaId ("PNP0C02"))
    Name (BUF0, ResourceTemplate ()
    {
    IO (Decode16,
    0x0454, // Range Minimum
    0x0454, // Range Maximum
    0x04, // Alignment
    0x04, // Length
    )
    })
    Method (_STA, 0, Serialized)
    {
    If (LEqual (WDTE, 0x01))
    {
    Return (0x0F)
    }
    Else
    {
    Return (0x00)
    }
    }

    Method (_CRS, 0, Serialized)
    {
    Return (BUF0)
    }
    }

    Device (PS2K)
    {
    Name (_HID, EisaId ("PNP0303"))
    Method (_STA, 0, NotSerialized)
    {
    If (And (\IOST, 0x0400))
    {
    Return (0x0F)
    }
    Else
    {
    Return (0x00)
    }
    }

    Name (_PRW, Package (0x02)
    {
    0x08,
    0x03
    })
    Name (_CRS, ResourceTemplate ()
    {
    IO (Decode16,
    0x0060, // Range Minimum
    0x0060, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0064, // Range Minimum
    0x0064, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IRQ (Edge, ActiveHigh, Exclusive, )
    {1}
    })
    Name (_PRS, ResourceTemplate ()
    {
    StartDependentFn (0x00, 0x00)
    {
    FixedIO (
    0x0060, // Address
    0x01, // Length
    )
    FixedIO (
    0x0064, // Address
    0x01, // Length
    )
    IRQNoFlags ()
    {1}
    }
    EndDependentFn ()
    })
    }
    }

    Device (EHC1)
    {
    Name (_ADR, 0x001D0000)
    OperationRegion (PWKE, PCI_Config, 0x62, 0x04)
    Field (PWKE, DWordAcc, NoLock, Preserve)
    {
    , 1,
    PWUC, 8
    }

    Method (_PSW, 1, NotSerialized)
    {
    If (Arg0)
    {
    Store (Ones, PWUC)
    }
    Else
    {
    Store (0x00, PWUC)
    }
    }

    Method (_S3D, 0, NotSerialized)
    {
    Return (0x02)
    }

    Method (_S4D, 0, NotSerialized)
    {
    Return (0x02)
    }

    Device (HUBN)
    {
    Name (_ADR, Zero)
    Device (PR01)
    {
    Name (_ADR, One)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0x00,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    Device (PR11)
    {
    Name (_ADR, One)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR12)
    {
    Name (_ADR, 0x02)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR13)
    {
    Name (_ADR, 0x03)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR14)
    {
    Name (_ADR, 0x04)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR15)
    {
    Name (_ADR, 0x05)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR16)
    {
    Name (_ADR, 0x06)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR17)
    {
    Name (_ADR, 0x07)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }

    Device (PR18)
    {
    Name (_ADR, 0x08)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    })
    }
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x0D, 0x03))
    }
    }

    Device (EHC2)
    {
    Name (_ADR, 0x001A0000)
    OperationRegion (PWKE, PCI_Config, 0x62, 0x04)
    Field (PWKE, DWordAcc, NoLock, Preserve)
    {
    , 1,
    PWUC, 6
    }

    Method (_PSW, 1, NotSerialized)
    {
    If (Arg0)
    {
    Store (Ones, PWUC)
    }
    Else
    {
    Store (0x00, PWUC)
    }
    }

    Method (_S3D, 0, NotSerialized)
    {
    Return (0x02)
    }

    Method (_S4D, 0, NotSerialized)
    {
    Return (0x02)
    }

    Device (HUBN)
    {
    Name (_ADR, Zero)
    Device (PR01)
    {
    Name (_ADR, One)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0x00,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    Device (PR11)
    {
    Name (_ADR, One)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    }

    Device (PR12)
    {
    Name (_ADR, 0x02)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    Alias (SBV1, SDGV)
    Method (_DSM, 4, Serialized)
    {
    Name (_T_0, Zero)
    If (LEqual (Arg0, Buffer (0x10)
    {
    /* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,
    /* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8
    }))
    {
    Store (ToInteger (Arg2), _T_0)
    If (LEqual (_T_0, 0x00))
    {
    If (LEqual (Arg1, 0x01))
    {
    Return (Buffer (0x01)
    {
    0x07
    })
    }
    Else
    {
    Return (Buffer (0x01)
    {
    0x00
    })
    }
    }
    Else
    {
    If (LEqual (_T_0, 0x01))
    {
    If (LEqual (SDGV, 0xFF))
    {
    Return (0x00)
    }
    Else
    {
    Return (0x01)
    }
    }
    Else
    {
    If (LEqual (_T_0, 0x02))
    {
    Return (SDGV)
    }
    }
    }
    }

    Return (0x00)
    }
    }

    Device (PR13)
    {
    Name (_ADR, 0x03)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    Alias (SBV2, SDGV)
    Method (_DSM, 4, Serialized)
    {
    Name (_T_0, Zero)
    If (LEqual (Arg0, Buffer (0x10)
    {
    /* 0000 */ 0x8F, 0x70, 0xFC, 0xA5, 0x75, 0x87, 0xA6, 0x4B,
    /* 0008 */ 0xBD, 0x0C, 0xBA, 0x90, 0xA1, 0xEC, 0x72, 0xF8
    }))
    {
    Store (ToInteger (Arg2), _T_0)
    If (LEqual (_T_0, 0x00))
    {
    If (LEqual (Arg1, 0x01))
    {
    Return (Buffer (0x01)
    {
    0x07
    })
    }
    Else
    {
    Return (Buffer (0x01)
    {
    0x00
    })
    }
    }
    Else
    {
    If (LEqual (_T_0, 0x01))
    {
    If (LEqual (SDGV, 0xFF))
    {
    Return (0x00)
    }
    Else
    {
    Return (0x01)
    }
    }
    Else
    {
    If (LEqual (_T_0, 0x02))
    {
    Return (SDGV)
    }
    }
    }
    }

    Return (0x00)
    }
    }

    Device (PR14)
    {
    Name (_ADR, 0x04)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xE1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    }

    Device (PR15)
    {
    Name (_ADR, 0x05)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    }

    Device (PR16)
    {
    Name (_ADR, 0x06)
    Name (_UPC, Package (0x04)
    {
    0xFF,
    0xFF,
    0x00,
    0x00
    })
    Name (_PLD, Package (0x01)
    {
    Buffer (0x10)
    {
    /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    /* 0008 */ 0xB1, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }
    })
    }
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x0D, 0x03))
    }
    }

    Device (HDEF)
    {
    Name (_ADR, 0x001B0000)
    OperationRegion (HDAR, PCI_Config, 0x4C, 0x10)
    Field (HDAR, WordAcc, NoLock, Preserve)
    {
    DCKA, 1,
    Offset (0x01),
    DCKM, 1,
    , 6,
    DCKS, 1,
    Offset (0x08),
    , 15,
    PMES, 1
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x0D, 0x04))
    }
    }

    Device (GLAN)
    {
    Name (_ADR, 0x00190000)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x0D, 0x04))
    }
    }

    Device (RP01)
    {
    Name (_ADR, 0x001C0000)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR04 ())
    }

    Return (PR04 ())
    }
    }

    Device (RP02)
    {
    Name (_ADR, 0x001C0001)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR05 ())
    }

    Return (PR05 ())
    }
    }

    Device (RP03)
    {
    Name (_ADR, 0x001C0002)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR06 ())
    }

    Return (PR06 ())
    }
    }

    Device (RP04)
    {
    Name (_ADR, 0x001C0003)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR07 ())
    }

    Return (PR07 ())
    }
    }

    Device (RP05)
    {
    Name (_ADR, 0x001C0004)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR08 ())
    }

    Return (PR08 ())
    }
    }

    Device (RP06)
    {
    Name (_ADR, 0x001C0005)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR09 ())
    }

    Return (PR09 ())
    }
    }

    Device (RP07)
    {
    Name (_ADR, 0x001C0006)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR0E)
    }

    Return (PR0E)
    }
    }

    Device (RP08)
    {
    Name (_ADR, 0x001C0007)
    OperationRegion (PXCS, PCI_Config, 0x40, 0xC0)
    Field (PXCS, AnyAcc, NoLock, Preserve)
    {
    Offset (0x10),
    L0SE, 1,
    Offset (0x11),
    Offset (0x12),
    , 13,
    LASX, 1,
    Offset (0x1A),
    ABPX, 1,
    , 2,
    PDCX, 1,
    , 2,
    PDSX, 1,
    Offset (0x1B),
    Offset (0x20),
    Offset (0x22),
    PSPX, 1,
    Offset (0x98),
    , 30,
    HPEX, 1,
    PMEX, 1
    }

    Field (PXCS, AnyAcc, NoLock, WriteAsZeros)
    {
    Offset (0x9C),
    , 30,
    HPSX, 1,
    PMSX, 1
    }

    Device (PXSX)
    {
    Name (_ADR, 0x00)
    Name (_PRW, Package (0x02)
    {
    0x09,
    0x04
    })
    }

    Method (HPME, 0, Serialized)
    {
    If (PMSX)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    Store (0x01, PMSX)
    If (PMSX)
    {
    Decrement (Local0)
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Notify (PXSX, 0x02)
    }
    }

    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR0F)
    }

    Return (PR0F)
    }
    }

    Device (PEG0)
    {
    Name (_ADR, 0x00010000)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR02 ())
    }

    Return (PR02 ())
    }

    Device (PEGP)
    {
    Name (_ADR, 0xFFFF)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }
    }
    }

    Device (PEG1)
    {
    Name (_ADR, 0x00010001)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR0A ())
    }

    Return (PR0A ())
    }
    }

    Device (PEG2)
    {
    Name (_ADR, 0x00010002)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR0B ())
    }

    Return (PR0B ())
    }
    }

    Device (PEG3)
    {
    Name (_ADR, 0x00060000)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x09, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR0C)
    }

    Return (PR0C)
    }
    }

    Device (B0D4)
    {
    Name (_ADR, 0x00040000)
    }

    Device (P0P1)
    {
    Name (_ADR, 0x001E0000)
    Method (_PRW, 0, NotSerialized)
    {
    Return (GPRW (0x0B, 0x04))
    }

    Method (_PRT, 0, NotSerialized)
    {
    If (PICM)
    {
    Return (AR01 ())
    }

    Return (PR01 ())
    }
    }
    }

    Scope (\_GPE)
    {
    Method (_L0D, 0, NotSerialized)
    {
    Notify (\_SB.PCI0.EHC1, 0x02)
    Notify (\_SB.PCI0.EHC2, 0x02)
    Notify (\_SB.PCI0.HDEF, 0x02)
    Notify (\_SB.PCI0.GLAN, 0x02)
    Notify (\_SB.PWRB, 0x02)
    }

    Method (_L09, 0, NotSerialized)
    {
    Notify (\_SB.PCI0.RP01, 0x02)
    Notify (\_SB.PCI0.RP02, 0x02)
    Notify (\_SB.PCI0.RP03, 0x02)
    Notify (\_SB.PCI0.RP04, 0x02)
    Notify (\_SB.PCI0.RP05, 0x02)
    Notify (\_SB.PCI0.RP06, 0x02)
    Notify (\_SB.PCI0.RP07, 0x02)
    Notify (\_SB.PCI0.RP08, 0x02)
    Notify (\_SB.PCI0.PEG0, 0x02)
    Notify (\_SB.PCI0.PEG0.PEGP, 0x02)
    Notify (\_SB.PCI0.PEG1, 0x02)
    Notify (\_SB.PCI0.PEG2, 0x02)
    Notify (\_SB.PCI0.PEG3, 0x02)
    }

    Method (_L0B, 0, NotSerialized)
    {
    Notify (\_SB.PCI0.P0P1, 0x02)
    Notify (\_SB.PWRB, 0x02)
    }
    }

    Device (PWRB)
    {
    Name (_HID, EisaId ("PNP0C0C"))
    Name (_UID, 0xAA)
    Name (_STA, 0x0B)
    }
    }

    Scope (\_PR)
    {
    Method (PPCE, 2, NotSerialized)
    {
    Store (GENS (0x15, 0x00, 0x00), Local0)
    Store (Local0, \_PR.CPU0._PPC)
    Notify (CPU0, 0x80)
    Sleep (0x64)
    If (LGreaterEqual (TCNT, 0x02))
    {
    Notify (CPU1, 0x80)
    Sleep (0x64)
    If (LGreaterEqual (TCNT, 0x04))
    {
    Notify (CPU2, 0x80)
    Sleep (0x64)
    Notify (CPU3, 0x80)
    Sleep (0x64)
    If (LGreaterEqual (TCNT, 0x08))
    {
    Notify (CPU4, 0x80)
    Sleep (0x64)
    Notify (CPU5, 0x80)
    Sleep (0x64)
    Notify (CPU6, 0x80)
    Sleep (0x64)
    Notify (CPU7, 0x80)
    Sleep (0x64)
    }
    }
    }
    }
    }

    Scope (\_PR)
    {
    Processor (CPU0, 0x01, 0x00000410, 0x06) {}
    Processor (CPU1, 0x02, 0x00000410, 0x06) {}
    Processor (CPU2, 0x03, 0x00000410, 0x06) {}
    Processor (CPU3, 0x04, 0x00000410, 0x06) {}
    Processor (CPU4, 0x05, 0x00000410, 0x06) {}
    Processor (CPU5, 0x06, 0x00000410, 0x06) {}
    Processor (CPU6, 0x07, 0x00000410, 0x06) {}
    Processor (CPU7, 0x08, 0x00000410, 0x06) {}
    }

    Mutex (MUTX, 0x00)
    OperationRegion (PRT0, SystemIO, 0x80, 0x04)
    Field (PRT0, DWordAcc, Lock, Preserve)
    {
    P80H, 32
    }

    Method (P8XH, 2, Serialized)
    {
    If (LEqual (Arg0, 0x00))
    {
    Store (Or (And (P80D, 0xFFFFFF00), Arg1), P80D)
    }

    If (LEqual (Arg0, 0x01))
    {
    Store (Or (And (P80D, 0xFFFF00FF), ShiftLeft (Arg1, 0x08)
    ), P80D)
    }

    If (LEqual (Arg0, 0x02))
    {
    Store (Or (And (P80D, 0xFF00FFFF), ShiftLeft (Arg1, 0x10)
    ), P80D)
    }

    If (LEqual (Arg0, 0x03))
    {
    Store (Or (And (P80D, 0x00FFFFFF), ShiftLeft (Arg1, 0x18)
    ), P80D)
    }

    Store (P80D, P80H)
    }

    OperationRegion (SPRT, SystemIO, 0xB2, 0x02)
    Field (SPRT, ByteAcc, Lock, Preserve)
    {
    SSMP, 8
    }

    Method (\_PIC, 1, NotSerialized)
    {
    Store (Arg0, GPIC)
    Store (Arg0, PICM)
    }

    Method (GETB, 3, Serialized)
    {
    Multiply (Arg0, 0x08, Local0)
    Multiply (Arg1, 0x08, Local1)
    CreateField (Arg2, Local0, Local1, TBF3)
    Return (TBF3)
    }

    Method (TRAP, 2, Serialized)
    {
    Return (0x00)
    }

    Scope (\_SB.PCI0)
    {
    Method (IINI, 2, NotSerialized)
    {
    If (LNotEqual (Arg0, 0x02))
    {
    Return (Zero)
    }

    Store (0x07D0, OSYS)
    If (CondRefOf (\_OSI, Local0))
    {
    If (\_OSI ("Linux"))
    {
    Store (0x03E8, OSYS)
    }

    If (\_OSI ("Windows 2001"))
    {
    Store (0x07D1, OSYS)
    }

    If (\_OSI ("Windows 2001 SP1"))
    {
    Store (0x07D1, OSYS)
    }

    If (\_OSI ("Windows 2001 SP2"))
    {
    Store (0x07D2, OSYS)
    }

    If (\_OSI ("Windows 2006"))
    {
    Store (0x07D6, OSYS)
    }

    If (\_OSI ("Windows 2009"))
    {
    Store (0x07D9, OSYS)
    }
    }

    Return (Zero)
    }

    Method (NHPG, 0, Serialized)
    {
    Store (0x00, ^RP01.HPEX)
    Store (0x00, ^RP02.HPEX)
    Store (0x00, ^RP03.HPEX)
    Store (0x00, ^RP04.HPEX)
    Store (0x01, ^RP01.HPSX)
    Store (0x01, ^RP02.HPSX)
    Store (0x01, ^RP03.HPSX)
    Store (0x01, ^RP04.HPSX)
    }

    Method (NPME, 0, Serialized)
    {
    Store (0x00, ^RP01.PMEX)
    Store (0x00, ^RP02.PMEX)
    Store (0x00, ^RP03.PMEX)
    Store (0x00, ^RP04.PMEX)
    Store (0x00, ^RP05.PMEX)
    Store (0x00, ^RP07.PMEX)
    Store (0x00, ^RP08.PMEX)
    Store (0x01, ^RP01.PMSX)
    Store (0x01, ^RP02.PMSX)
    Store (0x01, ^RP03.PMSX)
    Store (0x01, ^RP04.PMSX)
    Store (0x01, ^RP05.PMSX)
    Store (0x01, ^RP07.PMSX)
    Store (0x01, ^RP08.PMSX)
    }
    }

    Scope (\)
    {
    Name (PICM, 0x00)
    Name (PRWP, Package (0x02)
    {
    Zero,
    Zero
    })
    Method (GPRW, 2, NotSerialized)
    {
    Store (Arg0, Index (PRWP, 0x00))
    Store (Arg1, Index (PRWP, 0x01))
    Return (PRWP)
    }
    }

    Scope (\_SB.PCI0)
    {
    Device (PDRC)
    {
    Name (_HID, EisaId ("PNP0C02"))
    Name (_UID, 0x01)
    Name (BUF0, ResourceTemplate ()
    {
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00004000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00008000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00001000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00001000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00000000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0xFED20000, // Address Base
    0x00020000, // Address Length
    )
    Memory32Fixed (ReadOnly,
    0xFED90000, // Address Base
    0x00004000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0xFED45000, // Address Base
    0x0004B000, // Address Length
    )
    Memory32Fixed (ReadOnly,
    0xFF000000, // Address Base
    0x01000000, // Address Length
    )
    Memory32Fixed (ReadOnly,
    0xFEE00000, // Address Base
    0x00100000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00001000, // Address Length
    )
    Memory32Fixed (ReadWrite,
    0x00000000, // Address Base
    0x00000000, // Address Length
    )
    })
    Method (_CRS, 0, Serialized)
    {
    CreateDWordField (BUF0, 0x04, RBR0)
    ShiftLeft (\_SB.PCI0.LPCB.RCBA, 0x0E, RBR0)
    CreateDWordField (BUF0, 0x7C, TBR0)
    Store (TBAB, TBR0)
    CreateDWordField (BUF0, 0x80, TBLN)
    If (LEqual (TBAB, 0x00))
    {
    Store (0x00, TBLN)
    }

    If (CondRefOf (DPTR))
    {
    CreateDWordField (BUF0, 0x88, ABR0)
    Store (DPTR, ABR0)
    CreateDWordField (BUF0, 0x8C, ABLN)
    Subtract (EPTR, DPTR, ABLN)
    }

    CreateDWordField (BUF0, 0x10, MBR0)
    ShiftLeft (\_SB.PCI0.MHBR, 0x0F, MBR0)
    CreateDWordField (BUF0, 0x1C, DBR0)
    ShiftLeft (\_SB.PCI0.DIBR, 0x0C, DBR0)
    CreateDWordField (BUF0, 0x28, EBR0)
    ShiftLeft (\_SB.PCI0.EPBR, 0x0C, EBR0)
    CreateDWordField (BUF0, 0x34, XBR0)
    ShiftLeft (\_SB.PCI0.PXBR, 0x1A, XBR0)
    CreateDWordField (BUF0, 0x38, XSZ0)
    ShiftRight (0x10000000, \_SB.PCI0.PXSZ, XSZ0)
    Return (BUF0)
    }
    }
    }

    Scope (\)
    {
    OperationRegion (IO_T, SystemIO, 0x1000, 0x10)
    Field (IO_T, ByteAcc, NoLock, Preserve)
    {
    TRPI, 16,
    Offset (0x04),
    Offset (0x06),
    Offset (0x08),
    TRP0, 8,
    Offset (0x0A),
    Offset (0x0B),
    Offset (0x0C),
    Offset (0x0D),
    Offset (0x0E),
    Offset (0x0F),
    Offset (0x10)
    }

    OperationRegion (IO_D, SystemIO, 0x0810, 0x04)
    Field (IO_D, ByteAcc, NoLock, Preserve)
    {
    TRPD, 8
    }

    OperationRegion (IO_H, SystemIO, 0x1000, 0x04)
    Field (IO_H, ByteAcc, NoLock, Preserve)
    {
    TRPH, 8
    }

    OperationRegion (PMIO, SystemIO, 0x0400, 0x80)
    Field (PMIO, ByteAcc, NoLock, Preserve)
    {
    Offset (0x20),
    , 2,
    SPST, 1,
    Offset (0x21),
    RIST, 1,
    , 4,
    PBST, 1,
    , 5,
    GPS3, 1,
    Offset (0x28),
    Offset (0x2A),
    , 3,
    GPE3, 1,
    Offset (0x3C),
    , 1,
    UPRW, 1,
    Offset (0x42),
    , 1,
    GPEC, 1,
    Offset (0x64),
    , 9,
    SCIS, 1,
    Offset (0x66)
    }

    OperationRegion (GPIO, SystemIO, 0x0500, 0x64)
    Field (GPIO, ByteAcc, NoLock, Preserve)
    {
    GU00, 8,
    GU01, 8,
    GU02, 8,
    GU03, 8,
    GIO0, 8,
    GIO1, 8,
    GIO2, 8,
    GIO3, 8,
    Offset (0x0C),
    GL00, 8,
    GL01, 8,
    GL02, 8,
    , 3,
    GP27, 1,
    GP28, 1,
    Offset (0x10),
    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,
    GL04, 8,
    GL05, 8,
    GL06, 8,
    GL07, 8,
    Offset (0x40),
    GU08, 8,
    GU09, 8,
    GU0A, 8,
    GU0B, 8,
    GIO8, 8,
    GIO9, 8,
    GIOA, 8,
    GIOB, 8,
    GL08, 8,
    GL09, 8,
    GL0A, 8,
    GL0B, 8
    }

    OperationRegion (RCRB, SystemMemory, \SRCB, 0x4000)
    Field (RCRB, DWordAcc, Lock, Preserve)
    {
    Offset (0x1000),
    Offset (0x3000),
    Offset (0x3404),
    HPAS, 2,
    , 5,
    HPAE, 1,
    Offset (0x3418),
    , 1,
    , 1,
    SATD, 1,
    SMBD, 1,
    HDAD, 1,
    Offset (0x341A),
    RP1D, 1,
    RP2D, 1,
    RP3D, 1,
    RP4D, 1,
    RP5D, 1,
    RP6D, 1,
    RP7D, 1,
    RP8D, 1,
    Offset (0x359C),
    UP0D, 1,
    UP1D, 1,
    UP2D, 1,
    UP3D, 1,
    UP4D, 1,
    UP5D, 1,
    UP6D, 1,
    UP7D, 1,
    UP8D, 1,
    UP9D, 1,
    UPAD, 1,
    UPBD, 1,
    UPCD, 1,
    UPDD, 1,
    , 1,
    Offset (0x359E)
    }
    }

    Scope (\_SB.PCI0)
    {
    Device (SAT0)
    {
    Name (_ADR, 0x001F0002)
    }

    Device (SAT1)
    {
    Name (_ADR, 0x001F0005)
    }

    Device (SBUS)
    {
    Name (_ADR, 0x001F0003)
    OperationRegion (SMBP, PCI_Config, 0x40, 0xC0)
    Field (SMBP, DWordAcc, NoLock, Preserve)
    {
    , 2,
    I2CE, 1
    }

    OperationRegion (SMPB, PCI_Config, 0x20, 0x04)
    Field (SMPB, DWordAcc, NoLock, Preserve)
    {
    , 5,
    SBAR, 11
    }

    OperationRegion (SMBI, SystemIO, ShiftLeft (SBAR, 0x05), 0x10)
    Field (SMBI, ByteAcc, NoLock, Preserve)
    {
    HSTS, 8,
    Offset (0x02),
    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 (0x00)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Arg0, TXSA)
    Store (Arg1, HCOM)
    Store (0x48, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (0x01)
    }

    Return (0x00)
    }

    Method (SRXB, 1, Serialized)
    {
    If (STRT ())
    {
    Return (0xFFFF)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Or (Arg0, 0x01), TXSA)
    Store (0x44, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (DAT0)
    }

    Return (0xFFFF)
    }

    Method (SWRB, 3, Serialized)
    {
    If (STRT ())
    {
    Return (0x00)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Arg0, TXSA)
    Store (Arg1, HCOM)
    Store (Arg2, DAT0)
    Store (0x48, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (0x01)
    }

    Return (0x00)
    }

    Method (SRDB, 2, Serialized)
    {
    If (STRT ())
    {
    Return (0xFFFF)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Or (Arg0, 0x01), TXSA)
    Store (Arg1, HCOM)
    Store (0x48, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (DAT0)
    }

    Return (0xFFFF)
    }

    Method (SWRW, 3, Serialized)
    {
    If (STRT ())
    {
    Return (0x00)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Arg0, TXSA)
    Store (Arg1, HCOM)
    And (Arg2, 0xFF, DAT1)
    And (ShiftRight (Arg2, 0x08), 0xFF, DAT0)
    Store (0x4C, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (0x01)
    }

    Return (0x00)
    }

    Method (SRDW, 2, Serialized)
    {
    If (STRT ())
    {
    Return (0xFFFF)
    }

    Store (0x00, I2CE)
    Store (0xBF, HSTS)
    Store (Or (Arg0, 0x01), TXSA)
    Store (Arg1, HCOM)
    Store (0x4C, HCON)
    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (Or (ShiftLeft (DAT0, 0x08), DAT1))
    }

    Return (0xFFFFFFFF)
    }

    Method (SBLW, 4, Serialized)
    {
    If (STRT ())
    {
    Return (0x00)
    }

    Store (Arg3, I2CE)
    Store (0xBF, HSTS)
    Store (Arg0, TXSA)
    Store (Arg1, HCOM)
    Store (SizeOf (Arg2), DAT0)
    Store (0x00, Local1)
    Store (DerefOf (Index (Arg2, 0x00)), 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 (0x00)
    }

    Store (0x80, HSTS)
    Increment (Local1)
    If (LGreater (SizeOf (Arg2), Local1))
    {
    Store (DerefOf (Index (Arg2, Local1)), HBDR)
    }
    }

    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (0x01)
    }

    Return (0x00)
    }

    Method (SBLR, 3, Serialized)
    {
    Name (TBUF, Buffer (0x0100) {})
    If (STRT ())
    {
    Return (0x00)
    }

    Store (Arg2, I2CE)
    Store (0xBF, HSTS)
    Store (Or (Arg0, 0x01), 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 (0x00)
    }

    Store (DAT0, Index (TBUF, 0x00))
    Store (0x80, HSTS)
    Store (0x01, Local1)
    While (LLess (Local1, DerefOf (Index (TBUF, 0x00))))
    {
    Store (0x0FA0, Local0)
    While (LAnd (LNot (And (HSTS, 0x80)), Local0))
    {
    Decrement (Local0)
    Stall (0x32)
    }

    If (LNot (Local0))
    {
    KILL ()
    Return (0x00)
    }

    Store (HBDR, Index (TBUF, Local1))
    Store (0x80, HSTS)
    Increment (Local1)
    }

    If (COMP ())
    {
    Or (HSTS, 0xFF, HSTS)
    Return (TBUF)
    }

    Return (0x00)
    }

    Method (STRT, 0, Serialized)
    {
    Store (0xC8, Local0)
    While (Local0)
    {
    If (And (HSTS, 0x40))
    {
    Decrement (Local0)
    Sleep (0x01)
    If (LEqual (Local0, 0x00))
    {
    Return (0x01)
    }
    }
    Else
    {
    Store (0x00, Local0)
    }
    }

    Store (0x0FA0, Local0)
    While (Local0)
    {
    If (And (HSTS, 0x01))
    {
    Decrement (Local0)
    Stall (0x32)
    If (LEqual (Local0, 0x00))
    {
    KILL ()
    }
    }
    Else
    {
    Return (0x00)
    }
    }

    Return (0x01)
    }

    Method (COMP, 0, Serialized)
    {
    Store (0x0FA0, Local0)
    While (Local0)
    {
    If (And (HSTS, 0x02))
    {
    Return (0x01)
    }
    Else
    {
    Decrement (Local0)
    Stall (0x32)
    If (LEqual (Local0, 0x00))
    {
    KILL ()
    }
    }
    }

    Return (0x00)
    }

    Method (KILL, 0, Serialized)
    {
    Or (HCON, 0x02, HCON)
    Or (HSTS, 0xFF, HSTS)
    }
    }
    }

    Scope (\_GPE)
    {
    Method (NWAK, 2, NotSerialized)
    {
    _L01 ()
    }

    Method (_L01, 0, NotSerialized)
    {
    If (LAnd (LEqual (RP1D, 0x00), \_SB.PCI0.RP01.HPSX))
    {
    Store (0x01, \_SB.PCI0.RP01.HPSX)
    }

    If (LAnd (LEqual (RP1D, 0x00), \_SB.PCI0.RP01.PDCX))
    {
    Store (0x01, \_SB.PCI0.RP01.PDCX)
    }

    If (LAnd (LEqual (RP2D, 0x00), \_SB.PCI0.RP02.HPSX))
    {
    Store (0x01, \_SB.PCI0.RP02.HPSX)
    }

    If (LAnd (LEqual (RP2D, 0x00), \_SB.PCI0.RP02.PDCX))
    {
    Store (0x01, \_SB.PCI0.RP02.PDCX)
    }

    If (LAnd (LEqual (RP3D, 0x00), \_SB.PCI0.RP03.HPSX))
    {
    Store (0x01, \_SB.PCI0.RP03.HPSX)
    }

    If (LAnd (LEqual (RP3D, 0x00), \_SB.PCI0.RP03.PDCX))
    {
    Store (0x01, \_SB.PCI0.RP03.PDCX)
    }

    If (LAnd (LEqual (RP4D, 0x00), \_SB.PCI0.RP04.HPSX))
    {
    Store (0x01, \_SB.PCI0.RP04.HPSX)
    }

    If (LAnd (LEqual (RP4D, 0x00), \_SB.PCI0.RP04.PDCX))
    {
    Store (0x01, \_SB.PCI0.RP04.PDCX)
    }

    If (LAnd (LEqual (RP5D, 0x00), \_SB.PCI0.RP05.HPSX))
    {
    Store (0x01, \_SB.PCI0.RP05.HPSX)
    }

    If (LAnd (LEqual (RP5D, 0x00), \_SB.PCI0.RP05.PDCX))
    {
    Store (0x01, \_SB.PCI0.RP05.PDCX)
    }

    Notify (\_SB.PCI0, 0x00)
    }
    }

    Scope (\)
    {
    Mutex (SMIX, 0x01)
    Name (SMIB, 0xCF779000)
    Name (PSMI, 0x000000B2)
    Method (SNVC, 1, NotSerialized)
    {
    OperationRegion (WWPR, SystemMemory, SMIB, 0x04)
    Field (WWPR, DWordAcc, Lock, Preserve)
    {
    SCDW, 32
    }

    Store (Arg0, SCDW)
    }

    Method (SNWB, 2, NotSerialized)
    {
    Store (SMIB, Local0)
    Add (Local0, Arg1, Local0)
    Add (Local0, 0x04, Local0)
    OperationRegion (WWPR, SystemMemory, Local0, 0x01)
    Field (WWPR, ByteAcc, Lock, Preserve)
    {
    SBY0, 8
    }

    CreateByteField (Arg0, Arg1, SVAL)
    Store (SVAL, SBY0)
    }

    Method (SNRB, 2, NotSerialized)
    {
    Store (SMIB, Local0)
    Add (Local0, Arg1, Local0)
    Add (Local0, 0x04, Local0)
    OperationRegion (WWPR, SystemMemory, Local0, 0x04)
    Field (WWPR, ByteAcc, Lock, Preserve)
    {
    SBY0, 8
    }

    CreateByteField (Arg0, Arg1, SVAL)
    Store (SBY0, SVAL)
    Return (Arg0)
    }

    Method (SNVP, 2, NotSerialized)
    {
    Store (SMIB, Local0)
    Add (Local0, Arg1, Local0)
    Add (Local0, 0x04, Local0)
    OperationRegion (WWPR, SystemMemory, Local0, 0x04)
    Field (WWPR, ByteAcc, Lock, Preserve)
    {
    SDW0, 32
    }

    CreateDWordField (Arg0, Arg1, SVAL)
    Store (SVAL, SDW0)
    }

    Method (SNVG, 2, NotSerialized)
    {
    Store (SMIB, Local0)
    Add (Local0, Arg1, Local0)
    Add (Local0, 0x04, Local0)
    OperationRegion (WWPR, SystemMemory, Local0, 0x04)
    Field (WWPR, ByteAcc, Lock, Preserve)
    {
    SDW0, 32
    }

    CreateDWordField (Arg0, Arg1, SVAL)
    Store (SDW0, SVAL)
    Return (Arg0)
    }

    Method (GENS, 3, NotSerialized)
    {
    Acquire (SMIX, 0xFFFF)
    Store (Arg1, Local0)
    If (LEqual (ObjectType (Arg1), 0x01))
    {
    Store (SMBI (Arg0, Arg1), Local0)
    }

    If (LEqual (ObjectType (Arg1), 0x03))
    {
    Store (SMBF (Arg0, Arg1, Arg2), Local0)
    }

    Release (SMIX)
    Return (Local0)
    }

    Method (SMBI, 2, NotSerialized)
    {
    SNVC (Arg0)
    Add (SMIB, 0x04, Local0)
    OperationRegion (WWPR, SystemMemory, Local0, 0x04)
    Field (WWPR, ByteAcc, Lock, Preserve)
    {
    SDW0, 32
    }

    Store (Arg1, SDW0)
    ASMI ()
    Return (SDW0)
    }

    Method (SMBF, 3, NotSerialized)
    {
    If (LGreater (Arg2, 0xFC))
    {
    Return (Arg1)
    }

    If (LLess (SizeOf (Arg1), Arg2))
    {
    Return (Arg1)
    }

    SNVC (Arg0)
    Divide (Arg2, 0x04, Local3, Local4)
    Store (0x00, Local0)
    While (LLess (Local0, Local3))
    {
    SNWB (Arg1, Local0)
    Increment (Local0)
    }

    While (LLess (Local0, Arg2))
    {
    SNVP (Arg1, Local0)
    Add (Local0, 0x04, Local0)
    }

    ASMI ()
    Store (0x00, Local0)
    While (LLess (Local0, Local3))
    {
    Store (SNRB (Arg1, Local0), Arg1)
    Increment (Local0)
    }

    While (LLess (Local0, Arg2))
    {
    Store (SNVG (Arg1, Local0), Arg1)
    Add (Local0, 0x04, Local0)
    }

    Return (Arg1)
    }

    Method (ASMI, 0, NotSerialized)
    {
    OperationRegion (SMIR, SystemIO, PSMI, 0x01)
    Field (SMIR, ByteAcc, Lock, Preserve)
    {
    SCMD, 8
    }

    Store (0x04, SCMD)
    }
    }

    Scope (\)
    {
    OperationRegion (WENX, SystemIO, 0x0685, 0x03)
    Field (WENX, ByteAcc, NoLock, Preserve)
    {
    WEN1, 8,
    WEN2, 8,
    WEN3, 8
    }

    OperationRegion (WSTX, SystemIO, 0x0680, 0x05)
    Field (WSTX, ByteAcc, NoLock, Preserve)
    {
    WST0, 8,
    PENA, 8,
    WST1, 8,
    WST2, 8,
    WST3, 8
    }

    OperationRegion (LEDX, SystemIO, 0x0C25, 0x01)
    Field (LEDX, ByteAcc, NoLock, Preserve)
    {
    LEDB, 2
    }

    Method (PSKM, 1, NotSerialized)
    {
    If (Or (LEqual (Arg0, 0x03), LEqual (Arg0, 0x01)))
    {
    Store (0x55, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x07, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x01, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xF0, \_SB.PCI0.LPCB.SIO.IREG)
    Store (\_SB.PCI0.LPCB.SIO.DREG, Local0)
    Or (Local0, 0x60, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xAA, \_SB.PCI0.LPCB.SIO.IREG)
    Store (WST1, Local0)
    Or (Local0, 0x18, WST1)
    Store (WST0, Local0)
    Or (Local0, 0x01, WST0)
    Store (WEN1, Local0)
    Or (Local0, 0x18, WEN1)
    Store (PENA, Local0)
    Or (Local0, 0x01, PENA)
    }
    }

    Method (GPKM, 0, NotSerialized)
    {
    Store (WEN1, Local0)
    And (Local0, 0xE7, WEN1)
    Store (WST1, Local0)
    And (Local0, 0x18, WST1)
    Store (WST0, Local0)
    And (Local0, 0x01, WST0)
    }

    Method (WKKM, 1, NotSerialized)
    {
    If (LEqual (Arg0, 0x01))
    {
    Store (WEN1, Local0)
    And (Local0, 0xE7, WEN1)
    Store (PENA, Local0)
    And (Local0, 0xFE, PENA)
    Store (0x55, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x07, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x01, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xF0, \_SB.PCI0.LPCB.SIO.IREG)
    Store (\_SB.PCI0.LPCB.SIO.DREG, Local0)
    Or (Local0, 0x9F, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xAA, \_SB.PCI0.LPCB.SIO.IREG)
    }

    If (LEqual (Arg0, 0x03))
    {
    Store (WEN1, Local0)
    And (Local0, 0xE7, WEN1)
    Store (PENA, Local0)
    And (Local0, 0xFE, PENA)
    Store (0x55, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x07, \_SB.PCI0.LPCB.SIO.IREG)
    Store (0x01, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xF0, \_SB.PCI0.LPCB.SIO.IREG)
    Store (\_SB.PCI0.LPCB.SIO.DREG, Local0)
    Or (Local0, 0x9F, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xF2, \_SB.PCI0.LPCB.SIO.IREG)
    Store (\_SB.PCI0.LPCB.SIO.DREG, Local0)
    Or (Local0, 0x01, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xF2, \_SB.PCI0.LPCB.SIO.IREG)
    Store (\_SB.PCI0.LPCB.SIO.DREG, Local0)
    And (Local0, 0xFE, \_SB.PCI0.LPCB.SIO.DREG)
    Store (0xAA, \_SB.PCI0.LPCB.SIO.IREG)
    }
    }
    }

    Scope (\_SI)
    {
    Method (_SST, 1, NotSerialized)
    {
    If (LEqual (Arg0, 0x03))
    {
    Store (0x01, LEDB)
    }

    If (LEqual (Arg0, 0x01))
    {
    Store (0x03, LEDB)
    }
    }
    }

    Scope (\_SB.PCI0.LPCB)
    {
    Device (SIO)
    {
    Name (_HID, EisaId ("PNP0A05"))
    Mutex (MX00, 0x01)
    OperationRegion (VSIO, SystemIO, 0x2E, 0x02)
    Field (VSIO, ByteAcc, NoLock, Preserve)
    {
    IREG, 8,
    DREG, 8
    }

    IndexField (IREG, DREG, ByteAcc, NoLock, Preserve)
    {
    Offset (0x07),
    LDNM, 8,
    Offset (0x41),
    CR41, 8,
    Offset (0x43),
    CR43, 8,
    CR44, 8,
    CR45, 8,
    CR46, 8,
    CR47, 8,
    Offset (0x4C),
    CR4C, 8,
    Offset (0x53),
    CR53, 8,
    Offset (0x55),
    CR55, 8,
    Offset (0x57),
    CR57, 8,
    Offset (0x61),
    CR61, 8,
    CR62, 8,
    CR63, 8,
    Offset (0x65),
    CR65, 8,
    CR66, 8,
    CR67, 8,
    Offset (0x69),
    CR69, 8,
    CR6A, 8,
    CR6B, 8,
    Offset (0x6D),
    CR6D, 8,
    CR6E, 8,
    CR6F, 8,
    Offset (0x71),
    CR71, 8,
    CR72, 8,
    CR73, 8,
    Offset (0x79),
    CR79, 8,
    CR7A, 8,
    CR7B, 8,
    Offset (0x7D),
    CR7D, 8,
    CR7E, 8,
    CR7F, 8,
    Offset (0x81),
    CR81, 8,
    CR82, 8,
    CR83, 8
    }

    IndexField (IREG, DREG, ByteAcc, NoLock, Preserve)
    {
    Offset (0x30),
    ACTI, 8,
    Offset (0xF0),
    MODX, 8
    }

    Method (ENCG, 0, NotSerialized)
    {
    Store (0x55, IREG)
    }

    Method (EXCG, 0, NotSerialized)
    {
    Store (0xAA, IREG)
    }

    Method (SDEV, 1, NotSerialized)
    {
    Store (Arg0, LDNM)
    }

    Device (MOU)
    {
    Name (_HID, EisaId ("PNP0F13"))
    Name (_PRW, Package (0x02)
    {
    0x08,
    0x03
    })
    Method (_STA, 0, NotSerialized)
    {
    Name (RET, Zero)
    Store (0x00, RET)
    If (GCMS ())
    {
    Store (0x0F, RET)
    }

    Return (RET)
    }

    Method (_CRS, 0, NotSerialized)
    {
    Name (MOUB, ResourceTemplate ()
    {
    IRQNoFlags ()
    {12}
    })
    Name (MOKB, ResourceTemplate ()
    {
    IO (Decode16,
    0x0060, // Range Minimum
    0x0060, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IO (Decode16,
    0x0064, // Range Minimum
    0x0064, // Range Maximum
    0x01, // Alignment
    0x01, // Length
    )
    IRQNoFlags ()
    {12}
    })
    If (GCKB ())
    {
    Return (MOUB)
    }
    Else
    {
    Return (MOKB)
    }
    }
    }

    Device (ECP)
    {
    Name (_HID, EisaId ("PNP0401"))
    Method (_STA, 0, NotSerialized)
    {
    If (GCPP ())
    {
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x11)
    Store (ACTI, Local0)
    If (LEqual (Local0, 0x01))
    {
    Store (0x0F, Local1)
    }
    Else
    {
    Store (0x0D, Local1)
    }

    EXCG ()
    Release (MX00)
    }
    Else
    {
    Store (0x00, Local1)
    }

    Return (Local1)
    }

    Method (_DIS, 0, NotSerialized)
    {
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x11)
    Store (0x00, ACTI)
    EXCG ()
    Release (MX00)
    }

    Method (_CRS, 0, NotSerialized)
    {
    Name (BUF0, ResourceTemplate ()
    {
    IO (Decode16,
    0x0000, // Range Minimum
    0x0000, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IO (Decode16,
    0x0000, // Range Minimum
    0x0000, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {}
    DMA (Compatibility, NotBusMaster, Transfer8, )
    {}
    })
    CreateByteField (BUF0, 0x02, IOLO)
    CreateByteField (BUF0, 0x03, IOHI)
    CreateByteField (BUF0, 0x04, IORL)
    CreateByteField (BUF0, 0x05, IORH)
    CreateByteField (BUF0, 0x0A, DALO)
    CreateByteField (BUF0, 0x0B, DAHI)
    CreateByteField (BUF0, 0x0C, DRLO)
    CreateByteField (BUF0, 0x0D, DRHI)
    CreateByteField (BUF0, 0x11, IRQL)
    CreateByteField (BUF0, 0x14, DMAC)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (CR82, IOLO)
    Store (CR83, IOHI)
    Store (CR82, IORL)
    Store (CR83, IORH)
    Store (IOHI, Local0)
    Add (Local0, 0x04, Local0)
    Store (Local0, DAHI)
    Store (IOLO, DALO)
    Store (DALO, DRLO)
    Store (DAHI, DRHI)
    Store (CR45, Local0)
    If (LEqual (Local0, 0x11))
    {
    Store (0x05, Local1)
    Store (0x01, Local0)
    ShiftLeft (Local0, Local1, IRQL)
    }

    Store (CR47, Local0)
    If (LEqual (Local0, 0x11))
    {
    Store (0x07, Local1)
    Store (0x01, Local0)
    ShiftLeft (Local0, Local1, IRQL)
    }

    Store (CR53, Local0)
    If (LEqual (Local0, 0x91))
    {
    Store (0x02, Local1)
    Store (0x01, Local0)
    ShiftLeft (Local0, Local1, DMAC)
    }

    EXCG ()
    Release (MX00)
    Return (BUF0)
    }

    Name (_PRS, ResourceTemplate ()
    {
    StartDependentFn (0x00, 0x00)
    {
    IO (Decode16,
    0x0378, // Range Minimum
    0x0378, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IO (Decode16,
    0x0778, // Range Minimum
    0x0778, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {7}
    DMA (Compatibility, NotBusMaster, Transfer8, )
    {0}
    }
    StartDependentFn (0x01, 0x00)
    {
    IO (Decode16,
    0x0278, // Range Minimum
    0x0278, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IO (Decode16,
    0x0678, // Range Minimum
    0x0678, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {5}
    DMA (Compatibility, NotBusMaster, Transfer8, )
    {0}
    }
    StartDependentFn (0x01, 0x01)
    {
    IO (Decode16,
    0x03BC, // Range Minimum
    0x03BC, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IO (Decode16,
    0x07BC, // Range Minimum
    0x07BC, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {7}
    DMA (Compatibility, NotBusMaster, Transfer8, )
    {0}
    }
    EndDependentFn ()
    })
    Method (_SRS, 1, NotSerialized)
    {
    CreateByteField (Arg0, 0x02, IOLO)
    CreateByteField (Arg0, 0x03, IOHI)
    CreateByteField (Arg0, 0x11, IRQL)
    CreateByteField (Arg0, 0x14, DMAC)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (IOLO, CR82)
    Store (IOHI, CR83)
    If (LEqual (IOLO, 0xBC))
    {
    Store (0x02, LPTO)
    }

    If (LEqual (IOLO, 0x78))
    {
    If (LEqual (IOHI, 0x02))
    {
    Store (0x01, LPTO)
    }

    If (LEqual (IOHI, 0x03))
    {
    Store (0x00, LPTO)
    }
    }

    FindSetRightBit (IRQL, Local0)
    Subtract (Local0, 0x01, Local0)
    If (LEqual (Local0, 0x05))
    {
    Store (0x11, CR45)
    Store (CR47, Local0)
    If (LEqual (Local0, 0x11))
    {
    Store (0xFF, CR47)
    }
    }
    Else
    {
    If (LEqual (Local0, 0x07))
    {
    Store (0x11, CR47)
    Store (CR45, Local0)
    If (LEqual (Local0, 0x11))
    {
    Store (0xFF, CR45)
    }
    }
    }

    FindSetRightBit (DMAC, Local0)
    Subtract (Local0, 0x01, Local0)
    If (LEqual (Local0, 0x01))
    {
    Store (0x91, CR53)
    }

    SDEV (0x11)
    Store (0x01, ACTI)
    EXCG ()
    Release (MX00)
    }
    }

    Device (COM1)
    {
    Name (_HID, EisaId ("PNP0501"))
    Name (_UID, 0x01)
    Method (_STA, 0, NotSerialized)
    {
    Acquire (MX00, 0xFFFF)
    If (GCS1 ())
    {
    ENCG ()
    SDEV (0x07)
    Store (ACTI, Local0)
    If (LEqual (Local0, 0x01))
    {
    Store (0x0F, Local1)
    }
    Else
    {
    Store (0x0D, Local1)
    }

    EXCG ()
    Release (MX00)
    }
    Else
    {
    Store (0x00, Local1)
    }

    Return (Local1)
    }

    Method (_DIS, 0, NotSerialized)
    {
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x07)
    Store (0x00, ACTI)
    EXCG ()
    Release (MX00)
    }

    Method (_CRS, 0, NotSerialized)
    {
    Name (BUF0, ResourceTemplate ()
    {
    IO (Decode16,
    0x03F8, // Range Minimum
    0x03F8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {4}
    })
    CreateByteField (BUF0, 0x02, IOLO)
    CreateByteField (BUF0, 0x03, IOHI)
    CreateByteField (BUF0, 0x04, IORL)
    CreateByteField (BUF0, 0x05, IORH)
    CreateByteField (BUF0, 0x09, IRQL)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (CR6A, Local0)
    Store (Local0, IOLO)
    Store (CR6B, Local0)
    Store (Local0, IOHI)
    Store (IOLO, IORL)
    Store (IOHI, IORH)
    Store (CR44, Local0)
    If (LEqual (Local0, 0x07))
    {
    Store (0x04, Local0)
    Store (0x01, Local1)
    ShiftLeft (Local1, Local0, IRQL)
    }

    Store (CR43, Local0)
    If (LEqual (Local0, 0x07))
    {
    Store (0x03, Local0)
    Store (0x01, Local1)
    ShiftLeft (Local1, Local0, IRQL)
    }

    EXCG ()
    Release (MX00)
    Return (BUF0)
    }

    Name (_PRS, ResourceTemplate ()
    {
    StartDependentFn (0x00, 0x00)
    {
    IO (Decode16,
    0x03F8, // Range Minimum
    0x03F8, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {4}
    }
    StartDependentFnNoPri ()
    {
    IO (Decode16,
    0x02F8, // Range Minimum
    0x02F8, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3,4,5,6,7,10,11,12}
    }
    StartDependentFnNoPri ()
    {
    IO (Decode16,
    0x03E8, // Range Minimum
    0x03E8, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3,4,5,6,7,10,11,12}
    }
    StartDependentFnNoPri ()
    {
    IO (Decode16,
    0x02E8, // Range Minimum
    0x02E8, // Range Maximum
    0x01, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3,4,5,6,7,10,11,12}
    }
    EndDependentFn ()
    })
    Method (_SRS, 1, NotSerialized)
    {
    CreateByteField (Arg0, 0x02, IOLO)
    CreateByteField (Arg0, 0x03, IOHI)
    CreateByteField (Arg0, 0x09, IRQL)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (IOLO, CR6A)
    Store (IOHI, CR6B)
    FindSetRightBit (IRQL, Local0)
    Decrement (Local0)
    If (LEqual (Local0, 0x04))
    {
    Store (0x07, CR44)
    Store (CR43, Local0)
    If (LEqual (Local0, 0x07))
    {
    Store (0xFF, CR43)
    }
    }
    Else
    {
    If (LEqual (Local0, 0x03))
    {
    Store (0x07, CR43)
    Store (CR44, Local0)
    If (LEqual (Local0, 0x07))
    {
    Store (0xFF, CR44)
    }
    }
    }

    If (LEqual (IOHI, 0x03))
    {
    If (LEqual (IOLO, 0xF8))
    {
    Store (0x00, NSCA)
    }

    If (LEqual (IOLO, 0xE8))
    {
    Store (0x07, NSCA)
    }
    }

    If (LEqual (IOHI, 0x02))
    {
    If (LEqual (IOLO, 0xF8))
    {
    Store (0x01, NSCA)
    }

    If (LEqual (IOLO, 0xE8))
    {
    Store (0x05, NSCA)
    }
    }

    SDEV (0x07)
    Store (0x01, ACTI)
    EXCG ()
    Release (MX00)
    }
    }

    Device (COM2)
    {
    Name (_HID, EisaId ("PNP0501"))
    Name (_UID, 0x02)
    Method (_STA, 0, NotSerialized)
    {
    If (GCS2 ())
    {
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x08)
    Store (ACTI, Local0)
    If (LEqual (Local0, 0x01))
    {
    Store (0x0F, Local1)
    }
    Else
    {
    Store (0x0D, Local1)
    }

    EXCG ()
    Release (MX00)
    }
    Else
    {
    Store (0x00, Local1)
    }

    Return (Local1)
    }

    Method (_DIS, 0, NotSerialized)
    {
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x08)
    Store (0x00, ACTI)
    EXCG ()
    Release (MX00)
    }

    Method (_CRS, 0, NotSerialized)
    {
    Name (BUF0, ResourceTemplate ()
    {
    IO (Decode16,
    0x02F8, // Range Minimum
    0x02F8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3}
    })
    CreateByteField (BUF0, 0x02, IOLO)
    CreateByteField (BUF0, 0x03, IOHI)
    CreateByteField (BUF0, 0x04, IORL)
    CreateByteField (BUF0, 0x05, IORH)
    CreateByteField (BUF0, 0x09, IRQL)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (CR6E, Local0)
    Store (Local0, IOLO)
    Store (CR6F, Local0)
    Store (Local0, IOHI)
    Store (IOLO, IORL)
    Store (IOHI, IORH)
    Store (CR43, Local0)
    If (LEqual (Local0, 0x08))
    {
    Store (0x03, Local0)
    Store (0x01, Local1)
    ShiftLeft (Local1, Local0, IRQL)
    }

    Store (CR44, Local0)
    If (LEqual (Local0, 0x08))
    {
    Store (0x04, Local0)
    Store (0x01, Local1)
    ShiftLeft (Local1, Local0, IRQL)
    }

    EXCG ()
    Release (MX00)
    Return (BUF0)
    }

    Name (_PRS, ResourceTemplate ()
    {
    StartDependentFn (0x00, 0x00)
    {
    IO (Decode16,
    0x02F8, // Range Minimum
    0x02F8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3}
    }
    StartDependentFn (0x00, 0x00)
    {
    IO (Decode16,
    0x02E8, // Range Minimum
    0x02E8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {3}
    }
    StartDependentFn (0x00, 0x01)
    {
    IO (Decode16,
    0x03F8, // Range Minimum
    0x03F8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {4}
    }
    StartDependentFn (0x00, 0x01)
    {
    IO (Decode16,
    0x03E8, // Range Minimum
    0x03E8, // Range Maximum
    0x08, // Alignment
    0x08, // Length
    )
    IRQNoFlags ()
    {4}
    }
    EndDependentFn ()
    })
    Method (_SRS, 1, NotSerialized)
    {
    CreateByteField (Arg0, 0x02, IOLO)
    CreateByteField (Arg0, 0x03, IOHI)
    CreateByteField (Arg0, 0x09, IRQL)
    Acquire (MX00, 0xFFFF)
    ENCG ()
    SDEV (0x0C)
    Store (IOLO, CR6E)
    Store (IOHI, CR6F)
    FindSetRightBit (IRQL, Local0)
    Decrement (Local0)
    If (LEqual (Local0, 0x04))
    {
    Store (0x08, CR44)
    Store (CR43, Local0)
    If (LEqual (Local0, 0x08))
    {
    Store (0xFF, CR43)
    }
    }
    Else
    {
    If (LEqual (Local0, 0x03))
    {
    Store (0x08, CR43)
    Store (CR44, Local0)
    If (LEqual (Local0, 0x08))
    {
    Store (0xFF, CR44)
    }
    }
    }

    If (LEqual (IOHI, 0x03))
    {
    If (LEqual (IOLO, 0xF8))
    {
    Store (0x00, NSCB)
    }

    If (LEqual (IOLO, 0xE8))
    {
    Store (0x07, NSCB)
    }
    }

    If (LEqual (IOHI, 0x02))
    {
    If (LEqual (IOLO, 0xF8))
    {
    Store (0x01, NSCB)
    }

    If (LEqual (IOLO, 0xE8))
    {
    Store (0x05, NSCB)
    }
    }

    SDEV (0x08)
    Store (0x01, ACTI)
    EXCG ()
    Release (MX00)
    }
    }
    }

    OperationRegion (COM, PCI_Config, 0x80, 0x01)
    Field (\_SB.PCI0.LPCB.COM, ByteAcc, NoLock, Preserve)
    {
    NSCA, 3,
    , 1,
    NSCB, 3,
    Offset (0x01)
    }

    OperationRegion (FDPA, PCI_Config, 0x81, 0x01)
    Field (\_SB.PCI0.LPCB.FDPA, ByteAcc, NoLock, Preserve)
    {
    LPTO, 2,
    , 2,
    FDDC, 1,
    Offset (0x01)
    }
    }

    Scope (\)
    {
    Method (GCS1, 0, NotSerialized)
    {
    If (LEqual (CMCP, 0x00))
    {
    Return (0x00)
    }
    Else
    {
    Return (0x01)
    }
    }

    Method (GCS2, 0, NotSerialized)
    {
    Return (0x00)
    }

    Method (GCKB, 0, NotSerialized)
    {
    If (And (\IOST, 0x0400))
    {
    Return (0x01)
    }
    Else
    {
    Return (0x00)
    }
    }

    Method (GCMS, 0, NotSerialized)
    {
    Return (And (\IOST, 0x4000))
    }

    Method (GCFD, 0, NotSerialized)
    {
    Return (0x01)
    }

    Method (GCPP, 0, NotSerialized)
    {
    If (LEqual (LPTP, 0x00))
    {
    Return (0x00)
    }
    Else
    {
    Return (0x01)
    }
    }
    }

    Scope (\_SB.PCI0.GLAN)
    {
    Method (_PSW, 1, NotSerialized)
    {
    If (Arg0)
    {
    GENS (0x1B, 0x01, 0x00)
    }
    Else
    {
    GENS (0x1B, 0x00, 0x00)
    }
    }
    }

    Method (\AWAK, 1, NotSerialized)
    {
    Return (Package (0x02)
    {
    0x00,
    0x00
    })
    }

    Method (\APTS, 1, NotSerialized)
    {
    }

    Name (\_S0, Package (0x04)
    {
    0x00,
    0x00,
    0x00,
    0x00
    })
    Name (\_S3, Package (0x04)
    {
    0x05,
    0x00,
    0x00,
    0x00
    })
    Name (\_S4, Package (0x04)
    {
    0x06,
    0x00,
    0x00,
    0x00
    })
    Name (\_S5, Package (0x04)
    {
    0x07,
    0x00,
    0x00,
    0x00
    })
    Method (_PTS, 1, NotSerialized)
    {
    \APTS (Arg0)
    \EV4 (Arg0, 0x00)
    PSKM (Arg0)
    }

    Method (_WAK, 1, NotSerialized)
    {
    WKKM (Arg0)
    \EV2 (Arg0, 0x00)
    \AWAK (Arg0)
    If (Or (RIST, PBST))
    {
    Notify (\_SB.PWRB, 0x02)
    }

    Return (Package (0x02)
    {
    0x00,
    0x00
    })
    }

    Scope (\_SB.PCI0)
    {
    Method (_INI, 0, NotSerialized)
    {
    \EV1 (0x02, 0x00)
    }
    }

    Method (\EV4, 2, NotSerialized)
    {
    }

    Method (\EV1, 2, NotSerialized)
    {
    \_SB.PCI0.IINI (Arg0, Arg1)
    \_SB.SOS0 (Arg0, Arg1)
    }

    Method (\EV2, 2, NotSerialized)
    {
    \_GPE.NWAK (Arg0, Arg1)
    \_SB.SOS4 (Arg0, Arg1)
    }

    Method (\EV3, 2, NotSerialized)
    {
    \_PR.PPCE (Arg0, Arg1)
    }
    }

    [unhandled content-type:application/octet-stream]
    \
     
     \ /
      Last update: 2012-01-16 12:29    [W:0.670 / U:1.520 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site