/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20050211
 *
 * Disassembly of dsdt.out, Sun Feb 27 19:43:53 2005
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "MITAC", "TOPPER__", 4100)
{
    Name (VERS, Package (0x03)
    {
        "Project: OEMx", 
        "Date: 06/04/2002", 
        "Vers: 1.00.04"
    })
    Name (NIMH, "NiMH")
    Name (LION, "Lion")
    Name (REC, 0x00)
    Name (OSFB, 0x00)
    Name (\ECON, 0x01)
    Name (MYOS, Zero)
    OperationRegion (SMIO, SystemIO, 0xB2, 0x02)
    Field (SMIO, ByteAcc, NoLock, Preserve)
    {
        APMC,   8, 
        APMD,   8
    }

    OperationRegion (PMIO, SystemIO, 0x1000, 0x80)
    Field (PMIO, DWordAcc, NoLock, Preserve)
    {
        Offset (0x01), 
        PBST,   1, 
        Offset (0x02)
    }

    OperationRegion (GPI7, SystemIO, 0x102A, 0x02)
    Field (GPI7, WordAcc, NoLock, Preserve)
    {
            ,   7, 
        KBID,   1, 
            ,   7, 
        Offset (0x02)
    }

    OperationRegion (GPIO, SystemIO, 0x1300, 0x40)
    Field (GPIO, DWordAcc, NoLock, Preserve)
    {
        USSE,   32, 
        IOSE,   32, 
        Offset (0x0F), 
            ,   1, 
        SPK,    1, 
            ,   2, 
        Offset (0x10), 
        Offset (0x12), 
        CDPR,   1, 
        Offset (0x14), 
        Offset (0x18), 
        GTTL,   32, 
        BLNK,   32, 
        Offset (0x24), 
        Offset (0x28), 
        GINV,   32, 
        USE2,   32, 
        IOS2,   32, 
        Offset (0x35), 
            ,   1, 
        SIDT,   1, 
            ,   1, 
        CDRT,   1, 
        Offset (0x38)
    }

    OperationRegion (SM02, SystemIO, 0x1400, 0x08)
    Field (SM02, ByteAcc, NoLock, Preserve)
    {
        SSTA,   8, 
        Offset (0x02), 
        SCTL,   8, 
        SCMD,   8, 
        SXIT,   8, 
        SHD0,   8, 
        SHD1,   8, 
        SBLK,   8
    }

    OperationRegion (PT80, SystemIO, 0x80, 0x01)
    Field (PT80, ByteAcc, NoLock, Preserve)
    {
        P80T,   8
    }

    OperationRegion (MBOX, SystemMemory, 0x1FFFFC00, 0x08)
    Field (MBOX, AnyAcc, Lock, Preserve)
    {
        DTLO,   8, 
        DTHI,   8, 
        UTYP,   2, 
            ,   2, 
        GMOD,   3, 
        Offset (0x03), 
            ,   5, 
        MDOD,   3, 
        CMAD,   3, 
            ,   1, 
        CMBD,   3, 
        Offset (0x05), 
        PTYP,   2, 
        EPDA,   1, 
            ,   1, 
        LPTE,   2, 
            ,   1, 
        EPPT,   1, 
        ETLO,   8, 
        ETHI,   8
    }

    OperationRegion (BTT1, SystemMemory, 0x04F0, 0x0F)
    Field (BTT1, ByteAcc, NoLock, Preserve)
    {
            ,   5, 
        WORI,   1, 
        WOLA,   1, 
        Offset (0x01), 
            ,   1, 
        S3,     1, 
        Offset (0x02)
    }

    OperationRegion (BTT0, SystemMemory, 0x04C0, 0x20)
    Field (BTT0, ByteAcc, NoLock, Preserve)
    {
        MBUF,   128, 
        Offset (0x15), 
        OSFG,   4, 
        RTCF,   1, 
        IDDT,   1, 
        HSEV,   1, 
        Offset (0x16), 
        SMIF,   8, 
        CSTE,   16, 
        NSTE,   16
    }

    Scope (\_PR)
    {
        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
    }

    Scope (\_GPE)
    {
        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB0, 0x02)
        }

        Method (_L04, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB1, 0x02)
        }

        Method (_L05, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.MC97, 0x02)
        }

        Method (_L08, 0, NotSerialized)
        {
        }

        Method (_L09, 0, NotSerialized)
        {
        }

        Method (_L0A, 0, NotSerialized)
        {
        }

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

        Method (_L0D, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.USB3, 0x02)
        }
    }

    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S3, Package (0x04)
    {
        0x05, 
        0x05, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)
    {
        0x06, 
        0x06, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)
    {
        0x07, 
        0x07, 
        0x00, 
        0x00
    })
    Method (\_PTS, 1, NotSerialized)
    {
        Store (0x01, SPK)
        Store (0xED, APMC)
        Sleep (0x04B0)
        Store (0x00, \_SB.AC.ACFG)
        Store (0x01, PBST)
        While (PBST)
        {
            Store (0x01, PBST)
        }

        If (LEqual (Arg0, 0x01))
        {
            Store (0x51, P80T)
        }
        Else
        {
            If (LEqual (Arg0, 0x03))
            {
                Store (0x53, P80T)
                Store (0xE9, APMC)
                Store (0x09, APMD)
                Store (0xE3, APMC)
                Store (0xEC, APMC)
            }
            Else
            {
                If (LEqual (Arg0, 0x04))
                {
                    Store (0x54, P80T)
                    Store (0xE8, APMC)
                }
                Else
                {
                    Store (0x55, P80T)
                }
            }
        }
    }

    Method (\_WAK, 1, NotSerialized)
    {
        If (LEqual (RTCF, Zero))
        {
            Notify (\_SB.SBTN, 0x02)
        }

        If (LEqual (Arg0, 0x01))
        {
            Store (0xE1, P80T)
            Return (0x00)
        }
        Else
        {
            If (LEqual (Arg0, 0x03))
            {
                If (LNot (LLess (MYOS, 0x02)))
                {
                    And (\_SB.PCI0.USB3.MBAR, 0x00, \_SB.PCI0.USB3.MBAR)
                    Or (\_SB.PCI0.LPCB.FDIS, 0x8000, \_SB.PCI0.LPCB.FDIS)
                }

                Store (0xE3, P80T)
                Store (0x08, APMD)
                Store (0xE3, APMC)
                Store (0xEB, APMC)
                Return (0x00)
            }
            Else
            {
                If (LEqual (Arg0, 0x04))
                {
                    If (LNot (LLess (MYOS, 0x02)))
                    {
                        And (\_SB.PCI0.USB3.MBAR, 0x00, \_SB.PCI0.USB3.MBAR)
                        Or (\_SB.PCI0.LPCB.FDIS, 0x8000, \_SB.PCI0.LPCB.FDIS)
                    }

                    Store (0xE4, P80T)
                    Return (0x00)
                }
                Else
                {
                    Store (0xE5, P80T)
                    Return (0x00)
                }
            }
        }

        Store (0x00, SPK)
    }

    Scope (\_SB)
    {
        Method (_INI, 0, NotSerialized)
        {
            If (CondRefOf (_OSI, Local0))
            {
                Store (0x04, OSFG)
            }
            Else
            {
                Store (SizeOf (_OS), Local0)
                If (LEqual (Local0, 0x14))
                {
                    Store (0x03, OSFG)
                }
                Else
                {
                    If (LEqual (Local0, 0x27))
                    {
                        Store (0x02, OSFG)
                    }
                    Else
                    {
                        Store (0x01, OSFG)
                    }
                }
            }
        }

        Device (SBTN)
        {
            Name (_HID, EisaId ("PNP0C0E"))
            Method (_STA, 0, NotSerialized)
            {
                Return (0x0B)
            }

            Name (_PRW, Package (0x02)
            {
                0x1D, 
                0x04
            })
            Method (_PSW, 1, NotSerialized)
            {
                If (LEqual (Arg0, Zero))
                {
                    Noop
                }
                Else
                {
                    Noop
                }
            }
        }

        Device (AC)
        {
            Name (_HID, "ACPI0003")
            Name (ACST, 0x00)
            Name (ACFG, 0x00)
            Name (_PCL, Package (0x02)
            {
                \_SB, 
                BAT0
            })
            Method (_PSR, 0, NotSerialized)
            {
                If (REC)
                {
                    If (ACFG)
                    {
                        Store (ACST, Local0)
                    }
                    Else
                    {
                        Store (\_SB.PCI0.LPCB.EC0.ADP, Local0)
                        Store (Local0, ACST)
                        Store (0x01, ACFG)
                    }
                }
                Else
                {
                    Store (0x01, Local0)
                }

                Sleep (0x78)
                Store (Local0, Debug)
                Return (Local0)
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                If (REC)
                {
                    If (\_SB.PCI0.LPCB.EC0.LIDS)
                    {
                        Return (Zero)
                    }

                    Return (One)
                }
                Else
                {
                    Return (One)
                }
            }
        }

        Device (BAT0)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Method (_STA, 0, NotSerialized)
            {
                If (REC)
                {
                    If (\_SB.PCI0.LPCB.EC0.BAT)
                    {
                        Store (0x1F, Local0)
                    }
                    Else
                    {
                        Store (0x0F, Local0)
                    }

                    And (Local0, 0x1F, Local0)
                    Store (Local0, Debug)
                    Return (Local0)
                }
                Else
                {
                    Return (0x0F)
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                Name (BIFP, Package (0x0D)
                {
                    0x01, 
                    0xFFFFFFFF, 
                    0xFFFFFFFF, 
                    0x01, 
                    0xFFFFFFFF, 
                    0x012C, 
                    0x96, 
                    0x01, 
                    0x01, 
                    "Internal Battery", 
                    "", 
                    "LIon", 
                    "SAM Corporation"
                })
                If (REC)
                {
                    Store (\_SB.PCI0.LPCB.EC0.BDC0, Index (BIFP, 0x01))
                    Store (\_SB.PCI0.LPCB.EC0.BDV0, Index (BIFP, 0x04))
                    Store (\_SB.PCI0.LPCB.EC0.BFC0, Local0)
                    Store (Local0, Index (BIFP, 0x02))
                    Divide (Local0, 0x0A, Local1, Local2)
                    Store (Local2, Index (BIFP, 0x05))
                    Divide (Local0, 0x14, Local1, Local2)
                    Store (Local2, Index (BIFP, 0x06))
                    If (\_SB.PCI0.LPCB.EC0.BTYP)
                    {
                        Store (NIMH, Index (BIFP, 0x0B))
                    }
                    Else
                    {
                        Store (LION, Index (BIFP, 0x0B))
                    }
                }

                Store (BIFP, Debug)
                Return (BIFP)
            }

            Name (BSTP, Package (0x04)
            {
                0x00, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0xFFFFFFFF
            })
            Method (_BST, 0, Serialized)
            {
                If (REC)
                {
                    Store (\_SB.PCI0.LPCB.EC0.BPV0, Index (BSTP, 0x03))
                    Store (\_SB.PCI0.LPCB.EC0.BRC0, Local3)
                    Store (Local3, Index (BSTP, 0x02))
                    Store (\_SB.PCI0.LPCB.EC0.BPR0, Local0)
                    If (LNot (LLess (Local0, 0x8000)))
                    {
                        And (Not (Local0), 0xFFFF, Local0)
                    }

                    Store (Local0, Index (BSTP, 0x01))
                    If (\_SB.PCI0.LPCB.EC0.ADP)
                    {
                        If (\_SB.PCI0.LPCB.EC0.CHRG)
                        {
                            Store (0x02, Index (BSTP, 0x00))
                        }
                        Else
                        {
                            Store (0x00, Index (BSTP, 0x00))
                        }
                    }
                    Else
                    {
                        If (LLess (Local3, 0x19))
                        {
                            Store (0x05, Index (BSTP, 0x00))
                        }
                        Else
                        {
                            Store (0x01, Index (BSTP, 0x00))
                        }
                    }
                }

                Store (BSTP, Debug)
                Return (BSTP)
            }
        }

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Method (_INI, 0, NotSerialized)
            {
                If (LNot (LEqual (OSFG, 0x04)))
                {
                    Store (SizeOf (_OS), Local0)
                    If (LEqual (Local0, 0x14))
                    {
                        Store (0x03, OSFG)
                    }
                    Else
                    {
                        If (LEqual (Local0, 0x27))
                        {
                            Store (0x02, OSFG)
                        }
                        Else
                        {
                            Store (0x01, OSFG)
                        }
                    }
                }
            }

            Name (\DSEN, 0x01)
            Device (GFX0)
            {
                Name (_ADR, 0x00020000)
                Method (_DOS, 1, NotSerialized)
                {
                    Store (And (Arg0, 0x03), DSEN)
                }

                Method (_DOD, 0, NotSerialized)
                {
                    Return (Package (0x06)
                    {
                        0x00010100, 
                        0x00010110, 
                        0x00010200, 
                        0x00010300, 
                        0x00010500, 
                        0x00010600
                    })
                }

                Device (CRT1)
                {
                    Name (_ADR, 0x0100)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x0101))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x0101))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

                Device (DTV1)
                {
                    Name (_ADR, 0x0200)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x0202))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x0202))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

                Device (DFP1)
                {
                    Name (_ADR, 0x0300)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x0404))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x0404))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

                Device (LCD)
                {
                    Method (_ADR, 0, NotSerialized)
                    {
                        Return (0x0110)
                        Return (0x0400)
                    }

                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x0808))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x0808))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

                    Method (_BCL, 0, NotSerialized)
                    {
                        Return (Package (0x08)
                        {
                            0x50, 
                            0x3C, 
                            0x00, 
                            0x14, 
                            0x28, 
                            0x3C, 
                            0x50, 
                            0x64
                        })
                    }

                    Method (_BCM, 1, NotSerialized)
                    {
                        Store (Arg0, P80T)
                    }
                }

                Device (DTV2)
                {
                    Name (_ADR, 0x0500)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x1010))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x1010))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

                Device (DFP2)
                {
                    Name (_ADR, 0x0600)
                    Method (_DCS, 0, NotSerialized)
                    {
                        Store (0x06, APMD)
                        Store (0xE3, APMC)
                        If (And (CSTE, 0x2020))
                        {
                            Return (0x1F)
                        }

                        Return (0x1D)
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (And (NSTE, 0x2020))
                        {
                            Return (0x01)
                        }

                        Return (0x00)
                    }

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

            Device (PCI2)
            {
                Name (_ADR, 0x001E0000)
                Device (LAN)
                {
                    Name (_ADR, 0x00020000)
                    Name (LPRW, Package (0x02)
                    {
                        0x0B, 
                        0x03
                    })
                    Method (_PRW, 0, NotSerialized)
                    {
                        If (LEqual (WOLA, 0x00))
                        {
                            Store (0x00, Index (LPRW, 0x01))
                        }
                        Else
                        {
                            If (CondRefOf (\_S3, Local1))
                            {
                                Store (0x03, Index (LPRW, 0x01))
                            }
                            Else
                            {
                                Store (0x01, Index (LPRW, 0x01))
                            }
                        }

                        Return (LPRW)
                    }
                }

                Device (FSD0)
                {
                    Name (_ADR, 0x00050000)
                }

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

                Device (FCRD)
                {
                    Name (_ADR, 0x00040001)
                }

                Device (SMRD)
                {
                    Name (_ADR, 0x00040002)
                }

                Name (_PRT, Package (0x06)
                {
                    Package (0x04)
                    {
                        0x0002FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKE, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKB, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0004FFFF, 
                        0x01, 
                        \_SB.PCI0.LPCB.LNKC, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0005FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKG, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x00, 
                        \_SB.PCI0.LPCB.LNKD, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0001FFFF, 
                        0x01, 
                        \_SB.PCI0.LPCB.LNKF, 
                        0x00
                    }
                })
            }

            OperationRegion (REG0, PCI_Config, 0x90, 0x04)
            Field (REG0, DWordAcc, NoLock, Preserve)
            {
                    ,   3, 
                GSRM,   1, 
                DLCK,   1, 
                DCLS,   1, 
                DOPN,   1, 
                Offset (0x01)
            }

            Name (CRES, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinNotFixed, MaxNotFixed, PosDecode,
                    0x0000, /* Address Space Granularity */
                    0x0000, /* Address Range Minimum */
                    0x00FF, /* Address Range Maximum */
                    0x0000, /* Address Translation Offset */
                    0x0100)
                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, /* Address Space Granularity */
                    0x0000, /* Address Range Minimum */
                    0x0CF7, /* Address Range Maximum */
                    0x0000, /* Address Translation Offset */
                    0x0CF8)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000, /* Address Space Granularity */
                    0x0D00, /* Address Range Minimum */
                    0xFFFF, /* Address Range Maximum */
                    0x0000, /* Address Translation Offset */
                    0xF300)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, /* Address Space Granularity */
                    0x000A0000, /* Address Range Minimum */
                    0x000BFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0x00020000)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, /* Address Space Granularity */
                    0x000D0000, /* Address Range Minimum */
                    0x000DFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0x00010000)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, /* Address Space Granularity */
                    0x000C0000, /* Address Range Minimum */
                    0x000CFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0x00010000)
                DWordMemory (ResourceConsumer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly,
                    0x00000000, /* Address Space Granularity */
                    0xFFB80000, /* Address Range Minimum */
                    0xFFBFFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0x00080000)
                DWordMemory (ResourceConsumer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly,
                    0x00000000, /* Address Space Granularity */
                    0xFFF80000, /* Address Range Minimum */
                    0xFFFFFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0x00080000)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000, /* Address Space Granularity */
                    0x02000000, /* Address Range Minimum */
                    0xFEBFFFFF, /* Address Range Maximum */
                    0x00000000, /* Address Translation Offset */
                    0xFCE00000)
            })
            Method (_CRS, 0, NotSerialized)
            {
                CreateDWordField (CRES, 0xC4, RAMT)
                CreateDWordField (CRES, 0xD0, RAMR)
                Store (0x00100000, Local0)
                Multiply (ETHI, 0x00040000, Local1)
                Multiply (ETLO, 0x0400, Local2)
                Add (Local1, Local2, Local1)
                Multiply (Local1, 0x40, Local1)
                Multiply (DTHI, 0x00040000, Local3)
                Multiply (ETLO, 0x0400, Local4)
                Add (Local3, Local4, Local3)
                Add (Local1, Local3, Local1)
                Add (Local1, Local0, RAMT)
                Subtract (0xFEBFFFFF, RAMT, RAMR)
                Return (CRES)
            }

            Name (_PRT, Package (0x07)
            {
                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0001FFFF, 
                    0x01, 
                    \_SB.PCI0.LPCB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001FFFFF, 
                    0x01, 
                    \_SB.PCI0.LPCB.LNKB, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x00, 
                    \_SB.PCI0.LPCB.LNKA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x01, 
                    \_SB.PCI0.LPCB.LNKD, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x001DFFFF, 
                    0x03, 
                    \_SB.PCI0.LPCB.LNKH, 
                    0x00
                }
            })
            Device (USB0)
            {
                Name (_ADR, 0x001D0000)
                Name (_PRW, Package (0x02)
                {
                    0x03, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x03)
                }
            }

            Device (USB1)
            {
                Name (_ADR, 0x001D0001)
                Name (_PRW, Package (0x02)
                {
                    0x04, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x03)
                }
            }

            Device (USB3)
            {
                Name (_ADR, 0x001D0007)
                OperationRegion (BAR0, PCI_Config, 0x10, 0x04)
                Field (BAR0, DWordAcc, NoLock, Preserve)
                {
                    MBAR,   32
                }

                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
                Method (_S3D, 0, NotSerialized)
                {
                    Return (0x03)
                }
            }

            Device (AC97)
            {
                Name (_ADR, 0x001F0005)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (MC97)
            {
                Name (_ADR, 0x001F0006)
                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (IDEC)
            {
                Name (_ADR, 0x001F0001)
                OperationRegion (IDEC, PCI_Config, 0x40, 0x60)
                Field (IDEC, DWordAcc, NoLock, Preserve)
                {
                    PRIT,   16, 
                    SECT,   16, 
                    PSIT,   4, 
                    SSIT,   4, 
                    Offset (0x08), 
                    SYNC,   4, 
                    Offset (0x0A), 
                    SDT0,   2, 
                        ,   2, 
                    SDT1,   2, 
                    Offset (0x0B), 
                    SDT2,   2, 
                        ,   2, 
                    SDT3,   2, 
                    Offset (0x14), 
                    ICR0,   4, 
                    ICR1,   4, 
                    ICR2,   4, 
                    ICR3,   4, 
                    ICR4,   4, 
                    ICR5,   4
                }

                Device (PRID)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (PBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (PBUF, 0x00, PIO0)
                        CreateDWordField (PBUF, 0x04, DMA0)
                        CreateDWordField (PBUF, 0x08, PIO1)
                        CreateDWordField (PBUF, 0x0C, DMA1)
                        CreateDWordField (PBUF, 0x10, FLAG)
                        Store (GETP (PRIT), PIO0)
                        Store (GDMA (And (SYNC, 0x01), And (ICR3, 0x01), And (ICR0, 0x01), SDT0, And (ICR1, 0x01)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (PRIT, 0x4000))
                        {
                            If (LEqual (And (PRIT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (PSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x02), And (ICR3, 0x02), And (ICR0, 0x02), SDT1, And (ICR1, 0x02)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x01), And (SYNC, 0x02), PRIT), FLAG)
                        Return (PBUF)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (PRIT, 0x40F0, PRIT)
                            And (SYNC, 0x0E, SYNC)
                            Store (0x00, SDT0)
                            And (ICR0, 0x0E, ICR0)
                            And (ICR1, 0x0E, ICR1)
                            And (ICR3, 0x0E, ICR3)
                            And (ICR5, 0x0E, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (PRIT, 0x8004, PRIT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (PRIT, 0x02, PRIT)
                            }

                            Or (PRIT, SETP (PIO0, W530, W640), PRIT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x01, SYNC)
                                Store (SDMA (DMA0), SDT0)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x01, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x01, ICR0)
                                }

                                Or (ICR1, 0x01, ICR1)
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (PRIT, 0x3F0F, PRIT)
                            Store (0x00, PSIT)
                            And (SYNC, 0x0D, SYNC)
                            Store (0x00, SDT1)
                            And (ICR0, 0x0D, ICR0)
                            And (ICR1, 0x0D, ICR1)
                            And (ICR3, 0x0D, ICR3)
                            And (ICR5, 0x0D, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (PRIT, 0x8040, PRIT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (PRIT, 0x20, PRIT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (PRIT, 0x4000, PRIT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (PRIT, 0x80, PRIT)
                                }
                                Else
                                {
                                    Or (PRIT, 0x10, PRIT)
                                    Store (SETT (PIO1, W531, W641), PSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x02, SYNC)
                                Store (SDMA (DMA1), SDT1)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x02, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x02, ICR0)
                                }

                                Or (ICR1, 0x02, ICR1)
                            }
                        }
                    }

                    Device (P_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (PIB0, 0x01, PMD0)
                            CreateByteField (PIB0, 0x08, DMD0)
                            If (And (PRIT, 0x02))
                            {
                                If (LEqual (And (PRIT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (PRIT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (PRIT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x01))
                            {
                                Store (Or (SDT0, 0x40), DMD0)
                                If (And (ICR1, 0x01))
                                {
                                    If (And (ICR0, 0x01))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x01))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (PIB0)
                        }
                    }

                    Device (P_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (PIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (PIB1, 0x01, PMD1)
                            CreateByteField (PIB1, 0x08, DMD1)
                            If (And (PRIT, 0x20))
                            {
                                If (LEqual (And (PRIT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (PSIT, 0x03), ShiftRight (And (PSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SYNC, 0x02))
                            {
                                Store (Or (SDT1, 0x40), DMD1)
                                If (And (ICR1, 0x02))
                                {
                                    If (And (ICR0, 0x02))
                                    {
                                        Add (DMD1, 0x02, DMD1)
                                    }

                                    If (And (ICR3, 0x02))
                                    {
                                        Store (0x45, DMD1)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (PIB1)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }
                }

                Device (SECD)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Name (SBUF, Buffer (0x14)
                        {
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                            0x00, 0x00, 0x00, 0x00
                        })
                        CreateDWordField (SBUF, 0x00, PIO0)
                        CreateDWordField (SBUF, 0x04, DMA0)
                        CreateDWordField (SBUF, 0x08, PIO1)
                        CreateDWordField (SBUF, 0x0C, DMA1)
                        CreateDWordField (SBUF, 0x10, FLAG)
                        Store (GETP (SECT), PIO0)
                        Store (GDMA (And (SYNC, 0x04), And (ICR3, 0x04), And (ICR0, 0x04), SDT2, And (ICR1, 0x04)), DMA0)
                        If (LEqual (DMA0, 0xFFFFFFFF))
                        {
                            Store (PIO0, DMA0)
                        }

                        If (And (SECT, 0x4000))
                        {
                            If (LEqual (And (SECT, 0x90), 0x80))
                            {
                                Store (0x0384, PIO1)
                            }
                            Else
                            {
                                Store (GETT (SSIT), PIO1)
                            }
                        }
                        Else
                        {
                            Store (0xFFFFFFFF, PIO1)
                        }

                        Store (GDMA (And (SYNC, 0x08), And (ICR3, 0x08), And (ICR0, 0x08), SDT3, And (ICR1, 0x08)), DMA1)
                        If (LEqual (DMA1, 0xFFFFFFFF))
                        {
                            Store (PIO1, DMA1)
                        }

                        Store (GETF (And (SYNC, 0x04), And (SYNC, 0x08), SECT), FLAG)
                        Return (SBUF)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        CreateDWordField (Arg0, 0x00, PIO0)
                        CreateDWordField (Arg0, 0x04, DMA0)
                        CreateDWordField (Arg0, 0x08, PIO1)
                        CreateDWordField (Arg0, 0x0C, DMA1)
                        CreateDWordField (Arg0, 0x10, FLAG)
                        Store (0x04, ICR2)
                        If (LEqual (SizeOf (Arg1), 0x0200))
                        {
                            And (SECT, 0x40F0, SECT)
                            And (SYNC, 0x0B, SYNC)
                            Store (0x00, SDT2)
                            And (ICR0, 0x0B, ICR0)
                            And (ICR1, 0x0B, ICR1)
                            And (ICR3, 0x0B, ICR3)
                            And (ICR5, 0x0B, ICR5)
                            CreateWordField (Arg1, 0x62, W490)
                            CreateWordField (Arg1, 0x6A, W530)
                            CreateWordField (Arg1, 0x7E, W630)
                            CreateWordField (Arg1, 0x80, W640)
                            CreateWordField (Arg1, 0xB0, W880)
                            CreateWordField (Arg1, 0xBA, W930)
                            Or (SECT, 0x8004, SECT)
                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
                            {
                                Or (SECT, 0x02, SECT)
                            }

                            Or (SECT, SETP (PIO0, W530, W640), SECT)
                            If (And (FLAG, 0x01))
                            {
                                Or (SYNC, 0x04, SYNC)
                                Store (SDMA (DMA0), SDT2)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x04, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x04, ICR0)
                                }

                                Or (ICR1, 0x04, ICR1)
                            }
                        }

                        If (LEqual (SizeOf (Arg2), 0x0200))
                        {
                            And (SECT, 0x3F0F, SECT)
                            Store (0x00, SSIT)
                            And (SYNC, 0x07, SYNC)
                            Store (0x00, SDT3)
                            And (ICR0, 0x07, ICR0)
                            And (ICR1, 0x07, ICR1)
                            And (ICR3, 0x07, ICR3)
                            And (ICR5, 0x07, ICR5)
                            CreateWordField (Arg2, 0x62, W491)
                            CreateWordField (Arg2, 0x6A, W531)
                            CreateWordField (Arg2, 0x7E, W631)
                            CreateWordField (Arg2, 0x80, W641)
                            CreateWordField (Arg2, 0xB0, W881)
                            CreateWordField (Arg2, 0xBA, W931)
                            Or (SECT, 0x8040, SECT)
                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
                            {
                                Or (SECT, 0x20, SECT)
                            }

                            If (And (FLAG, 0x10))
                            {
                                Or (SECT, 0x4000, SECT)
                                If (LGreater (PIO1, 0xF0))
                                {
                                    Or (SECT, 0x80, SECT)
                                }
                                Else
                                {
                                    Or (SECT, 0x10, SECT)
                                    Store (SETT (PIO1, W531, W641), SSIT)
                                }
                            }

                            If (And (FLAG, 0x04))
                            {
                                Or (SYNC, 0x08, SYNC)
                                Store (SDMA (DMA1), SDT3)
                                If (LLess (DMA0, 0x1E))
                                {
                                    Or (ICR3, 0x08, ICR3)
                                }

                                If (LLess (DMA0, 0x3C))
                                {
                                    Or (ICR0, 0x08, ICR0)
                                }

                                Or (ICR1, 0x08, ICR1)
                            }
                        }
                    }

                    Device (S_D0)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (SIB0, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                            })
                            CreateByteField (SIB0, 0x01, PMD0)
                            CreateByteField (SIB0, 0x08, DMD0)
                            If (And (SECT, 0x02))
                            {
                                If (LEqual (And (SECT, 0x09), 0x08))
                                {
                                    Store (0x08, PMD0)
                                }
                                Else
                                {
                                    Store (0x0A, PMD0)
                                    ShiftRight (And (SECT, 0x0300), 0x08, Local0)
                                    ShiftRight (And (SECT, 0x3000), 0x0C, Local1)
                                    Add (Local0, Local1, Local2)
                                    If (LEqual (0x03, Local2))
                                    {
                                        Store (0x0B, PMD0)
                                    }

                                    If (LEqual (0x05, Local2))
                                    {
                                        Store (0x0C, PMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD0)
                            }

                            If (And (SYNC, 0x04))
                            {
                                Store (Or (SDT2, 0x40), DMD0)
                                If (And (ICR1, 0x04))
                                {
                                    If (And (ICR0, 0x04))
                                    {
                                        Add (DMD0, 0x02, DMD0)
                                    }

                                    If (And (ICR3, 0x04))
                                    {
                                        Store (0x45, DMD0)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD0, 0x07), 0x02), 0x20, DMD0)
                            }

                            Return (SIB0)
                        }
                    }

                    Device (S_D1)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Name (SIB1, Buffer (0x0E)
                            {
                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
                            })
                            CreateByteField (SIB1, 0x01, PMD1)
                            CreateByteField (SIB1, 0x08, DMD1)
                            If (And (SECT, 0x20))
                            {
                                If (LEqual (And (SECT, 0x90), 0x80))
                                {
                                    Store (0x08, PMD1)
                                }
                                Else
                                {
                                    Add (And (SSIT, 0x03), ShiftRight (And (SSIT, 0x0C), 0x02), Local0)
                                    If (LEqual (0x05, Local0))
                                    {
                                        Store (0x0C, PMD1)
                                    }
                                    Else
                                    {
                                        If (LEqual (0x03, Local0))
                                        {
                                            Store (0x0B, PMD1)
                                        }
                                        Else
                                        {
                                            Store (0x0A, PMD1)
                                        }
                                    }
                                }
                            }
                            Else
                            {
                                Store (0x01, PMD1)
                            }

                            If (And (SYNC, 0x08))
                            {
                                Store (Or (SDT3, 0x40), DMD1)
                                If (And (ICR1, 0x08))
                                {
                                    If (And (ICR0, 0x08))
                                    {
                                        Add (DMD1, 0x02, DMD1)
                                    }

                                    If (And (ICR3, 0x08))
                                    {
                                        Store (0x45, DMD1)
                                    }
                                }
                            }
                            Else
                            {
                                Or (Subtract (And (PMD1, 0x07), 0x02), 0x20, DMD1)
                            }

                            Return (SIB1)
                        }
                    }

                    Method (_PS0, 0, NotSerialized)
                    {
                    }

                    Method (_PS3, 0, NotSerialized)
                    {
                    }
                }

                Method (GETP, 1, NotSerialized)
                {
                    If (LEqual (And (Arg0, 0x09), 0x00))
                    {
                        Return (0xFFFFFFFF)
                    }

                    If (LEqual (And (Arg0, 0x09), 0x08))
                    {
                        Return (0x0384)
                    }

                    ShiftRight (And (Arg0, 0x0300), 0x08, Local0)
                    ShiftRight (And (Arg0, 0x3000), 0x0C, Local1)
                    Return (Multiply (0x1E, Subtract (0x09, Add (Local0, Local1))))
                }

                Method (GDMA, 5, NotSerialized)
                {
                    If (Arg0)
                    {
                        If (LAnd (Arg1, Arg4))
                        {
                            Return (0x14)
                        }

                        If (LAnd (Arg2, Arg4))
                        {
                            Return (Multiply (Subtract (0x04, Arg3), 0x0F))
                        }

                        Return (Multiply (Subtract (0x04, Arg3), 0x1E))
                    }

                    Return (0xFFFFFFFF)
                }

                Method (GETT, 1, NotSerialized)
                {
                    Return (Multiply (0x1E, Subtract (0x09, Add (And (ShiftRight (Arg0, 0x02), 0x03), And (Arg0, 0x03)))))
                }

                Method (GETF, 3, NotSerialized)
                {
                    Name (TMPF, 0x00)
                    If (Arg0)
                    {
                        Or (TMPF, 0x01, TMPF)
                    }

                    If (And (Arg2, 0x02))
                    {
                        Or (TMPF, 0x02, TMPF)
                    }

                    If (Arg1)
                    {
                        Or (TMPF, 0x04, TMPF)
                    }

                    If (And (Arg2, 0x20))
                    {
                        Or (TMPF, 0x08, TMPF)
                    }

                    If (And (Arg2, 0x4000))
                    {
                        Or (TMPF, 0x10, TMPF)
                    }

                    Return (TMPF)
                }

                Method (SETP, 3, NotSerialized)
                {
                    If (LGreater (Arg0, 0xF0))
                    {
                        Return (0x08)
                    }
                    Else
                    {
                        If (And (Arg1, 0x02))
                        {
                            If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                            {
                                Return (0x2301)
                            }

                            If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                            {
                                Return (0x2101)
                            }
                        }

                        Return (0x1001)
                    }
                }

                Method (SDMA, 1, NotSerialized)
                {
                    If (LNot (LGreater (Arg0, 0x14)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x1E)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x2D)))
                    {
                        Return (0x01)
                    }

                    If (LNot (LGreater (Arg0, 0x3C)))
                    {
                        Return (0x02)
                    }

                    If (LNot (LGreater (Arg0, 0x5A)))
                    {
                        Return (0x01)
                    }

                    Return (0x00)
                }

                Method (SETT, 3, NotSerialized)
                {
                    If (And (Arg1, 0x02))
                    {
                        If (LAnd (LNot (LGreater (Arg0, 0x78)), And (Arg2, 0x02)))
                        {
                            Return (0x0B)
                        }

                        If (LAnd (LNot (LGreater (Arg0, 0xB4)), And (Arg2, 0x01)))
                        {
                            Return (0x09)
                        }
                    }

                    Return (0x04)
                }
            }

            Device (SMBS)
            {
                Name (_ADR, 0x001F0003)
            }

            Device (LPCB)
            {
                Name (_ADR, 0x001F0000)
                OperationRegion (LPC0, PCI_Config, 0x60, 0x94)
                Field (LPC0, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8, 
                    Offset (0x08), 
                    PIRE,   8, 
                    PIRF,   8, 
                    PIRG,   8, 
                    PIRH,   8, 
                    Offset (0x80), 
                    CMDE,   8, 
                    FLDE,   8, 
                    SNDE,   8, 
                    Offset (0x84), 
                    GEN1,   16, 
                    LPEN,   16, 
                    Offset (0x8A), 
                    Offset (0x8C), 
                    GEN2,   16, 
                    Offset (0x92), 
                    FDIS,   16
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LINK-A STA", Debug)
                        If (LEqual (PIRA, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LINK-A DIS", Debug)
                        Store (0x80, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFA, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFA, 0x01, IRB1)
                        If (LNot (LEqual (PIRA, 0x80)))
                        {
                            ShiftLeft (One, PIRA, IRB1)
                        }

                        Store ("LINKA-CRS", Debug)
                        Return (BUFA)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRA)
                        Store ("LINKA-SRS", Debug)
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LINK-B STA", Debug)
                        If (LEqual (PIRB, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LINK-B DIS", Debug)
                        Store (0x80, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFB, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFB, 0x01, IRB1)
                        If (LNot (LEqual (PIRB, 0x80)))
                        {
                            ShiftLeft (One, PIRB, IRB1)
                        }

                        Store ("LINK-B-CRS", Debug)
                        Return (BUFB)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRB)
                        Store ("LINK-B-SRS", Debug)
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LINK-C-STA", Debug)
                        If (LEqual (PIRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LINK-C-DIS", Debug)
                        Store (0x80, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFC, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFC, 0x01, IRB1)
                        If (LNot (LEqual (PIRC, 0x80)))
                        {
                            ShiftLeft (One, PIRC, IRB1)
                        }

                        Store ("LINKC-CRS", Debug)
                        Return (BUFC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRC)
                        Store ("LINKC-SRS", Debug)
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LINK-D-STA", Debug)
                        If (LEqual (PIRD, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LINK-D-DIS", Debug)
                        Store (0x80, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFD, 0x01, IRB1)
                        If (LNot (LEqual (PIRD, 0x80)))
                        {
                            ShiftLeft (One, PIRD, IRB1)
                        }

                        Store ("LINK-D-CRS", Debug)
                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRD)
                        Sleep (0x0190)
                    }
                }

                Device (LNKE)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x05)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (PIRE, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x80, PIRE)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFD, 0x01, IRB1)
                        If (LNot (LEqual (PIRE, 0x80)))
                        {
                            ShiftLeft (One, PIRE, IRB1)
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRE)
                    }
                }

                Device (LNKF)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x06)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LINK-F-STA", Debug)
                        If (LEqual (PIRF, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x80, PIRF)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFD, 0x01, IRB1)
                        If (LNot (LEqual (PIRF, 0x80)))
                        {
                            ShiftLeft (One, PIRF, IRB1)
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRF)
                    }
                }

                Device (LNKG)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x07)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (PIRG, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x80, PIRG)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFD, 0x01, IRB1)
                        If (LNot (LEqual (PIRG, 0x80)))
                        {
                            ShiftLeft (One, PIRG, IRB1)
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRG)
                    }
                }

                Device (LNKH)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x08)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared) {3,4,5,10,11}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        If (LEqual (PIRH, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }

                    Method (_DIS, 0, NotSerialized)
                    {
                        Store (0x80, PIRH)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (BUFD, ResourceTemplate ()
                        {
                            IRQ (Level, ActiveLow, Shared) {}
                        })
                        CreateWordField (BUFD, 0x01, IRB1)
                        If (LNot (LEqual (PIRH, 0x80)))
                        {
                            ShiftLeft (One, PIRH, IRB1)
                        }

                        Return (BUFD)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRB1)
                        FindSetLeftBit (IRB1, Local0)
                        If (LGreater (Local0, 0x00))
                        {
                            Decrement (Local0)
                        }

                        Store (Local0, PIRH)
                        Sleep (0xC8)
                    }
                }

                Device (PS2M)
                {
                    Name (_HID, EisaId ("SYN0C05"))
                    Name (_CID, Package (0x02)
                    {
                        0x000C2E4F, 
                        0x130FD041
                    })
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags () {12}
                    })
                }

                Device (KBC)
                {
                    Method (_HID, 0, NotSerialized)
                    {
                        Return (ENID)
                    }

                    Method (_CID, 0, NotSerialized)
                    {
                        Return (ENID)
                    }

                    Name (ENID, 0x0303D041)
                    Name (JPID, 0x2003D041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
                        IRQNoFlags () {1}
                    })
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x08)
                        IRQNoFlags () {8}
                    })
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
                        IO (Decode16, 0x0050, 0x0050, 0x01, 0x04)
                        IRQNoFlags () {0}
                    })
                }

                Device (SPKR)
                {
                    Name (_HID, EisaId ("PNP0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
                    })
                }

                Device (MEM)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000)
                    })
                }

                Device (PIC)
                {
                    Name (_HID, EisaId ("PNP0000"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
                        IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
                        IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
                        IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
                        IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
                        IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
                        IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
                        IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
                        IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
                        IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
                        IO (Decode16, 0x00B2, 0x00B2, 0x01, 0x02)
                        IO (Decode16, 0x00B4, 0x00B4, 0x01, 0x02)
                        IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
                        IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
                        IO (Decode16, 0x03E0, 0x03E0, 0x01, 0x02)
                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
                        IRQNoFlags () {2}
                    })
                }

                Device (MAD)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x20)
                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
                        IO (Decode16, 0x0090, 0x0090, 0x01, 0x02)
                        IO (Decode16, 0x0093, 0x0093, 0x01, 0x0D)
                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
                        DMA (Compatibility, NotBusMaster, Transfer8_16) {4}
                    })
                }

                Device (PNP)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
                        IO (Decode16, 0x0680, 0x0680, 0x01, 0x80)
                        IO (Decode16, 0x0200, 0x0200, 0x01, 0x10)
                        IO (Decode16, 0x0290, 0x0297, 0x01, 0x08)
                        IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
                        IO (Decode16, 0x1300, 0x1300, 0x01, 0x40)
                        IO (Decode16, 0x077C, 0x077C, 0x01, 0x04)
                    })
                }

                Device (COPR)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x01)
                        IRQNoFlags () {13}
                    })
                }

                Device (FWH)
                {
                    Name (_HID, EisaId ("INT0800"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        Memory32Fixed (ReadOnly, 0xFFB80000, 0x00080000)
                        Memory32Fixed (ReadOnly, 0xFFB00000, 0x00080000)
                    })
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_GPE, 0x1C)
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    OperationRegion (RAM, EmbeddedControl, 0x00, 0x30)
                    Field (RAM, ByteAcc, NoLock, Preserve)
                    {
                        MODE,   1, 
                        FAN,    1, 
                        LIDS,   1, 
                        LSW0,   1, 
                        BTYP,   1, 
                        MWKE,   1, 
                        ADP,    1, 
                        BAT,    1, 
                        SLPT,   3, 
                        CHRG,   1, 
                        RI_W,   1, 
                        KB_W,   1, 
                        BATW,   1, 
                        PMEW,   1, 
                        BDC0,   16, 
                        BFC0,   16, 
                        BDV0,   16, 
                        BPR0,   16, 
                        BRC0,   16, 
                        BPV0,   16, 
                        BTP0,   16
                    }

                    Name (BEC0, ResourceTemplate ()
                    {
                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
                    })
                    Method (_CRS, 0, NotSerialized)
                    {
                        Store (0x01, REC)
                        Return (BEC0)
                    }

                    Method (_Q01, 0, NotSerialized)
                    {
                        If (\_SB.PCI0.LPCB.EC0.ADP)
                        {
                            Store (0x01, \_SB.AC.ACST)
                            Notify (\_SB.AC, 0x00)
                            Store (0x0B, APMD)
                            Store (0xE3, APMC)
                        }
                        Else
                        {
                            Store (0x00, \_SB.AC.ACST)
                            Store (0x0A, APMD)
                            Store (0xE3, APMC)
                            If (LEqual (OSFG, 0x04))
                            {
                                Notify (\_SB.AC, 0x80)
                            }
                            Else
                            {
                                Notify (\_SB.AC, 0x01)
                            }

                            Notify (\_SB.BAT0, 0x80)
                        }
                    }

                    Method (_Q02, 0, NotSerialized)
                    {
                        If (\_SB.PCI0.LPCB.EC0.BAT)
                        {
                            Notify (\_SB.BAT0, 0x00)
                            Notify (\_SB.AC, 0x80)
                        }
                        Else
                        {
                            Notify (\_SB.AC, 0x80)
                            Notify (\_SB.BAT0, 0x80)
                        }
                    }

                    Method (_Q05, 0, NotSerialized)
                    {
                        Notify (\_SB.SBTN, 0x80)
                    }

                    Method (_Q07, 0, NotSerialized)
                    {
                        Notify (\_SB.LID, 0x80)
                    }

                    Method (_Q0C, 0, NotSerialized)
                    {
                        Notify (\_SB.PCI0, 0x00)
                        Notify (\_SB.PCI0.GFX0, 0x80)
                    }
                }

                OperationRegion (N393, SystemIO, 0x2E, 0x02)
                Field (N393, ByteAcc, NoLock, Preserve)
                {
                    INDX,   8, 
                    DATA,   8
                }

                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x07), 
                    LDN,    8, 
                    Offset (0x20), 
                    SID,    8, 
                    SCF1,   8, 
                    SCF2,   8, 
                    SCF3,   8, 
                    SCF4,   8, 
                    SCF5,   8, 
                    SCF6,   8, 
                    SCF7,   8, 
                    SCF8,   8, 
                    SCF9,   8, 
                    SCFA,   8, 
                    SCFB,   8, 
                    SCFC,   8, 
                    SCFD,   8, 
                    SCFE,   8, 
                    SCFF,   8, 
                    LDC,    8, 
                    Offset (0x60), 
                    IOBH,   8, 
                    IOBL,   8, 
                    Offset (0x70), 
                    IRQN,   8, 
                    ITS,    8, 
                    Offset (0x74), 
                    DMA0,   8, 
                    DMA1,   8, 
                    Offset (0xF0), 
                        ,   1, 
                    PMC,    1, 
                        ,   3, 
                    PPMD,   3
                }
            }
        }

        Method (GSMI, 1, NotSerialized)
        {
            Store (Arg0, APMD)
            Store (0xE3, APMC)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
            Stall (0xFF)
        }
    }
}