[coreboot] Questions to ACPI, Interrupts, APICS (M57SLI)

Harald Gutmann harald.gutmann at gmx.net
Fri Mar 27 10:56:02 CET 2009


On Friday 27 March 2009 10:30:22 Rudolf Marek wrote:
> Hi,
>
> http://www.coreboot.org/ACPI_in_coreboot
> Check this.
I know that site, but that is ATM not the problem i'm going to address. (This 
will happen later on.)

The problem which actually exists on M57SLI is, that one PCI port and the 
PCI-16x port isn't working correctly.
Therefore it's necessary to fix the mptable.c file, so that those ports will be 
initialized correctly from coreboot.

Like Peter said, it should be possible to get the right values which are 
needed in the mptable.c out of the vendors DSDT file, but my problem is right 
now, that i don't know the ACPI specifications (DSDT parts) that good, to be 
able to find out which parts of the DSDT are relevant for fixing the PCI issues 
on M57SLI.

> All you need is to get the information for _PRT method routings. Then you
> can construct some minimalistic DSDT as I did for m2v-mx.
Good that you mention that again, maybe i shall look out for the _PRT symbols 
on the vendors DSDT, which i also attached.
Maybe you can give a look at that file, and give me a hint which parts are 
relevant to fix my problem.

> If you need help, just write/ask here.
>
> Rudolf
Thanks.


Kind regards
Harald
-------------- next part --------------
DefinitionBlock ("DSDT.aml", "DSDT", 1, "GBT   ", "NVDAACPI", 0x00001000)
{
    Name (\_S0, Package (0x04)
    {
        0x00, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S1, Package (0x04)
    {
        0x01, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S4, Package (0x04)
    {
        0x06, 
        0x00, 
        0x00, 
        0x00
    })
    Name (\_S5, Package (0x04)
    {
        0x07, 
        0x00, 
        0x00, 
        0x00
    })
    OperationRegion (\DEBG, SystemIO, 0x80, 0x01)
    Field (\DEBG, ByteAcc, NoLock, Preserve)
    {
        DBG1,   8
    }

    OperationRegion (KBC, SystemIO, 0x64, 0x01)
    Field (KBC, ByteAcc, NoLock, Preserve)
    {
        KCMD,   8
    }

    OperationRegion (KBCD, SystemIO, 0x60, 0x01)
    Field (KBCD, ByteAcc, NoLock, Preserve)
    {
        KDAT,   8
    }

    OperationRegion (AWYM, SystemMemory, 0x000FFFEA, 0x01)
    Field (AWYM, ByteAcc, NoLock, Preserve)
    {
            ,   1, 
            ,   1, 
        AWYE,   1, 
            ,   1, 
            ,   1, 
            ,   1, 
            ,   1, 
                Offset (0x01)
    }

    OperationRegion (EXTM, SystemMemory, 0x000FF830, 0x10)
    Field (EXTM, WordAcc, NoLock, Preserve)
    {
        ROM1,   16, 
        RMS1,   16, 
        ROM2,   16, 
        RMS2,   16, 
        ROM3,   16, 
        RMS3,   16, 
        AMEM,   32
    }

    OperationRegion (\PM1S, SystemIO, 0x1000, 0x02)
    Field (\PM1S, ByteAcc, NoLock, Preserve)
    {
                Offset (0x01), 
        PBTS,   1, 
            ,   1, 
        RTCS,   1, 
            ,   3, 
        PEWS,   1, 
        WAKS,   1
    }

    OperationRegion (\PM1E, SystemIO, 0x1002, 0x02)
    Field (\PM1E, ByteAcc, NoLock, Preserve)
    {
            ,   14, 
        PEWK,   1, 
                Offset (0x02)
    }

    OperationRegion (\APA4, SystemIO, 0x10A4, 0x04)
    Field (\APA4, ByteAcc, NoLock, Preserve)
    {
                Offset (0x02), 
        LCTM,   1, 
        LCNM,   1
    }

    OperationRegion (ELCR, SystemIO, 0x04D0, 0x02)
    Field (ELCR, ByteAcc, NoLock, Preserve)
    {
        ELC1,   8, 
        ELC2,   8
    }

    OperationRegion (\STUS, SystemIO, 0x1400, 0x04)
    Field (\STUS, ByteAcc, NoLock, Preserve)
    {
        G_ST,   32
    }

    OperationRegion (\GPS0, SystemIO, 0x1020, 0x04)
    Field (\GPS0, ByteAcc, NoLock, Preserve)
    {
        GS00,   8, 
        GS01,   8, 
        GS02,   8, 
        GS03,   8
    }

    OperationRegion (\SMIC, SystemIO, 0x142E, 0x01)
    Field (\SMIC, ByteAcc, NoLock, Preserve)
    {
        SCP,    8
    }

    OperationRegion (\GP1, SystemIO, 0x14C0, 0x32)
    Field (\GP1, ByteAcc, NoLock, Preserve)
    {
        GP00,   8, 
        GP01,   8, 
        GP02,   8, 
        GP03,   8, 
        GP04,   8, 
        GP05,   8, 
        GP06,   8, 
        GP07,   8, 
        GP08,   8, 
        GP09,   8, 
        GP10,   8, 
        GP11,   8, 
        GP12,   8, 
        GP13,   8, 
        GP14,   8, 
        GP15,   8, 
        GP16,   8, 
        GP17,   8, 
        GP18,   8, 
        GP19,   8, 
        GP20,   8, 
        GP21,   8, 
        GP22,   8, 
                Offset (0x18), 
        GP24,   8, 
        GP25,   8, 
        GP26,   8, 
        GP27,   8, 
        GP28,   8, 
        GP29,   8, 
        GP30,   8, 
        GP31,   8, 
        GP32,   8, 
        GP33,   8, 
        GP34,   8, 
        GP35,   8, 
        GP36,   8, 
        GP37,   8, 
        GP38,   8, 
        GP39,   8, 
        GT40,   8, 
        GP41,   8, 
        GP42,   8, 
        GP43,   8, 
        GP44,   8, 
        GP45,   8, 
        GP46,   8, 
        GP47,   8, 
        GP48,   8, 
        GP49,   8
    }

    Name (OSFX, 0x01)
    Name (OSFL, 0x01)
    Method (STRC, 2, NotSerialized)
    {
        If (LNotEqual (SizeOf (Arg0), SizeOf (Arg1)))
        {
            Return (0x00)
        }

        Add (SizeOf (Arg0), 0x01, Local0)
        Name (BUF0, Buffer (Local0) {})
        Name (BUF1, Buffer (Local0) {})
        Store (Arg0, BUF0)
        Store (Arg1, BUF1)
        While (Local0)
        {
            Decrement (Local0)
            If (LNotEqual (DerefOf (Index (BUF0, Local0)), DerefOf (Index (
                BUF1, Local0))))
            {
                Return (Zero)
            }
        }

        Return (One)
    }

    OperationRegion (INFO, SystemMemory, 0x000FF840, 0x02)
    Field (INFO, ByteAcc, NoLock, Preserve)
    {
        KBDI,   1, 
        RTCW,   1, 
        PS2F,   1, 
        IRFL,   2, 
        DISE,   1, 
        SSHU,   1
    }

    Scope (\)
    {
        Name (PICF, 0x00)
        Method (_PIC, 1, NotSerialized)
        {
            Store (Arg0, PICF)
        }
    }

    Name (SID4, 0x00)
    Name (SLG0, 0x00)
    Name (SLG1, 0x00)
    Name (SLG2, 0x00)
    Name (SLG3, 0x00)
    Name (SLG4, 0x00)
    Name (SLG5, 0x00)
    Name (SLG6, 0x00)
    Name (SLG7, 0x00)
    Name (SLG8, 0x00)
    Name (SLG9, 0x00)
    Name (SLGA, 0x00)
    Name (SID5, 0x00)
    Name (SSM0, 0x00)
    Name (SSM1, 0x00)
    Name (SSM2, 0x00)
    Name (SSM3, 0x00)
    Name (SSM4, 0x00)
    Name (SUA0, 0x00)
    Name (SUB0, 0x00)
    Name (SX, 0x00)
    Name (SFLG, 0x00)
    Name (SID0, 0x00)
    Name (SID1, 0x00)
    Name (SID2, 0x00)
    Name (SID3, 0x00)
    Method (\_PTS, 1, NotSerialized)
    {
        Store (Arg0, Local0)
        Store (Local0, SX)
        Or (Arg0, 0xF0, Local0)
        Store (Local0, DBG1)
        OSTP ()
        Store (\_SB.PCI0.IDE0.ID20, SID0)
        Store (\_SB.PCI0.IDE0.IDTS, SID1)
        Store (\_SB.PCI0.IDE0.IDTP, SID2)
        Store (\_SB.PCI0.IDE0.ID22, SID3)
        Store (\_SB.PCI0.IDE0.UMSS, SID4)
        Store (\_SB.PCI0.IDE0.UMSP, SID5)
        If (LEqual (Arg0, 0x01)) {}
        If (LEqual (Arg0, 0x03))
        {
            Store (0x00, LCTM)
            Store (0x00, LCNM)
        }

        If (LEqual (Arg0, 0x04)) {}
        If (LEqual (Arg0, 0x05))
        {
            If (LNotEqual (OSFL, 0x00))
            {
                Sleep (0x01F4)
            }
        }
    }

    Method (\_WAK, 1, NotSerialized)
    {
        Store (0xFF, DBG1)
        Store (0x00, SFLG)
        If (LEqual (RTCW, 0x00))
        {
            Notify (\_SB.PWRB, 0x02)
        }

        Notify (\_SB.PCI0.USB0, 0x00)
        If (LGreaterEqual (OSFL, 0x01))
        {
            Store (0x00, \_SB.PCI0.SMB0.SMPM)
        }
    }

    Scope (\_SI)
    {
        Method (_MSG, 1, NotSerialized)
        {
            Store ("==== MSG Working ====", Debug)
        }

        Method (_SST, 1, NotSerialized)
        {
            Store ("==== SST Working ====", Debug)
        }
    }

    Scope (\_GPE)
    {
        Method (_L11, 0, NotSerialized)
        {
            Store (0x02, GS02)
            If (LNotEqual (PEV0, 0xFFFF))
            {
                If (PES0)
                {
                    While (PES0)
                    {
                        Store (0x01, PES0)
                    }

                    Notify (\_SB.PCI0.XVR0, 0x02)
                }
            }

            If (LNotEqual (PEV1, 0xFFFF))
            {
                If (PES1)
                {
                    While (PES1)
                    {
                        Store (0x01, PES1)
                    }

                    Notify (\_SB.PCI0.XVR1, 0x02)
                }
            }

            If (LNotEqual (PEV2, 0xFFFF))
            {
                If (PES2)
                {
                    While (PES2)
                    {
                        Store (0x01, PES2)
                    }

                    Notify (\_SB.PCI0.XVR2, 0x02)
                }
            }

            If (LNotEqual (PEV3, 0xFFFF))
            {
                If (PES3)
                {
                    While (PES3)
                    {
                        Store (0x01, PES3)
                    }

                    Notify (\_SB.PCI0.XVR3, 0x02)
                }
            }

            If (LNotEqual (PEV4, 0xFFFF))
            {
                If (PES4)
                {
                    While (PES4)
                    {
                        Store (0x01, PES4)
                    }

                    Notify (\_SB.PCI0.XVR4, 0x02)
                }
            }

            If (LNotEqual (PEV5, 0xFFFF))
            {
                If (PES5)
                {
                    While (PES5)
                    {
                        Store (0x01, PES5)
                    }

                    Notify (\_SB.PCI0.XVR5, 0x02)
                }
            }
        }

        Method (_L00, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.HUB0, 0x02)
        }

        Method (_L03, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.UAR1, 0x02)
        }

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

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

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

        Method (_L15, 0, NotSerialized)
        {
            Notify (\_SB.PCI0.AZAD, 0x02)
        }
    }

    Scope (\_SB)
    {
        Device (\AWY)
        {
            Name (_HID, "AWY0001")
            Method (_STA, 0, NotSerialized)
            {
                If (AWYE)
                {
                    Return (0x0F)
                }

                Return (0x00)
            }

            Method (SMOD, 1, NotSerialized)
            {
            }
        }

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

        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A08"))
            Name (_CID, 0x030AD041)
            Name (_ADR, 0x00)
            Name (_UID, 0x01)
            Name (_BBN, 0x00)
            Name (PCIA, 0x00)
            Method (_REG, 2, NotSerialized)
            {
                If (LEqual (Arg0, 0x02))
                {
                    Store (Arg1, PCIA)
                }
            }

            OperationRegion (BRCR, PCI_Config, 0xEC, 0x04)
            Scope (\)
            {
                Field (\_SB.PCI0.BRCR, ByteAcc, NoLock, Preserve)
                {
                    GPUB,   32
                }
            }

            Device (MBIO)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x05)
                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x1000,             // Range Minimum
                            0x1000,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1080,             // Range Minimum
                            0x1080,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1400,             // Range Minimum
                            0x1400,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1480,             // Range Minimum
                            0x1480,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1800,             // Range Minimum
                            0x1800,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        IO (Decode16,
                            0x1880,             // Range Minimum
                            0x1880,             // Range Maximum
                            0x01,               // Alignment
                            0x80,               // Length
                            )
                        Memory32Fixed (ReadWrite,
                            0xA0000000,         // Address Base
                            0x00000000,         // Address Length
                            _Y00)
                    })
                    CreateDWordField (BUF0, \_SB.PCI0.MBIO._CRS._Y00._BAS, BRAB)
                    CreateDWordField (BUF0, \_SB.PCI0.MBIO._CRS._Y00._LEN, BRAL)
                    Store (GPUB, Local0)
                    And (Local0, 0xFFFF0000, Local0)
                    ShiftLeft (Local0, 0x08, Local0)
                    If (Local0)
                    {
                        Store (Local0, BRAB)
                        Store (0x10000000, BRAL)
                    }

                    Return (BUF0)
                }
            }

            Name (NATA, Package (0x01)
            {
                0x00040000
            })
            Method (SS3D, 0, NotSerialized)
            {
                If (LEqual (OSFL, 0x02))
                {
                    Return (0x02)
                }
                Else
                {
                    Return (0x03)
                }
            }

            Method (_STA, 0, NotSerialized)
            {
                Return (0x0F)
            }

            OperationRegion (LDT3, PCI_Config, 0x6C, 0x04)
            Field (LDT3, DWordAcc, NoLock, Preserve)
            {
                UCFG,   32
            }

            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    WordBusNumber (ResourceConsumer, MinNotFixed, MaxNotFixed, PosDecode,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x00FF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0100,             // Length
                        ,, )
                    IO (Decode16,
                        0x0CF8,             // Range Minimum
                        0x0CF8,             // Range Maximum
                        0x01,               // Alignment
                        0x08,               // Length
                        )
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0000,             // Range Minimum
                        0x0CF7,             // Range Maximum
                        0x0000,             // Translation Offset
                        0x0CF8,             // Length
                        ,, , TypeStatic)
                    WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                        0x0000,             // Granularity
                        0x0D00,             // Range Minimum
                        0xFFFF,             // Range Maximum
                        0x0000,             // Translation Offset
                        0xF300,             // 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
                        0x000DFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0x00020000,         // Length
                        ,, , AddressRangeMemory, TypeStatic)
                    DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                        0x00000000,         // Granularity
                        0x00100000,         // Range Minimum
                        0xFEBFFFFF,         // Range Maximum
                        0x00000000,         // Translation Offset
                        0xFFF00000,         // Length
                        ,, _Y01, AddressRangeMemory, TypeStatic)
                })
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y01._MIN, TCMM)
                CreateDWordField (BUF0, \_SB.PCI0._CRS._Y01._LEN, TOMM)
                Add (AMEM, 0x00010000, TCMM)
                Subtract (0xFEC00000, TCMM, TOMM)
                Return (BUF0)
            }

            Name (PICM, Package (0x23)
            {
                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    \_SB.PCI0.LSMB, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.LUBA, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x01, 
                    \_SB.PCI0.LUB2, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    \_SB.PCI0.LMAC, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x00, 
                    \_SB.PCI0.LP2P, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x01, 
                    \_SB.PCI0.LAZA, 
                    0x00
                }, 

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

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

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x01, 
                    \_SB.PCI0.LFID, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x02, 
                    \_SB.PCI0.LSA2, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.PCI0.LNK7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    \_SB.PCI0.LNK8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    \_SB.PCI0.LNK5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    \_SB.PCI0.LNK6, 
                    0x00
                }
            })
            Name (APIC, Package (0x23)
            {
                Package (0x04)
                {
                    0x0001FFFF, 
                    0x00, 
                    \_SB.PCI0.APCS, 
                    0x00
                }, 

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

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x00, 
                    \_SB.PCI0.APCF, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0002FFFF, 
                    0x01, 
                    \_SB.PCI0.APCL, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0008FFFF, 
                    0x00, 
                    \_SB.PCI0.APCH, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x00, 
                    \_SB.PCI0.APCM, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0006FFFF, 
                    0x01, 
                    \_SB.PCI0.AAZA, 
                    0x00
                }, 

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

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

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x01, 
                    \_SB.PCI0.APSJ, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x0005FFFF, 
                    0x02, 
                    \_SB.PCI0.ASA2, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x00, 
                    \_SB.PCI0.APC6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x01, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x02, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000FFFFF, 
                    0x03, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x00, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x01, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x02, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000EFFFF, 
                    0x03, 
                    \_SB.PCI0.APC6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x00, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x01, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x02, 
                    \_SB.PCI0.APC6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000DFFFF, 
                    0x03, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x01, 
                    \_SB.PCI0.APC6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x02, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x03, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x00, 
                    \_SB.PCI0.APC6, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x01, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x02, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000BFFFF, 
                    0x03, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x00, 
                    \_SB.PCI0.APC7, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x01, 
                    \_SB.PCI0.APC8, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x02, 
                    \_SB.PCI0.APC5, 
                    0x00
                }, 

                Package (0x04)
                {
                    0x000AFFFF, 
                    0x03, 
                    \_SB.PCI0.APC6, 
                    0x00
                }
            })
            Method (_PRT, 0, NotSerialized)
            {
                If (LNot (PICF))
                {
                    Return (PICM)
                }
                Else
                {
                    Return (APIC)
                }
            }

            Device (HUB0)
            {
                Name (_ADR, 0x00060000)
                Method (_STA, 0, NotSerialized)
                {
                    Return (0x0F)
                }

                Name (PICM, Package (0x14)
                {
                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x01, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x02, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x03, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x01, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x02, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x03, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x01, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x02, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x03, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x00, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x01, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x02, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x03, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x00, 
                        \_SB.PCI0.LNK3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x01, 
                        \_SB.PCI0.LNK4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x02, 
                        \_SB.PCI0.LNK1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x03, 
                        \_SB.PCI0.LNK2, 
                        0x00
                    }
                })
                Name (APIC, Package (0x14)
                {
                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x00, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x01, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x02, 
                        \_SB.PCI0.APC1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0006FFFF, 
                        0x03, 
                        \_SB.PCI0.APC2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x00, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x01, 
                        \_SB.PCI0.APC1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x02, 
                        \_SB.PCI0.APC2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0007FFFF, 
                        0x03, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x00, 
                        \_SB.PCI0.APC1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x01, 
                        \_SB.PCI0.APC2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x02, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0008FFFF, 
                        0x03, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x00, 
                        \_SB.PCI0.APC2, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x01, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x02, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x0009FFFF, 
                        0x03, 
                        \_SB.PCI0.APC1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x00, 
                        \_SB.PCI0.APC3, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x01, 
                        \_SB.PCI0.APC4, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x02, 
                        \_SB.PCI0.APC1, 
                        0x00
                    }, 

                    Package (0x04)
                    {
                        0x000AFFFF, 
                        0x03, 
                        \_SB.PCI0.APC2, 
                        0x00
                    }
                })
                Method (_PRT, 0, NotSerialized)
                {
                    If (LNot (PICF))
                    {
                        Return (PICM)
                    }
                    Else
                    {
                        Return (APIC)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x00, 
                    0x05
                })
            }

            Device (SAT1)
            {
                Name (_ADR, 0x00050000)
                Device (PRI0)
                {
                    Name (_ADR, 0x00)
                    Name (SPTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SPTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (0x90, SMIP)
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)
                    Name (SSTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SSTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SSTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (0x90, SMIP)
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Method (DRMP, 0, NotSerialized)
                {
                    Return (\_SB.PCI0.NVRB.R_S0)
                }
            }

            Device (SAT2)
            {
                Name (_ADR, 0x00050001)
                Device (PRI0)
                {
                    Name (_ADR, 0x00)
                    Name (SPTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SPTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (0x90, SMIP)
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)
                    Name (SSTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SSTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SSTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (0x90, SMIP)
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Method (DRMP, 0, NotSerialized)
                {
                    Return (\_SB.PCI0.NVRB.R_S1)
                }
            }

            Device (SAT3)
            {
                Name (_ADR, 0x00050002)
                Device (PRI0)
                {
                    Name (_ADR, 0x00)
                    Name (SPTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SPTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SPTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)
                    Name (SSTM, Buffer (0x14)
                    {
                        /* 0000 */    0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 
                        /* 0008 */    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
                        /* 0010 */    0x13, 0x00, 0x00, 0x00
                    })
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (SSTM)
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        Store (Arg0, SSTM)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Store (Buffer (0x07)
                                {
                                    0x03, 0x46, 0x00, 0x00, 0x00, 0xA0, 0xEF
                                }, Local0)
                            Return (Local0)
                        }
                    }
                }

                Method (DRMP, 0, NotSerialized)
                {
                    Return (\_SB.PCI0.NVRB.R_S2)
                }
            }

            Device (IDE0)
            {
                Name (_ADR, 0x00040000)
                OperationRegion (A090, PCI_Config, 0x50, 0x18)
                Field (A090, DWordAcc, NoLock, Preserve)
                {
                    ID20,   16, 
                            Offset (0x08), 
                    IDTS,   16, 
                    IDTP,   16, 
                    ID22,   32, 
                    UMSS,   16, 
                    UMSP,   16
                }

                Name (IDEP, Buffer (0x14) {})
                Name (IDES, Buffer (0x14) {})
                Method (GTM, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (IDTP, Local0)
                        Store (UMSP, Local1)
                        Store (IDEP, Local2)
                    }
                    Else
                    {
                        Store (IDTS, Local0)
                        Store (UMSS, Local1)
                        Store (IDES, Local2)
                    }

                    CreateDWordField (Local2, 0x00, PIO0)
                    CreateDWordField (Local2, 0x04, DMA0)
                    CreateDWordField (Local2, 0x08, PIO1)
                    CreateDWordField (Local2, 0x0C, DMA1)
                    CreateDWordField (Local2, 0x10, FLAG)
                    Store (0x10, FLAG)
                    And (Local0, 0x0F00, Local3)
                    And (Local0, 0xF000, Local4)
                    ShiftRight (Local3, 0x08, Local3)
                    ShiftRight (Local4, 0x0C, Local4)
                    Add (Local3, Local4, Local3)
                    Multiply (Add (Local3, 0x02), 0x1E, PIO0)
                    If (LLessEqual (PIO0, 0xB4))
                    {
                        Or (FLAG, 0x02, FLAG)
                    }

                    If (And (Local1, 0x4000))
                    {
                        Or (FLAG, 0x01, FLAG)
                        And (Local1, 0x0700, Local3)
                        ShiftRight (Local3, 0x08, Local3)
                        Store (U2T (Local3), DMA0)
                    }
                    Else
                    {
                        Store (PIO0, DMA0)
                    }

                    And (Local0, 0x0F, Local3)
                    And (Local0, 0xF0, Local4)
                    ShiftRight (Local4, 0x04, Local4)
                    Add (Local3, Local4, Local3)
                    Multiply (Add (Local3, 0x02), 0x1E, PIO1)
                    If (LLessEqual (PIO1, 0xB4))
                    {
                        Or (FLAG, 0x08, FLAG)
                    }

                    If (And (Local1, 0x40))
                    {
                        Or (FLAG, 0x04, FLAG)
                        And (Local1, 0x07, Local3)
                        Store (U2T (Local3), DMA1)
                    }
                    Else
                    {
                        Store (PIO1, DMA1)
                    }

                    If (LEqual (Arg0, 0x00))
                    {
                        Store (Local2, IDEP)
                        Return (IDEP)
                    }
                    Else
                    {
                        Store (Local2, IDES)
                        Return (IDES)
                    }
                }

                Method (U2T, 1, NotSerialized)
                {
                    If (LEqual (Arg0, 0x00))
                    {
                        Return (0x3C)
                    }

                    If (LEqual (Arg0, 0x01))
                    {
                        Return (0x49)
                    }

                    If (LEqual (Arg0, 0x02))
                    {
                        Return (0x78)
                    }

                    If (LEqual (Arg0, 0x03))
                    {
                        Return (0x96)
                    }

                    If (LEqual (Arg0, 0x04))
                    {
                        Return (0x2D)
                    }

                    If (LEqual (Arg0, 0x05))
                    {
                        Return (0x1E)
                    }

                    If (LEqual (Arg0, 0x06))
                    {
                        Return (0x14)
                    }

                    Return (0x0F)
                }

                Method (T2U, 1, NotSerialized)
                {
                    If (LGreater (Arg0, 0x78))
                    {
                        Return (0x03)
                    }

                    If (LGreater (Arg0, 0x49))
                    {
                        Return (0x02)
                    }

                    If (LGreater (Arg0, 0x3C))
                    {
                        Return (0x01)
                    }

                    If (LGreater (Arg0, 0x2D))
                    {
                        Return (0x00)
                    }

                    If (LGreater (Arg0, 0x1E))
                    {
                        Return (0x04)
                    }

                    If (LGreater (Arg0, 0x14))
                    {
                        Return (0x05)
                    }

                    If (LGreater (Arg0, 0x0F))
                    {
                        Return (0x06)
                    }

                    Return (0x07)
                }

                Method (T2D, 1, NotSerialized)
                {
                    If (LGreater (Arg0, 0x01E0))
                    {
                        Return (0xA8)
                    }

                    If (LGreater (Arg0, 0x0186))
                    {
                        Return (0x77)
                    }

                    If (LGreater (Arg0, 0xF0))
                    {
                        Return (0x47)
                    }

                    If (LGreater (Arg0, 0xB4))
                    {
                        Return (0x33)
                    }

                    If (LGreater (Arg0, 0x96))
                    {
                        Return (0x22)
                    }

                    If (LGreater (Arg0, 0x78))
                    {
                        Return (0x21)
                    }

                    Return (0x20)
                }

                Method (STM, 4, NotSerialized)
                {
                    If (SX)
                    {
                        Store (SID0, ID20)
                        Store (SID1, IDTS)
                        Store (SID2, IDTP)
                        Store (SID3, ID22)
                        Store (SID4, UMSS)
                        Store (SID5, UMSP)
                    }
                    Else
                    {
                        Store (ID20, SID0)
                        Store (IDTS, SID1)
                        Store (IDTP, SID2)
                        Store (ID22, SID3)
                        Store (UMSS, SID4)
                        Store (UMSP, SID5)
                    }

                    Store (0x00, SX)
                    CreateDWordField (Arg0, 0x00, PIO0)
                    CreateDWordField (Arg0, 0x04, DMA0)
                    CreateDWordField (Arg0, 0x08, PIO1)
                    CreateDWordField (Arg0, 0x0C, DMA1)
                    CreateDWordField (Arg0, 0x10, FLAG)
                    If (LEqual (Arg3, 0x00))
                    {
                        Store (SID2, Local0)
                        Store (SID5, Local1)
                    }
                    Else
                    {
                        Store (SID1, Local0)
                        Store (SID4, Local1)
                    }

                    If (LNotEqual (PIO0, 0xFFFFFFFF))
                    {
                        And (Local0, 0xFF, Local0)
                        ShiftLeft (T2D (PIO0), 0x08, Local2)
                        Or (Local0, Local2, Local0)
                    }

                    If (LNotEqual (PIO1, 0xFFFFFFFF))
                    {
                        And (Local0, 0xFF00, Local0)
                        Or (Local0, T2D (PIO1), Local0)
                    }

                    If (And (FLAG, 0x01))
                    {
                        And (Local1, 0xFF, Local1)
                        ShiftLeft (T2U (DMA0), 0x08, Local2)
                        Or (0xC000, Local2, Local2)
                        Or (Local2, Local1, Local1)
                    }
                    Else
                    {
                        If (LNotEqual (DMA0, 0xFFFFFFFF))
                        {
                            And (Local0, 0xFF, Local0)
                            ShiftLeft (T2D (DMA0), 0x08, Local2)
                            Or (Local0, Local2, Local0)
                        }
                    }

                    If (And (FLAG, 0x04))
                    {
                        And (Local1, 0xFF00, Local1)
                        Or (0xC0, T2U (DMA1), Local2)
                        Or (Local2, Local1, Local1)
                    }
                    Else
                    {
                        If (LNotEqual (DMA1, 0xFFFFFFFF))
                        {
                            And (Local0, 0xFF00, Local0)
                            Or (Local0, T2D (DMA1), Local0)
                        }
                    }

                    If (LEqual (Arg3, 0x00))
                    {
                        Store (Local0, IDTP)
                        Store (Local1, UMSP)
                    }
                    Else
                    {
                        Store (Local0, IDTS)
                        Store (Local1, UMSS)
                    }
                }

                Method (GTF, 2, NotSerialized)
                {
                    Store (Buffer (0x07)
                        {
                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
                        }, Local0)
                    CreateByteField (Local0, 0x01, MODE)
                    CreateByteField (Local0, 0x05, DRIV)
                    Store (Arg1, DRIV)
                    If (LEqual (Arg0, 0x00))
                    {
                        Store (IDEP, Local1)
                    }
                    Else
                    {
                        Store (IDES, Local1)
                    }

                    CreateDWordField (Local1, 0x00, PIO0)
                    CreateDWordField (Local1, 0x04, DMA0)
                    CreateDWordField (Local1, 0x08, PIO1)
                    CreateDWordField (Local1, 0x0C, DMA1)
                    CreateDWordField (Local1, 0x10, FLGX)
                    If (LEqual (Arg1, 0xA0))
                    {
                        Store (PIO0, Local2)
                        Store (DMA0, Local3)
                        And (FLGX, 0x01, FLGX)
                    }
                    Else
                    {
                        Store (PIO1, Local2)
                        Store (DMA1, Local3)
                        And (FLGX, 0x04, FLGX)
                    }

                    Store (FLGX, Local1)
                    If (LGreater (Local2, 0x0186))
                    {
                        Store (0x00, Local2)
                    }
                    Else
                    {
                        If (LGreater (Local2, 0xF0))
                        {
                            Store (0x01, Local2)
                        }
                        Else
                        {
                            If (LGreater (Local2, 0xB4))
                            {
                                Store (0x02, Local2)
                            }
                            Else
                            {
                                If (LGreater (Local2, 0x78))
                                {
                                    Store (0x03, Local2)
                                }
                                Else
                                {
                                    Store (0x04, Local2)
                                }
                            }
                        }
                    }

                    Or (0x08, Local2, MODE)
                    Store (Local0, Local2)
                    If (FLGX)
                    {
                        If (LGreater (Local3, 0x49))
                        {
                            Store (0x00, Local3)
                        }
                        Else
                        {
                            If (LGreater (Local3, 0x3C))
                            {
                                Store (0x01, Local3)
                            }
                            Else
                            {
                                If (LGreater (Local3, 0x2D))
                                {
                                    Store (0x02, Local3)
                                }
                                Else
                                {
                                    If (LGreater (Local3, 0x1E))
                                    {
                                        Store (0x03, Local3)
                                    }
                                    Else
                                    {
                                        If (LGreater (Local3, 0x14))
                                        {
                                            Store (0x04, Local3)
                                        }
                                        Else
                                        {
                                            If (LGreater (Local3, 0x0F))
                                            {
                                                Store (0x05, Local3)
                                            }
                                            Else
                                            {
                                                Store (0x06, Local3)
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        Or (0x40, Local3, MODE)
                    }
                    Else
                    {
                        If (LEqual (Local3, 0xFFFFFFFF))
                        {
                            Return (Local0)
                        }
                        Else
                        {
                            If (LGreater (Local3, 0x96))
                            {
                                Store (0x00, Local3)
                            }
                            Else
                            {
                                If (LGreater (Local3, 0x78))
                                {
                                    Store (0x01, Local3)
                                }
                                Else
                                {
                                    Store (0x02, Local3)
                                }
                            }

                            Or (0x20, Local3, MODE)
                        }
                    }

                    Concatenate (Local0, Local2, Local1)
                    Return (Local1)
                }

                Device (PRI0)
                {
                    Name (_ADR, 0x00)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (0x00))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        STM (Arg0, Arg1, Arg2, 0x00)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x00, 0xA0))
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x00, 0xB0))
                        }
                    }
                }

                Device (SEC0)
                {
                    Name (_ADR, 0x01)
                    Method (_GTM, 0, NotSerialized)
                    {
                        Return (GTM (0x01))
                    }

                    Method (_STM, 3, NotSerialized)
                    {
                        STM (Arg0, Arg1, Arg2, 0x01)
                    }

                    Device (MAST)
                    {
                        Name (_ADR, 0x00)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x01, 0xA0))
                        }
                    }

                    Device (SLAV)
                    {
                        Name (_ADR, 0x01)
                        Method (_GTF, 0, NotSerialized)
                        {
                            Return (GTF (0x01, 0xB0))
                        }
                    }
                }

                Method (DRMP, 0, NotSerialized)
                {
                    Return (\_SB.PCI0.NVRB.R_P0)
                }
            }

            Device (XVR0)
            {
                Name (_ADR, 0x000F0000)
                OperationRegion (PCV0, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR0.PCV0, ByteAcc, NoLock, Preserve)
                    {
                        PEV0,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE0,   1, 
                                Offset (0xA0), 
                        RQD0,   16, 
                        PES0,   1, 
                        PEP0,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR1)
            {
                Name (_ADR, 0x000E0000)
                OperationRegion (PCV1, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR1.PCV1, ByteAcc, NoLock, Preserve)
                    {
                        PEV1,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE1,   1, 
                                Offset (0xA0), 
                        RQD1,   16, 
                        PES1,   1, 
                        PEP1,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR2)
            {
                Name (_ADR, 0x000D0000)
                OperationRegion (PCV2, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR2.PCV2, ByteAcc, NoLock, Preserve)
                    {
                        PEV2,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE2,   1, 
                                Offset (0xA0), 
                        RQD2,   16, 
                        PES2,   1, 
                        PEP2,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR3)
            {
                Name (_ADR, 0x000C0000)
                OperationRegion (PCV3, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR3.PCV3, ByteAcc, NoLock, Preserve)
                    {
                        PEV3,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE3,   1, 
                                Offset (0xA0), 
                        RQD3,   16, 
                        PES3,   1, 
                        PEP3,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR4)
            {
                Name (_ADR, 0x000B0000)
                OperationRegion (PCV4, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR4.PCV4, ByteAcc, NoLock, Preserve)
                    {
                        PEV4,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE4,   1, 
                                Offset (0xA0), 
                        RQD4,   16, 
                        PES4,   1, 
                        PEP4,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (XVR5)
            {
                Name (_ADR, 0x000A0000)
                OperationRegion (PCV5, PCI_Config, 0x00, 0xFF)
                Scope (\)
                {
                    Field (\_SB.PCI0.XVR5.PCV5, ByteAcc, NoLock, Preserve)
                    {
                        PEV5,   16, 
                                Offset (0x9C), 
                            ,   3, 
                        XPE5,   1, 
                                Offset (0xA0), 
                        RQD5,   16, 
                        PES5,   1, 
                        PEP5,   1
                    }
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x00, PEWK)
                    }
                    Else
                    {
                        Store (0x01, PEWK)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x11, 
                    0x05
                })
            }

            Device (SMB0)
            {
                Name (_ADR, 0x00010001)
                OperationRegion (SMCF, PCI_Config, 0x48, 0x10)
                Field (SMCF, DWordAcc, NoLock, Preserve)
                {
                    SMPM,   4, 
                    SMT1,   28, 
                    SMT2,   32
                }

                OperationRegion (SMCA, PCI_Config, 0x20, 0x08)
                Field (SMCA, DWordAcc, NoLock, Preserve)
                {
                    SB1,    32, 
                    SB2,    32
                }

                Method (SMBB, 0, NotSerialized)
                {
                    If (PCIA)
                    {
                        And (SB1, 0xFFFE, Local0)
                    }
                    Else
                    {
                        Store (0x1C00, Local0)
                    }

                    Return (Local0)
                }
            }

            Device (LEG0)
            {
                Name (_ADR, 0x00010000)
                OperationRegion (PIO0, PCI_Config, 0x04, 0x20)
                Scope (\)
                {
                    Field (\_SB.PCI0.LEG0.PIO0, ByteAcc, NoLock, Preserve)
                    {
                        SMEN,   8, 
                                Offset (0x0C), 
                                Offset (0x0D), 
                        SMIO,   8
                    }
                }

                OperationRegion (PIRQ, PCI_Config, 0x7C, 0x0C)
                Scope (\)
                {
                    Field (\_SB.PCI0.LEG0.PIRQ, AnyAcc, NoLock, Preserve)
                    {
                        INTA,   4, 
                        INTB,   4, 
                        INTC,   4, 
                        INTD,   4, 
                        PCEA,   4, 
                        PCEB,   4, 
                        PCEC,   4, 
                        PCED,   4, 
                        SCII,   4, 
                        TCOI,   4, 
                        INTF,   4, 
                        INTQ,   4, 
                        INTU,   4, 
                        INTS,   4, 
                        IS0P,   4, 
                        ITID,   4, 
                        INTG,   4, 
                        INTH,   4, 
                        INTJ,   4, 
                        INTK,   4, 
                        INTL,   4, 
                        INTM,   4, 
                        INTN,   4, 
                        ISA2,   4
                    }
                }

                OperationRegion (HPF0, PCI_Config, 0x74, 0x01)
                Scope (\)
                {
                    Field (\_SB.PCI0.LEG0.HPF0, ByteAcc, NoLock, Preserve)
                    {
                            ,   2, 
                        HPTF,   1, 
                                Offset (0x01)
                    }
                }

                OperationRegion (LPIO, PCI_Config, 0xA0, 0x18)
                Scope (\)
                {
                    Field (\_SB.PCI0.LEG0.LPIO, ByteAcc, NoLock, Preserve)
                    {
                        UAIO,   8, 
                        SNDD,   4, 
                        MIDD,   4, 
                        MSSD,   4, 
                        FDCD,   2, 
                                Offset (0x03), 
                        PRIO,   3, 
                            ,   1, 
                        GEN1,   1, 
                        GEN2,   1, 
                        GEN3,   1, 
                        GEN4,   1, 
                        GAM1,   8, 
                        GAM2,   8
                    }

                    OperationRegion (RTC2, SystemIO, 0x72, 0x02)
                    Field (RTC2, ByteAcc, NoLock, Preserve)
                    {
                        CM2I,   8, 
                        CM2D,   8
                    }

                    IndexField (CM2I, CM2D, ByteAcc, NoLock, Preserve)
                    {
                                Offset (0xCC), 
                        UA1D,   8
                    }

                    Name (UARA, 0x00)
                    Name (UARB, 0x00)
                    Method (DISD, 1, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x00))
                        {
                            Store (UARA, Local0)
                            XOr (Local0, 0xFF, Local0)
                            And (UAIO, Local0, UAIO)
                        }

                        If (LEqual (Arg0, 0x01))
                        {
                            Store (UARB, Local0)
                            XOr (Local0, 0xFF, Local0)
                            And (UAIO, Local0, UAIO)
                        }

                        If (LEqual (Arg0, 0x02))
                        {
                            Store (0x00, PRIO)
                        }

                        If (LEqual (Arg0, 0x03))
                        {
                            Store (0x00, FDCD)
                        }

                        If (LEqual (Arg0, 0x04))
                        {
                            Store (0x00, GAM1)
                            Store (0x00, GAM2)
                        }

                        If (LEqual (Arg0, 0x05))
                        {
                            Store (0x00, MIDD)
                        }
                    }

                    Method (CKIO, 2, NotSerialized)
                    {
                        If (LEqual (Arg1, 0x00))
                        {
                            Or (UARA, UARB, Local0)
                            And (UAIO, Local0, UAIO)
                            Store (UARA, Local0)
                            XOr (Local0, 0xFF, Local0)
                            And (UAIO, Local0, UAIO)
                            If (LEqual (Arg0, 0x03F8))
                            {
                                Store (0x01, Local0)
                            }

                            If (LEqual (Arg0, 0x02F8))
                            {
                                Store (0x02, Local0)
                            }

                            If (LEqual (Arg0, 0x02E8))
                            {
                                Store (0x20, Local0)
                            }

                            If (LEqual (Arg0, 0x03E8))
                            {
                                Store (0x80, Local0)
                            }

                            Or (UAIO, Local0, UAIO)
                            Store (Local0, UARA)
                        }

                        If (LEqual (Arg1, 0x01))
                        {
                            Or (UARA, UARB, Local0)
                            And (UAIO, Local0, UAIO)
                            Store (UARB, Local0)
                            XOr (Local0, 0xFF, Local0)
                            And (UAIO, Local0, UAIO)
                            If (LEqual (Arg0, 0x03F8))
                            {
                                Store (0x01, Local0)
                            }

                            If (LEqual (Arg0, 0x02F8))
                            {
                                Store (0x02, Local0)
                            }

                            If (LEqual (Arg0, 0x02E8))
                            {
                                Store (0x20, Local0)
                            }

                            If (LEqual (Arg0, 0x03E8))
                            {
                                Store (0x80, Local0)
                            }

                            Or (UAIO, Local0, UAIO)
                            Store (Local0, UARB)
                        }

                        If (LEqual (Arg1, 0x02))
                        {
                            If (LEqual (Arg0, 0x0378))
                            {
                                Store (0x00, PRIO)
                                Or (PRIO, 0x01, PRIO)
                            }

                            If (LEqual (Arg0, 0x0278))
                            {
                                Store (0x00, PRIO)
                                Or (PRIO, 0x02, PRIO)
                            }

                            If (LEqual (Arg0, 0x03BC))
                            {
                                Store (0x00, PRIO)
                                Or (PRIO, 0x04, PRIO)
                            }
                        }

                        If (LEqual (Arg1, 0x03))
                        {
                            Or (FDCD, 0x01, FDCD)
                        }

                        If (LEqual (Arg1, 0x04))
                        {
                            Store (0x00, GAM1)
                            Store (0x00, GAM2)
                            If (LEqual (Arg0, 0x0201))
                            {
                                Or (GAM1, 0x02, GAM1)
                            }

                            If (LEqual (Arg0, 0x0209))
                            {
                                Or (GAM2, 0x02, GAM2)
                            }
                        }

                        If (LEqual (Arg1, 0x05))
                        {
                            Store (0x00, MIDD)
                            If (LEqual (Arg0, 0x0300))
                            {
                                Or (MIDD, 0x01, MIDD)
                            }

                            If (LEqual (Arg0, 0x0330))
                            {
                                Or (MIDD, 0x08, MIDD)
                            }
                        }
                    }

                    Method (SLDM, 2, NotSerialized)
                    {
                    }

                    Method (CLSU, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x02, UARO)
                        If (LEqual (UARO, 0x03F8))
                        {
                            And (UAIO, 0xFE, UAIO)
                        }

                        If (LEqual (UARO, 0x02F8))
                        {
                            And (UAIO, 0xFD, UAIO)
                        }

                        If (LEqual (UARO, 0x02E8))
                        {
                            And (UAIO, 0xBF, UAIO)
                        }

                        If (LEqual (UARO, 0x03E8))
                        {
                            And (UAIO, 0x7F, UAIO)
                        }
                    }
                }
            }

            Device (USB0)
            {
                Name (_ADR, 0x00020000)
                Method (_S1D, 0, NotSerialized)
                {
                    Return (0x01)
                }

                Method (SS3D, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x02))
                    {
                        Return (0x02)
                    }
                    Else
                    {
                        Return (0x03)
                    }
                }

                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x03
                })
            }

            Device (USB2)
            {
                Name (_ADR, 0x00020001)
                OperationRegion (P020, PCI_Config, 0x49, 0x01)
                Field (P020, AnyAcc, NoLock, Preserve)
                {
                    U0WK,   1
                }

                Method (_PSW, 1, NotSerialized)
                {
                    If (Arg0)
                    {
                        Store (0x01, U0WK)
                    }
                    Else
                    {
                        Store (0x00, U0WK)
                    }
                }

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

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

                Name (_PRW, Package (0x02)
                {
                    0x05, 
                    0x03
                })
            }

            Device (AZAD)
            {
                Name (_ADR, 0x00060001)
                Name (_PRW, Package (0x02)
                {
                    0x15, 
                    0x05
                })
            }

            Device (MMAC)
            {
                Name (_ADR, 0x00080000)
                Name (_PRW, Package (0x02)
                {
                    0x0B, 
                    0x05
                })
            }

            Device (NVRB)
            {
                Name (_HID, "NVRAIDBUS")
                OperationRegion (NVRD, SystemMemory, 0x000FFF38, 0x03)
                Field (NVRD, ByteAcc, NoLock, Preserve)
                {
                    R_ST,   1, 
                        ,   3, 
                    R_P0,   4, 
                    R_S0,   4, 
                    R_S1,   4, 
                    R_S2,   4
                }

                Name (FNVR, 0xFF)
                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, FNVR)
                }

                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (R_ST, 0x01))
                    {
                        If (LEqual (FNVR, 0xFF))
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x0D)
                        }
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x04D2,             // Range Minimum
                        0x04D2,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
            }

            Name (BUFA, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, )
                    {5,7,9,10,11,14,15}
            })
            Name (BUFB, ResourceTemplate ()
            {
                IRQ (Level, ActiveLow, Shared, _Y02)
                    {}
            })
            CreateWordField (BUFB, \_SB.PCI0._Y02._INT, IRQV)
            Method (CRS, 1, NotSerialized)
            {
                If (Arg0)
                {
                    ShiftLeft (0x01, Arg0, IRQV)
                }
                Else
                {
                    Store (Zero, IRQV)
                }

                Return (BUFB)
            }

            Method (SRS, 1, NotSerialized)
            {
                CreateWordField (Arg0, 0x01, IRQ0)
                FindSetRightBit (IRQ0, Local0)
                Decrement (Local0)
                Return (Local0)
            }

            Method (CRSA, 1, Serialized)
            {
                Store (Arg0, Local0)
                If (LEqual (Arg0, 0x01))
                {
                    Store (0x17, Local0)
                }

                If (LEqual (Arg0, 0x02))
                {
                    Store (0x16, Local0)
                }

                If (LEqual (Arg0, 0x03))
                {
                    Store (0x10, Local0)
                }

                If (LEqual (Arg0, 0x04))
                {
                    Store (0x11, Local0)
                }

                If (LEqual (Arg0, 0x06))
                {
                    Store (0x12, Local0)
                }

                If (LEqual (Arg0, 0x08))
                {
                    Store (0x14, Local0)
                }

                If (LEqual (Arg0, 0x0C))
                {
                    Store (0x13, Local0)
                }

                If (LEqual (Arg0, 0x0D))
                {
                    Store (0x15, Local0)
                }

                Name (IRZ5, ResourceTemplate ()
                {
                    Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, _Y03)
                    {
                        0x00000007,
                    }
                })
                CreateWordField (IRZ5, \_SB.PCI0.CRSA._Y03._INT, INZ5)
                Store (Local0, INZ5)
                Return (IRZ5)
            }

            Method (SRSA, 1, Serialized)
            {
                CreateWordField (Arg0, 0x05, INZ6)
                Store (0x08, Local0)
                If (LEqual (INZ6, 0x10))
                {
                    Store (0x03, Local0)
                }

                If (LEqual (INZ6, 0x11))
                {
                    Store (0x04, Local0)
                }

                If (LEqual (INZ6, 0x12))
                {
                    Store (0x06, Local0)
                }

                If (LEqual (INZ6, 0x13))
                {
                    Store (0x0C, Local0)
                }

                If (LEqual (INZ6, 0x14))
                {
                    Store (0x08, Local0)
                }

                If (LEqual (INZ6, 0x15))
                {
                    Store (0x0D, Local0)
                }

                If (LEqual (INZ6, 0x16))
                {
                    Store (0x02, Local0)
                }

                If (LEqual (INZ6, 0x17))
                {
                    Store (0x01, Local0)
                }

                Return (Local0)
            }

            Device (LNK1)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTA)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTA))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTA)
                }
            }

            Device (LNK2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x02)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTB)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTB)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTB))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTB)
                }
            }

            Device (LNK3)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTC)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTC))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTC)
                }
            }

            Device (LNK4)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x04)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTD)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTD)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTD))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTD)
                }
            }

            Device (LNK5)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x05)
                Method (_STA, 0, NotSerialized)
                {
                    If (PCEA)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (PCEA))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), PCEA)
                }
            }

            Device (LNK6)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x06)
                Method (_STA, 0, NotSerialized)
                {
                    If (PCEB)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEB)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (PCEB))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), PCEB)
                }
            }

            Device (LNK7)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x07)
                Method (_STA, 0, NotSerialized)
                {
                    If (PCEC)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (PCEC))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), PCEC)
                }
            }

            Device (LNK8)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x08)
                Method (_STA, 0, NotSerialized)
                {
                    If (PCED)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCED)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (PCED))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), PCED)
                }
            }

            Device (LP2P)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x09)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTU)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTU)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTU))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTU)
                }
            }

            Device (LUBA)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0A)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTG)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTG)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTG))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTG)
                }
            }

            Device (LMAC)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0B)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTJ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTJ)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTJ))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTJ)
                }
            }

            Device (LAZA)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0D)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTK)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTK)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTK))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTK)
                }
            }

            Device (LPMU)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0E)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTS)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTS)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTS))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTS)
                }
            }

            Device (LSMB)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x0F)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTF)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTF)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTF))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTF)
                }
            }

            Device (LUB2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x10)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTQ)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTQ)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTQ))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTQ)
                }
            }

            Device (LIDE)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x11)
                Method (_STA, 0, NotSerialized)
                {
                    If (INTN)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTN)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (INTN))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), INTN)
                }
            }

            Device (LSID)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x12)
                Method (_STA, 0, NotSerialized)
                {
                    If (ITID)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, ITID)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (ITID))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), ITID)
                }
            }

            Device (LFID)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x13)
                Method (_STA, 0, NotSerialized)
                {
                    If (IS0P)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IS0P)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (IS0P))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), IS0P)
                }
            }

            Device (LSA2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x14)
                Method (_STA, 0, NotSerialized)
                {
                    If (ISA2)
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFA)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, ISA2)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRS (ISA2))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRS (Arg0), ISA2)
                }
            }

            Name (BUF1, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000010,
                }
            })
            Name (BUF2, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000011,
                }
            })
            Name (BUF3, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000012,
                }
            })
            Name (BUF4, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000013,
                }
            })
            Name (BUFF, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000014,
                    0x00000015,
                    0x00000016,
                    0x00000017,
                }
            })
            Name (BUFH, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x0000000B,
                }
            })
            Name (BUFI, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000017,
                }
            })
            Name (IRZ1, ResourceTemplate ()
            {
                Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, )
                {
                    0x00000007,
                }
            })
            Device (APC1)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x15)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTA, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF1)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTA))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTA)
                }
            }

            Device (APC2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x16)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTB, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF2)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTB)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTB))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTB)
                }
            }

            Device (APC3)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x17)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTC, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF3)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTC))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTC)
                }
            }

            Device (APC4)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x18)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTD, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF4)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTD)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTD))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTD)
                }
            }

            Device (APC5)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x19)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (PCEA, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF1)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEA)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (PCEA))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), PCEA)
                }
            }

            Device (APC6)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1A)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (PCEB, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF1)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEB)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (PCEB))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), PCEB)
                }
            }

            Device (APC7)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1B)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (PCEC, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF1)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCEC)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (PCEC))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), PCEC)
                }
            }

            Device (APC8)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1C)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (PCED, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUF1)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, PCED)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (PCED))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), PCED)
                }
            }

            Device (APCF)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1D)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTG, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTG)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTG))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTG)
                }
            }

            Device (APCH)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x1E)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTJ, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTJ)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTJ))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTJ)
                }
            }

            Device (APMU)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x20)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTS, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTS)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTS))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTS)
                }
            }

            Device (AAZA)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x21)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTK, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTK)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTK))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTK)
                }
            }

            Device (APCS)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x22)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTF, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTF)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTF))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTF)
                }
            }

            Device (APCL)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x23)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTQ, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTQ)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTQ))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTQ)
                }
            }

            Device (APCM)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x24)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTU, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTU)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTU))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTU)
                }
            }

            Device (APCZ)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x25)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (INTN, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, INTN)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (INTN))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), INTN)
                }
            }

            Device (APSI)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x26)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (ITID, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, ITID)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (ITID))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), ITID)
                }
            }

            Device (APSJ)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x27)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (IS0P, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, IS0P)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (IS0P))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), IS0P)
                }
            }

            Device (ASA2)
            {
                Name (_HID, EisaId ("PNP0C0F"))
                Name (_UID, 0x28)
                Method (_STA, 0, NotSerialized)
                {
                    If (LAnd (ISA2, PICF))
                    {
                        Return (0x0B)
                    }
                    Else
                    {
                        Return (0x09)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    Store (0x00, ISA2)
                }

                Method (_PRS, 0, NotSerialized)
                {
                    Return (BUFF)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Return (CRSA (ISA2))
                }

                Method (_SRS, 1, NotSerialized)
                {
                    Store (SRSA (Arg0), ISA2)
                }
            }

            Scope (\)
            {
                OperationRegion (\SCPP, SystemIO, 0x142E, 0x01)
                Field (\SCPP, ByteAcc, NoLock, Preserve)
                {
                    SMIP,   8
                }
            }

            Method (\_SB.PCI0._INI, 0, NotSerialized)
            {
                If (STRC (\_OS, "Microsoft Windows"))
                {
                    Store (0x56, SMIP)
                }
                Else
                {
                    If (STRC (\_OS, "Microsoft Windows NT"))
                    {
                        If (CondRefOf (\_OSI, Local0))
                        {
                            If (\_OSI ("Windows 2001"))
                            {
                                Store (0x59, SMIP)
                                Store (0x00, OSFL)
                                Store (0x03, OSFX)
                            }
                        }
                        Else
                        {
                            Store (0x58, SMIP)
                            Store (0x00, OSFL)
                        }
                    }
                    Else
                    {
                        Store (0x57, SMIP)
                        Store (0x02, OSFL)
                    }
                }

                Name (TEMP, 0x00)
                Store (UA1D, TEMP)
                And (TEMP, 0x0F, TEMP)
                If (LEqual (TEMP, 0x01))
                {
                    Store (0x01, UARA)
                }

                If (LEqual (TEMP, 0x02))
                {
                    Store (0x02, UARA)
                }

                If (LEqual (TEMP, 0x03))
                {
                    Store (0x20, UARA)
                }

                If (LEqual (TEMP, 0x04))
                {
                    Store (0x80, UARA)
                }

                Store (UA1D, TEMP)
                And (TEMP, 0xF0, TEMP)
                ShiftRight (TEMP, 0x04, TEMP)
                If (LEqual (TEMP, 0x01))
                {
                    Store (0x01, UARB)
                }

                If (LEqual (TEMP, 0x02))
                {
                    Store (0x02, UARB)
                }

                If (LEqual (TEMP, 0x03))
                {
                    Store (0x20, UARB)
                }

                If (LEqual (TEMP, 0x04))
                {
                    Store (0x80, UARB)
                }
            }

            Scope (\)
            {
                Method (OSTP, 0, NotSerialized)
                {
                    If (LEqual (OSFL, 0x01))
                    {
                        Store (0x56, SMIP)
                    }

                    If (LEqual (OSFL, 0x02))
                    {
                        Store (0x57, SMIP)
                    }

                    If (LEqual (OSFL, 0x00))
                    {
                        If (LEqual (OSFX, 0x03))
                        {
                            Store (0x59, SMIP)
                        }
                        Else
                        {
                            Store (0x58, SMIP)
                        }
                    }

                    If (LEqual (OSFX, 0x03))
                    {
                        Store (0x59, SMIP)
                    }
                }
            }

            Device (SYSR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x01)
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0010,             // Range Minimum
                        0x0010,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x0022,             // Range Minimum
                        0x0022,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x0044,             // Range Minimum
                        0x0044,             // Range Maximum
                        0x01,               // Alignment
                        0x1C,               // Length
                        )
                    IO (Decode16,
                        0x0062,             // Range Minimum
                        0x0062,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0065,             // Range Minimum
                        0x0065,             // Range Maximum
                        0x01,               // Alignment
                        0x0B,               // Length
                        )
                    IO (Decode16,
                        0x0074,             // Range Minimum
                        0x0074,             // Range Maximum
                        0x01,               // Alignment
                        0x0C,               // Length
                        )
                    IO (Decode16,
                        0x0091,             // Range Minimum
                        0x0091,             // Range Maximum
                        0x01,               // Alignment
                        0x03,               // Length
                        )
                    IO (Decode16,
                        0x00A2,             // Range Minimum
                        0x00A2,             // Range Maximum
                        0x01,               // Alignment
                        0x1E,               // Length
                        )
                    IO (Decode16,
                        0x00E0,             // Range Minimum
                        0x00E0,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x04D0,             // Range Minimum
                        0x04D0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x0800,             // Range Minimum
                        0x0800,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0x0295,             // Range Minimum
                        0x0295,             // Range Maximum
                        0x01,               // Alignment
                        0x80,               // Length
                        )
                    IO (Decode16,
                        0x0290,             // Range Minimum
                        0x0290,             // Range Maximum
                        0x01,               // Alignment
                        0x05,               // Length
                        )
                })
            }

            Device (PIC)
            {
                Name (_HID, EisaId ("PNP0000"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0020,             // Range Minimum
                        0x0020,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IO (Decode16,
                        0x00A0,             // Range Minimum
                        0x00A0,             // Range Maximum
                        0x01,               // Alignment
                        0x02,               // Length
                        )
                    IRQNoFlags ()
                        {2}
                })
            }

            Device (DMA1)
            {
                Name (_HID, EisaId ("PNP0200"))
                Name (_CRS, ResourceTemplate ()
                {
                    DMA (Compatibility, BusMaster, Transfer8, )
                        {4}
                    IO (Decode16,
                        0x0000,             // Range Minimum
                        0x0000,             // Range Maximum
                        0x01,               // Alignment
                        0x10,               // Length
                        )
                    IO (Decode16,
                        0x0080,             // Range Minimum
                        0x0080,             // Range Maximum
                        0x01,               // Alignment
                        0x11,               // Length
                        )
                    IO (Decode16,
                        0x0094,             // Range Minimum
                        0x0094,             // Range Maximum
                        0x01,               // Alignment
                        0x0C,               // Length
                        )
                    IO (Decode16,
                        0x00C0,             // Range Minimum
                        0x00C0,             // Range Maximum
                        0x01,               // Alignment
                        0x20,               // Length
                        )
                })
            }

            Device (TMR)
            {
                Name (_HID, EisaId ("PNP0100"))
                Name (ATT5, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {0}
                })
                Name (ATT6, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0040,             // Range Minimum
                        0x0040,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                })
                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT6)
                        }
                        Else
                        {
                            Return (ATT5)
                        }
                    }
                    Else
                    {
                        Return (ATT5)
                    }
                }
            }

            Device (HPET)
            {
                Name (_HID, EisaId ("PNP0103"))
                Name (ATT3, ResourceTemplate ()
                {
                    IRQNoFlags ()
                        {0}
                    IRQNoFlags ()
                        {8}
                    Memory32Fixed (ReadWrite,
                        0xFEFFFC00,         // Address Base
                        0x00000400,         // Address Length
                        )
                })
                Name (ATT4, ResourceTemplate ()
                {
                })
                Method (_STA, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT3)
                        }
                        Else
                        {
                            Return (ATT4)
                        }
                    }
                    Else
                    {
                        Return (ATT4)
                    }
                }
            }

            Device (RTC)
            {
                Name (_HID, EisaId ("PNP0B00"))
                Name (ATT0, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                    IRQNoFlags ()
                        {8}
                })
                Name (ATT1, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0070,             // Range Minimum
                        0x0070,             // Range Maximum
                        0x00,               // Alignment
                        0x04,               // Length
                        )
                })
                Method (_CRS, 0, NotSerialized)
                {
                    If (LGreaterEqual (OSFX, 0x03))
                    {
                        If (HPTF)
                        {
                            Return (ATT1)
                        }
                        Else
                        {
                            Return (ATT0)
                        }
                    }
                    Else
                    {
                        Return (ATT0)
                    }
                }
            }

            Device (SPKR)
            {
                Name (_HID, EisaId ("PNP0800"))
                Name (_CRS, ResourceTemplate ()
                {
                    IO (Decode16,
                        0x0061,             // Range Minimum
                        0x0061,             // Range Maximum
                        0x01,               // Alignment
                        0x01,               // Length
                        )
                })
            }

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

            Scope (\)
            {
                OperationRegion (WIN1, SystemIO, 0x2E, 0x02)
                Field (WIN1, ByteAcc, NoLock, Preserve)
                {
                    INDP,   8, 
                    DATP,   8
                }

                OperationRegion (GPIO, SystemIO, 0x0800, 0x05)
                Field (GPIO, ByteAcc, NoLock, Preserve)
                {
                    GO01,   8, 
                    GO02,   8, 
                    GO03,   8, 
                    GO04,   8, 
                    GO05,   8
                }

                IndexField (INDP, DATP, ByteAcc, NoLock, Preserve)
                {
                            Offset (0x02), 
                    CFG,    8, 
                            Offset (0x07), 
                    LDN,    8, 
                            Offset (0x20), 
                    IDHI,   8, 
                    IDLO,   8, 
                    POWC,   8, 
                            Offset (0x30), 
                    ACTR,   8, 
                            Offset (0x60), 
                    IOAH,   8, 
                    IOAL,   8, 
                    IO2H,   8, 
                    IO2L,   8, 
                            Offset (0x70), 
                    INTR,   8, 
                            Offset (0x72), 
                    INT1,   8, 
                            Offset (0x74), 
                    DMCH,   8, 
                            Offset (0xC0), 
                    GP40,   8, 
                            Offset (0xF0), 
                    OPT1,   8, 
                    OPT2,   8, 
                    OPT3,   8, 
                    OPT4,   8
                }

                Method (ENFG, 0, NotSerialized)
                {
                    Store (0x87, INDP)
                    Store (0x01, INDP)
                    Store (0x55, INDP)
                    Store (0x55, INDP)
                }

                Method (EXFG, 0, NotSerialized)
                {
                    Store (0x02, CFG)
                }

                Method (GSRG, 1, NotSerialized)
                {
                    Store (Arg0, INDP)
                    Return (DATP)
                }

                Method (SSRG, 2, NotSerialized)
                {
                    Store (Arg0, INDP)
                    Store (Arg1, DATP)
                }
            }

            Device (FDC0)
            {
                Name (_HID, EisaId ("PNP0700"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (Zero, LDN)
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LOr (IOAH, IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x00, LDN)
                    Store (Zero, ACTR)
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x03)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF0, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x01,               // Alignment
                            0x06,               // Length
                            _Y04)
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    })
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y04._MIN, IOLO)
                    CreateByteField (BUF0, 0x03, IOHI)
                    CreateByteField (BUF0, \_SB.PCI0.FDC0._CRS._Y04._MAX, IORL)
                    CreateByteField (BUF0, 0x05, IORH)
                    ENFG ()
                    EXFG ()
                    Return (BUF0)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F0,             // Range Minimum
                            0x03F0,             // Range Maximum
                            0x01,               // Alignment
                            0x06,               // Length
                            )
                        IO (Decode16,
                            0x03F7,             // Range Minimum
                            0x03F7,             // Range Maximum
                            0x01,               // Alignment
                            0x01,               // Length
                            )
                        IRQNoFlags ()
                            {6}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {2}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x19, IRQW)
                    CreateByteField (Arg0, 0x1C, DMAV)
                    ENFG ()
                    Store (Zero, LDN)
                    Store (One, ACTR)
                    SLDM (DMCH, DMCH)
                    CKIO (IOAD, 0x03)
                    EXFG ()
                }
            }

            Device (UAR1)
            {
                Name (_HID, EisaId ("PNP0501"))
                Name (_UID, 0x01)
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x01, LDN)
                    If (ACTR)
                    {
                        EXFG ()
                        Return (0x0F)
                    }
                    Else
                    {
                        If (LOr (IOAH, IOAL))
                        {
                            EXFG ()
                            Return (0x0D)
                        }
                        Else
                        {
                            EXFG ()
                            Return (0x00)
                        }
                    }

                    EXFG ()
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x01, LDN)
                    Store (Zero, ACTR)
                    EXFG ()
                    DISD (0x00)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y05)
                        IRQNoFlags (_Y06)
                            {}
                    })
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y05._MIN, IOLO)
                    CreateByteField (BUF1, 0x03, IOHI)
                    CreateByteField (BUF1, \_SB.PCI0.UAR1._CRS._Y05._MAX, IORL)
                    CreateByteField (BUF1, 0x05, IORH)
                    CreateWordField (BUF1, \_SB.PCI0.UAR1._CRS._Y06._INT, IRQW)
                    ENFG ()
                    Store (0x01, LDN)
                    Store (IOAL, IOLO)
                    Store (IOAL, IORL)
                    Store (IOAH, IOHI)
                    Store (IOAH, IORH)
                    Store (One, Local0)
                    ShiftLeft (Local0, INTR, IRQW)
                    EXFG ()
                    Return (BUF1)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03F8,             // Range Minimum
                            0x03F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02F8,             // Range Minimum
                            0x02F8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03E8,             // Range Minimum
                            0x03E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x02E8,             // Range Minimum
                            0x02E8,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x01, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetRightBit (IRQW, Local0)
                    Subtract (Local0, 0x01, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x00)
                }
            }

            Device (LPT1)
            {
                Name (_HID, EisaId ("PNP0400"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    And (OPT1, 0x02, Local0)
                    If (LNotEqual (Local0, 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            If (LOr (IOAH, IOAL))
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x00)
                            }
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    Store (Zero, ACTR)
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF5, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            _Y07)
                        IRQNoFlags (_Y08)
                            {}
                    })
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y07._MIN, IOLO)
                    CreateByteField (BUF5, 0x03, IOHI)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y07._MAX, IORL)
                    CreateByteField (BUF5, 0x05, IORH)
                    CreateByteField (BUF5, \_SB.PCI0.LPT1._CRS._Y07._LEN, IOLE)
                    CreateWordField (BUF5, \_SB.PCI0.LPT1._CRS._Y08._INT, IRQW)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (IOAL, IOLO)
                    Store (IOLO, IORL)
                    Store (IOAH, IOHI)
                    Store (IOHI, IORH)
                    If (LEqual (IOLO, 0xBC))
                    {
                        Store (0x04, IOLE)
                    }
                    Else
                    {
                        Store (0x08, IOLE)
                    }

                    Store (One, Local0)
                    Store (INTR, Local5)
                    ShiftLeft (Local0, Local5, IRQW)
                    EXFG ()
                    Return (BUF5)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x01,               // Alignment
                            0x08,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateByteField (Arg0, 0x04, IORL)
                    CreateByteField (Arg0, 0x05, IORH)
                    CreateWordField (Arg0, 0x09, IRQW)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetLeftBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Store (Local0, INTR)
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

            Device (ECP1)
            {
                Name (_HID, EisaId ("PNP0401"))
                Method (_STA, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    And (OPT1, 0x02, Local0)
                    If (LEqual (Local0, 0x02))
                    {
                        If (ACTR)
                        {
                            EXFG ()
                            Return (0x0F)
                        }
                        Else
                        {
                            If (LOr (IOAH, IOAL))
                            {
                                EXFG ()
                                Return (0x0D)
                            }
                            Else
                            {
                                EXFG ()
                                Return (0x00)
                            }
                        }
                    }
                    Else
                    {
                        EXFG ()
                        Return (0x00)
                    }
                }

                Method (_DIS, 0, NotSerialized)
                {
                    ENFG ()
                    Store (0x03, LDN)
                    Store (Zero, ACTR)
                    SLDM (DMCH, 0x04)
                    EXFG ()
                    DISD (0x02)
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF6, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            _Y09)
                        IO (Decode16,
                            0x0000,             // Range Minimum
                            0x0000,             // Range Maximum
                            0x01,               // Alignment
                            0x04,               // Length
                            _Y0A)
                        IRQNoFlags (_Y0B)
                            {}
                        DMA (Compatibility, NotBusMaster, Transfer8, _Y0C)
                            {}
                    })
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y09._MIN, IOLO)
                    CreateByteField (BUF6, 0x03, IOHI)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y09._MAX, IORL)
                    CreateByteField (BUF6, 0x05, IORH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y09._LEN, IOLE)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y0A._MIN, IOEL)
                    CreateByteField (BUF6, 0x0B, IOEH)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y0A._MAX, IOML)
                    CreateByteField (BUF6, 0x0D, IOMH)
                    CreateWordField (BUF6, \_SB.PCI0.ECP1._CRS._Y0B._INT, IRQW)
                    CreateByteField (BUF6, \_SB.PCI0.ECP1._CRS._Y0C._DMA, DMAC)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (IOAL, Local2)
                    Store (Local2, IOLO)
                    Store (IOAH, Local3)
                    Store (Local3, IOHI)
                    Or (Local3, 0x04, Local3)
                    Store (Local3, IOEH)
                    Store (Local3, IOMH)
                    Store (IOLO, IORL)
                    Store (IOLO, IOEL)
                    Store (IOLO, IOML)
                    Store (IOHI, IORH)
                    If (LEqual (IOLO, 0xBC))
                    {
                        Store (0x04, IOLE)
                    }
                    Else
                    {
                        Store (0x08, IOLE)
                    }

                    Store (One, Local0)
                    Store (INTR, Local5)
                    ShiftLeft (Local0, Local5, IRQW)
                    Store (One, Local0)
                    Store (DMCH, Local5)
                    ShiftLeft (Local0, Local5, DMAC)
                    EXFG ()
                    Return (BUF6)
                }

                Name (_PRS, ResourceTemplate ()
                {
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0378,             // Range Minimum
                            0x0378,             // Range Maximum
                            0x00,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0778,             // Range Minimum
                            0x0778,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x0278,             // Range Minimum
                            0x0278,             // Range Maximum
                            0x00,               // Alignment
                            0x08,               // Length
                            )
                        IO (Decode16,
                            0x0678,             // Range Minimum
                            0x0678,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    StartDependentFnNoPri ()
                    {
                        IO (Decode16,
                            0x03BC,             // Range Minimum
                            0x03BC,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IO (Decode16,
                            0x07BC,             // Range Minimum
                            0x07BC,             // Range Maximum
                            0x00,               // Alignment
                            0x04,               // Length
                            )
                        IRQNoFlags ()
                            {3,4,5,7,9,10,11,12}
                        DMA (Compatibility, NotBusMaster, Transfer8, )
                            {0,1,3}
                    }
                    EndDependentFn ()
                })
                Method (_SRS, 1, NotSerialized)
                {
                    CreateByteField (Arg0, 0x02, IOLO)
                    CreateByteField (Arg0, 0x03, IOHI)
                    CreateWordField (Arg0, 0x02, IOAD)
                    CreateWordField (Arg0, 0x11, IRQW)
                    CreateByteField (Arg0, 0x14, DMAC)
                    ENFG ()
                    Store (0x03, LDN)
                    Store (One, ACTR)
                    Store (IOLO, IOAL)
                    Store (IOHI, IOAH)
                    FindSetLeftBit (IRQW, Local0)
                    Subtract (Local0, 0x01, Local0)
                    Store (Local0, INTR)
                    FindSetLeftBit (DMAC, Local1)
                    Store (DMCH, Local0)
                    Subtract (Local1, 0x01, DMCH)
                    SLDM (Local0, DMCH)
                    EXFG ()
                    CKIO (IOAD, 0x02)
                }
            }

            OperationRegion (KBCT, SystemIO, 0x60, 0x05)
            Field (KBCT, ByteAcc, NoLock, Preserve)
            {
                P060,   8, 
                        Offset (0x04), 
                P064,   8
            }

            Device (PS2M)
            {
                Name (_HID, EisaId ("PNP0F13"))
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (PS2F, 0x00))
                    {
                        Return (0x0F)
                    }
                    Else
                    {
                        Return (0x00)
                    }
                }

                Method (_CRS, 0, NotSerialized)
                {
                    Name (BUF1, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                    Name (BUF2, 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 (LEqual (KBDI, 0x01))
                    {
                        If (LEqual (OSFL, 0x02))
                        {
                            Return (BUF1)
                        }

                        If (LEqual (OSFL, 0x01))
                        {
                            Return (BUF1)
                        }
                        Else
                        {
                            Return (BUF2)
                        }
                    }
                    Else
                    {
                        Return (BUF1)
                    }
                }
            }

            Device (PS2K)
            {
                Name (_HID, EisaId ("PNP0303"))
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (KBDI, 0x01))
                    {
                        Return (0x00)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }

                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
                        )
                    IRQNoFlags ()
                        {1}
                })
            }

            Device (PSMR)
            {
                Name (_HID, EisaId ("PNP0C02"))
                Name (_UID, 0x03)
                Method (_STA, 0, NotSerialized)
                {
                    If (LEqual (KBDI, 0x00))
                    {
                        Return (0x00)
                    }

                    If (LEqual (PS2F, 0x00))
                    {
                        If (LEqual (OSFL, 0x02))
                        {
                            Return (0x0F)
                        }

                        If (LEqual (OSFL, 0x01))
                        {
                            Return (0x0F)
                        }

                        Return (0x00)
                    }

                    Return (0x00)
                }

                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
                        )
                })
            }

            Method (\_SB.PCI0.UAR1._PRW, 0, NotSerialized)
            {
                Return (Package (0x02)
                {
                    0x03, 
                    0x05
                })
            }
        }

        Device (MEM)
        {
            Name (_HID, EisaId ("PNP0C01"))
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0x000F0000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0E)
                    Memory32Fixed (ReadWrite,
                        0x000F4000,         // Address Base
                        0x00004000,         // Address Length
                        _Y0F)
                    Memory32Fixed (ReadWrite,
                        0x000F8000,         // Address Base
                        0x00004000,         // Address Length
                        _Y10)
                    Memory32Fixed (ReadWrite,
                        0x000FC000,         // Address Base
                        0x00004000,         // Address Length
                        _Y11)
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x00010000,         // Address Length
                        _Y0D)
                    Memory32Fixed (ReadWrite,
                        0xFFFF0000,         // Address Base
                        0x00010000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00000000,         // Address Base
                        0x000A0000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0x00100000,         // Address Base
                        0x00000000,         // Address Length
                        _Y12)
                    Memory32Fixed (ReadWrite,
                        0xFEC00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                    Memory32Fixed (ReadWrite,
                        0xFEE00000,         // Address Base
                        0x00001000,         // Address Length
                        )
                })
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0D._BAS, ACMM)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0E._BAS, RMA1)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0E._LEN, RSS1)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0F._BAS, RMA2)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y0F._LEN, RSS2)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y10._BAS, RMA3)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y10._LEN, RSS3)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y11._BAS, RMA4)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y11._LEN, RSS4)
                CreateDWordField (BUF0, \_SB.MEM._CRS._Y12._LEN, EXTM)
                Subtract (AMEM, 0x00100000, EXTM)
                If (LNotEqual (ROM1, Zero))
                {
                    Store (RMA1, RMA2)
                    ShiftLeft (ROM1, 0x08, Local0)
                    Store (Local0, RMA1)
                    ShiftLeft (RMS1, 0x08, Local0)
                    Store (Local0, RSS1)
                    Store (0x8000, RSS2)
                }

                If (LNotEqual (ROM2, Zero))
                {
                    Store (RMA2, RMA3)
                    ShiftLeft (ROM2, 0x08, Local0)
                    Store (Local0, RMA2)
                    ShiftLeft (RMS2, 0x08, Local0)
                    Store (Local0, RSS2)
                    Store (0xC000, RSS3)
                }

                If (LNotEqual (ROM3, Zero))
                {
                    Store (RMA3, RMA4)
                    ShiftLeft (ROM3, 0x08, Local0)
                    Store (Local0, RMA3)
                    ShiftLeft (RMS3, 0x08, Local0)
                    Store (Local0, RSS3)
                    Store (0x00010000, RSS4)
                }

                Store (AMEM, ACMM)
                Return (BUF0)
            }
        }

        Device (\_SB.PCI0.EXPL)
        {
            Name (_HID, EisaId ("PNP0C02"))
            Name (_UID, 0x04)
            Method (_CRS, 0, NotSerialized)
            {
                Name (BUF0, ResourceTemplate ()
                {
                    Memory32Fixed (ReadWrite,
                        0xF0000000,         // Address Base
                        0x08000000,         // Address Length
                        )
                })
                Return (BUF0)
            }
        }
    }
}

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 197 bytes
Desc: This is a digitally signed message part.
URL: <http://www.coreboot.org/pipermail/coreboot/attachments/20090327/53bdf387/attachment.sig>


More information about the coreboot mailing list