Attachment 69602 Details for Bug 151517

DSDT.dsl

dsdt.dsl (text/plain), 219.17 KB, created by Hannes Reinecke on 2006-02-21 15:53:10 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Hannes Reinecke

Created: 2006-02-21 15:53:10 UTC

Size: 219.17 KB

patch

obsolete

>/*
> * Intel ACPI Component Architecture
> * AML Disassembler version 20050902
> *
> * Disassembly of dsdt.asl, Tue Feb 21 16:48:47 2006
> */
>DefinitionBlock ("DSDT.aml", "DSDT", 1, "FUJ   ", "FJNB1A1 ", 17891328)
>{
>    Name (BIDT, Buffer (0x10)
>    {
>        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
>        0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x00, 0x0A
>    })
>    Name (BMNT, Package (0x0B)
>    {
>        "CP255084", 
>        "CP255092", 
>        "CP255100", 
>        "CP255108", 
>        "CP255116", 
>        "CP255124", 
>        "CP255132", 
>        "CP255140", 
>        "CP245360", 
>        "CP186215 / CP186216", 
>        "CP144820 / CP144821"
>    })
>    Name (BMST, Package (0x0B)
>    {
>        "CP255084", 
>        "CP255092", 
>        "CP255100", 
>        "CP255108", 
>        "CP255116", 
>        "CP255124", 
>        "CP255132", 
>        "CP255140", 
>        "CP245360", 
>        "CP245376", 
>        "CP245408"
>    })
>    Scope (_PR)
>    {
>        Processor (CPU0, 0x00, 0x00001010, 0x06) {}
>    }
>
>    Scope (\_SB)
>    {
>        Name (OSTB, Ones)
>        OperationRegion (OSTY, SystemMemory, 0x1F697F12, 0x00000001)
>        Field (OSTY, AnyAcc, NoLock, Preserve)
>        {
>            TPOS,   8
>        }
>
>        Method (OSTP, 0, NotSerialized)
>        {
>            If (LEqual (^OSTB, Ones))
>            {
>                If (CondRefOf (\_OSI, Local0))
>                {
>                    If (\_OSI ("Windows 2001.1"))
>                    {
>                        Store (0x20, ^OSTB)
>                        Store (0x20, ^TPOS)
>                    }
>                    Else
>                    {
>                        If (\_OSI ("Windows 2001 SP1"))
>                        {
>                            Store (0x10, ^OSTB)
>                            Store (0x10, ^TPOS)
>                        }
>                        Else
>                        {
>                            If (\_OSI ("Windows 2001"))
>                            {
>                                Store (0x08, ^OSTB)
>                                Store (0x08, ^TPOS)
>                            }
>                            Else
>                            {
>                                Store (0x00, ^OSTB)
>                                Store (0x00, ^TPOS)
>                            }
>                        }
>                    }
>                }
>                Else
>                {
>                    If (CondRefOf (\_OS, Local0))
>                    {
>                        If (^SEQL (\_OS, "Microsoft Windows"))
>                        {
>                            Store (0x01, ^OSTB)
>                            Store (0x01, ^TPOS)
>                        }
>                        Else
>                        {
>                            If (^SEQL (\_OS, "Microsoft WindowsME: Millennium Edition"))
>                            {
>                                Store (0x02, ^OSTB)
>                                Store (0x02, ^TPOS)
>                            }
>                            Else
>                            {
>                                If (^SEQL (\_OS, "Microsoft Windows NT"))
>                                {
>                                    Store (0x04, ^OSTB)
>                                    Store (0x04, ^TPOS)
>                                }
>                                Else
>                                {
>                                    Store (0x00, ^OSTB)
>                                    Store (0x00, ^TPOS)
>                                }
>                            }
>                        }
>                    }
>                    Else
>                    {
>                        Store (0x00, ^OSTB)
>                        Store (0x00, ^TPOS)
>                    }
>                }
>            }
>
>            Return (^OSTB)
>        }
>
>        Method (OSHT, 0, NotSerialized)
>        {
>            \_SB.OSTP ()
>            Store (0x48, CMD)
>            Store (Zero, SSMI)
>        }
>
>        Method (SEQL, 2, Serialized)
>        {
>            Store (SizeOf (Arg0), Local0)
>            Store (SizeOf (Arg1), Local1)
>            If (LNot (LEqual (Local0, Local1)))
>            {
>                Return (Zero)
>            }
>
>            Name (BUF0, Buffer (Local0) {})
>            Store (Arg0, BUF0)
>            Name (BUF1, Buffer (Local0) {})
>            Store (Arg1, BUF1)
>            Store (Zero, Local2)
>            While (LLess (Local2, Local0))
>            {
>                Store (DerefOf (Index (BUF0, Local2)), Local3)
>                Store (DerefOf (Index (BUF1, Local2)), Local4)
>                If (LNot (LEqual (Local3, Local4)))
>                {
>                    Return (Zero)
>                }
>
>                Increment (Local2)
>            }
>
>            Return (One)
>        }
>    }
>
>    Name (BYIS, 0xFF)
>    Name (EXIS, 0xFF)
>    Name (PLWM, Zero)
>    Name (PTAL, Zero)
>    Name (FWSO, Zero)
>    Name (RPEN, Zero)
>    Name (RPDS, Zero)
>    Name (TMBF, Zero)
>    Name (TCNT, Zero)
>    Name (LEDI, Zero)
>    Name (BTNI, Zero)
>    Name (NGTI, 0x06)
>    Name (GPIC, Zero)
>    Method (\_PIC, 1, NotSerialized)
>    {
>        Store (Arg0, GPIC)
>    }
>
>    Scope (_SB)
>    {
>        OperationRegion (PSIO, SystemIO, 0x0000FE00, 0x00000002)
>        OperationRegion (PSBF, SystemMemory, 0x1F697E82, 0x00000090)
>        OperationRegion (OEMT, SystemMemory, 0x1F697F92, 0x00000020)
>        OperationRegion (SYSC, SystemMemory, 0x1F697FB2, 0x0000000A)
>        OperationRegion (VDEX, SystemMemory, 0x1F697E72, 0x00000010)
>        OperationRegion (BTNC, SystemMemory, 0x1F697F82, 0x00000010)
>        Scope (\)
>        {
>            Field (\_SB.PSIO, ByteAcc, NoLock, Preserve)
>            {
>                SSMI,   8
>            }
>
>            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
>            {
>                CMD,    8, 
>                DVID,   32, 
>                PSDT,   32
>            }
>
>            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
>            {
>                Offset (0x05), 
>                INF,    8
>            }
>
>            Field (\_SB.PSBF, ByteAcc, NoLock, Preserve)
>            {
>                Offset (0x05), 
>                PIID,   320
>            }
>
>            Field (\_SB.OEMT, ByteAcc, NoLock, Preserve)
>            {
>                SPAF,   2, 
>                SPBF,   2, 
>                PPF,    3, 
>                FDCF,   1, 
>                SIDF,   2, 
>                IMTF,   1, 
>                BLEN,   1, 
>                WLEN,   1, 
>                Offset (0x04), 
>                WAPB,   1, 
>                WBLT,   1, 
>                Offset (0x08), 
>                FWHM,   1, 
>                    ,   1, 
>                TPMF,   2, 
>                TTIM,   1, 
>                FBAY,   1, 
>                Offset (0x10), 
>                FDS0,   4, 
>                FDS1,   4, 
>                Offset (0x18), 
>                UMST,   32, 
>                UMSZ,   32
>            }
>
>            Field (\_SB.SYSC, ByteAcc, NoLock, Preserve)
>            {
>                BHKF,   1, 
>                    ,   2, 
>                MHKF,   1, 
>                Offset (0x01), 
>                BLLM,   8, 
>                BLLT,   64
>            }
>
>            Field (\_SB.SYSC, ByteAcc, NoLock, Preserve)
>            {
>                AHKF,   8
>            }
>
>            Field (\_SB.VDEX, ByteAcc, NoLock, Preserve)
>            {
>                ADOS,   3, 
>                CLCD,   1, 
>                ALCD,   1, 
>                CCRT,   1, 
>                ACRT,   1, 
>                CTV,    1, 
>                ATV,    1, 
>                CDVI,   1, 
>                ADVI,   1, 
>                DSWF,   2
>            }
>
>            Field (\_SB.BTNC, ByteAcc, NoLock, Preserve)
>            {
>                IRBF,   1, 
>                    ,   6, 
>                NGTF,   1, 
>                Offset (0x04), 
>                IRBC,   16
>            }
>        }
>
>        Method (_INI, 0, NotSerialized)
>        {
>            And (G3P1, 0xC0, Local0)
>            If (LEqual (Local0, 0xC0))
>            {
>                Store (Zero, LEDI)
>                Store (Zero, BTNI)
>            }
>            Else
>            {
>                If (Local0)
>                {
>                    Store (0x0100, LEDI)
>                    Store (0x00FF0101, BTNI)
>                }
>                Else
>                {
>                    Store (Zero, LEDI)
>                    Store (0x000F0001, BTNI)
>                }
>            }
>        }
>
>        Device (MCFG)
>        {
>            Name (_HID, EisaId ("PNP0C02"))
>            Name (_CRS, ResourceTemplate ()
>            {
>                DWordMemory (ResourceConsumer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0xE0000000, // Address Range Minimum
>                    0xEFFFFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x10000000,,,
>                    , AddressRangeMemory, TypeStatic)
>            })
>        }
>
>        Device (PCI0)
>        {
>            Name (_HID, EisaId ("PNP0A03"))
>            Name (_ADR, 0x00)
>            Name (_BBN, 0x00)
>            OperationRegion (HBUS, PCI_Config, 0x40, 0xC0)
>            Field (HBUS, DWordAcc, NoLock, Preserve)
>            {
>                Offset (0x50), 
>                    ,   4, 
>                PM0H,   2, 
>                Offset (0x51), 
>                PM1L,   2, 
>                    ,   2, 
>                PM1H,   2, 
>                Offset (0x52), 
>                PM2L,   2, 
>                    ,   2, 
>                PM2H,   2, 
>                Offset (0x53), 
>                PM3L,   2, 
>                    ,   2, 
>                PM3H,   2, 
>                Offset (0x54), 
>                PM4L,   2, 
>                    ,   2, 
>                PM4H,   2, 
>                Offset (0x55), 
>                PM5L,   2, 
>                    ,   2, 
>                PM5H,   2, 
>                Offset (0x56), 
>                PM6L,   2, 
>                    ,   2, 
>                PM6H,   2, 
>                Offset (0x57), 
>                    ,   7, 
>                HENA,   1, 
>                Offset (0x5C), 
>                    ,   3, 
>                TOUD,   5
>            }
>
>            Name (BUF0, ResourceTemplate ()
>            {
>                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
>                    0x0000, // Address Space Granularity
>                    0x0000, // Address Range Minimum
>                    0x00FF, // Address Range Maximum
>                    0x0000, // Address Translation Offset
>                    0x0100,,,)
>                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x00000000, // Address Space Granularity
>                    0x00000000, // Address Range Minimum
>                    0x00000CF7, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00000CF8,,,
>                    , TypeStatic)
>                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
>                DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x00000000, // Address Space Granularity
>                    0x00000D00, // Address Range Minimum
>                    0x0000FFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x0000F300,,,
>                    , TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000A0000, // Address Range Minimum
>                    0x000BFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00020000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000C0000, // Address Range Minimum
>                    0x000C3FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000C4000, // Address Range Minimum
>                    0x000C7FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000C8000, // Address Range Minimum
>                    0x000CBFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000CC000, // Address Range Minimum
>                    0x000CFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000D0000, // Address Range Minimum
>                    0x000D3FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000D4000, // Address Range Minimum
>                    0x000D7FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000D8000, // Address Range Minimum
>                    0x000DBFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000DC000, // Address Range Minimum
>                    0x000DFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000E0000, // Address Range Minimum
>                    0x000E3FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000E4000, // Address Range Minimum
>                    0x000E7FFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000E8000, // Address Range Minimum
>                    0x000EBFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000EC000, // Address Range Minimum
>                    0x000EFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00004000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x000F0000, // Address Range Minimum
>                    0x000FFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00010000,,,
>                    , AddressRangeMemory, TypeStatic)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000, // Address Space Granularity
>                    0x00000000, // Address Range Minimum
>                    0xDFFFFFFF, // Address Range Maximum
>                    0x00000000, // Address Translation Offset
>                    0x00000000,,,
>                    , AddressRangeMemory, TypeStatic)
>            })
>            Method (_CRS, 0, Serialized)
>            {
>                If (PM1L)
>                {
>                    CreateDWordField (BUF0, 0x80, C0LN)
>                    Store (Zero, C0LN)
>                }
>
>                If (LEqual (PM1L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0378, C0RW)
>                    Store (Zero, C0RW)
>                }
>
>                If (PM1H)
>                {
>                    CreateDWordField (BUF0, 0x9B, C4LN)
>                    Store (Zero, C4LN)
>                }
>
>                If (LEqual (PM1H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0450, C4RW)
>                    Store (Zero, C4RW)
>                }
>
>                If (PM2L)
>                {
>                    CreateDWordField (BUF0, 0xB6, C8LN)
>                    Store (Zero, C8LN)
>                }
>
>                If (LEqual (PM2L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0528, C8RW)
>                    Store (Zero, C8RW)
>                }
>
>                If (PM2H)
>                {
>                    CreateDWordField (BUF0, 0xD1, CCLN)
>                    Store (Zero, CCLN)
>                }
>
>                If (LEqual (PM2H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0600, CCRW)
>                    Store (Zero, CCRW)
>                }
>
>                If (PM3L)
>                {
>                    CreateDWordField (BUF0, 0xEC, D0LN)
>                    Store (Zero, D0LN)
>                }
>
>                If (LEqual (PM3L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x06D8, D0RW)
>                    Store (Zero, D0RW)
>                }
>
>                If (PM3H)
>                {
>                    CreateDWordField (BUF0, 0x0107, D4LN)
>                    Store (Zero, D4LN)
>                }
>
>                If (LEqual (PM3H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x07B0, D4RW)
>                    Store (Zero, D4RW)
>                }
>
>                If (PM4L)
>                {
>                    CreateDWordField (BUF0, 0x0122, D8LN)
>                    Store (Zero, D8LN)
>                }
>
>                If (LEqual (PM4L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0888, D8RW)
>                    Store (Zero, D8RW)
>                }
>
>                If (PM4H)
>                {
>                    CreateDWordField (BUF0, 0x013D, DCLN)
>                    Store (Zero, DCLN)
>                }
>
>                If (LEqual (PM4H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0960, DCRW)
>                    Store (Zero, DCRW)
>                }
>
>                If (PM5L)
>                {
>                    CreateDWordField (BUF0, 0x0158, E0LN)
>                    Store (Zero, E0LN)
>                }
>
>                If (LEqual (PM5L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0A38, E0RW)
>                    Store (Zero, E0RW)
>                }
>
>                If (PM5H)
>                {
>                    CreateDWordField (BUF0, 0x0173, E4LN)
>                    Store (Zero, E4LN)
>                }
>
>                If (LEqual (PM5H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0B10, E4RW)
>                    Store (Zero, E4RW)
>                }
>
>                If (PM6L)
>                {
>                    CreateDWordField (BUF0, 0x018E, E8LN)
>                    Store (Zero, E8LN)
>                }
>
>                If (LEqual (PM6L, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0BE8, E8RW)
>                    Store (Zero, E8RW)
>                }
>
>                If (PM6H)
>                {
>                    CreateDWordField (BUF0, 0x01A9, ECLN)
>                    Store (Zero, ECLN)
>                }
>
>                If (LEqual (PM6H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0CC0, ECRW)
>                    Store (Zero, ECRW)
>                }
>
>                If (PM0H)
>                {
>                    CreateDWordField (BUF0, 0x01C4, F0LN)
>                    Store (Zero, F0LN)
>                }
>
>                If (LEqual (PM0H, 0x01))
>                {
>                    CreateBitField (BUF0, 0x0D98, F0RW)
>                    Store (Zero, F0RW)
>                }
>
>                CreateDWordField (BUF0, 0x01D3, M1MN)
>                CreateDWordField (BUF0, 0x01D7, M1MX)
>                CreateDWordField (BUF0, 0x01DF, M1LN)
>                ShiftLeft (TOUD, 0x1B, M1MN)
>                Add (Subtract (M1MX, M1MN), 0x01, M1LN)
>                Return (BUF0)
>            }
>
>            Method (_PRT, 0, NotSerialized)
>            {
>                If (GPIC)
>                {
>                    Return (Package (0x0E)
>                    {
>                        Package (0x04)
>                        {
>                            0x0001FFFF, 
>                            0x00, 
>                            0x00, 
>                            0x10
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x0002FFFF, 
>                            0x00, 
>                            0x00, 
>                            0x10
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001BFFFF, 
>                            0x00, 
>                            0x00, 
>                            0x10
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001CFFFF, 
>                            0x00, 
>                            0x00, 
>                            0x11
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001CFFFF, 
>                            0x01, 
>                            0x00, 
>                            0x10
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x00, 
>                            0x00, 
>                            0x17
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x01, 
>                            0x00, 
>                            0x13
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x02, 
>                            0x00, 
>                            0x12
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x03, 
>                            0x00, 
>                            0x10
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001EFFFF, 
>                            0x00, 
>                            0x00, 
>                            0x11
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001EFFFF, 
>                            0x01, 
>                            0x00, 
>                            0x14
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x00, 
>                            0x00, 
>                            0x12
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x01, 
>                            0x00, 
>                            0x13
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x03, 
>                            0x00, 
>                            0x10
>                        }
>                    })
>                }
>                Else
>                {
>                    Return (Package (0x0E)
>                    {
>                        Package (0x04)
>                        {
>                            0x0001FFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x0002FFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001BFFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001CFFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKB, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001CFFFF, 
>                            0x01, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKH, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x01, 
>                            \_SB.PCI0.LPCB.LNKD, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x02, 
>                            \_SB.PCI0.LPCB.LNKC, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001DFFFF, 
>                            0x03, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001EFFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKB, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001EFFFF, 
>                            0x01, 
>                            \_SB.PCI0.LPCB.LNKE, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x00, 
>                            \_SB.PCI0.LPCB.LNKC, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x01, 
>                            \_SB.PCI0.LPCB.LNKD, 
>                            0x00
>                        }, 
>
>                        Package (0x04)
>                        {
>                            0x001FFFFF, 
>                            0x03, 
>                            \_SB.PCI0.LPCB.LNKA, 
>                            0x00
>                        }
>                    })
>                }
>            }
>
>            Device (GFX0)
>            {
>                Name (_ADR, 0x00020000)
>                Method (XLCD, 0, NotSerialized)
>                {
>                    Return (One)
>                }
>
>                Method (XCRT, 0, NotSerialized)
>                {
>                    Return (One)
>                }
>
>                Method (XTV, 0, NotSerialized)
>                {
>                    Return (XOr (SOUT, One))
>                }
>
>                Method (XDVI, 0, NotSerialized)
>                {
>                    Return (BY2O)
>                }
>
>                Scope (\)
>                {
>                    Name (WLCD, Zero)
>                    Name (WCRT, Zero)
>                    Name (WTV, Zero)
>                    Name (WDVI, Zero)
>                }
>
>                Method (PHTK, 0, NotSerialized)
>                {
>                    Store (Zero, DSWF)
>                }
>
>                Name (F10T, Package (0x0A)
>                {
>                    0x01, 
>                    0x02, 
>                    0x03, 
>                    0x04, 
>                    0x05, 
>                    0x01, 
>                    0x02, 
>                    0x03, 
>                    0x04, 
>                    0x05
>                })
>                Method (AHTK, 0, NotSerialized)
>                {
>                    If (LAnd (LEqual (And (ADOS, 0x03), Zero), DSWF))
>                    {
>                        UPDD ()
>                        If (LEqual (DSWF, 0x01))
>                        {
>                            Or (ShiftLeft (CDVI, 0x02), Or (ShiftLeft (CCRT, 0x01), CLCD), Local0)
>                            Or (ShiftLeft (ADVI, 0x02), Or (ShiftLeft (ACRT, 0x01), ALCD), Local1)
>                            Store (Zero, Local2)
>                            Store (0xFF, Local3)
>                            While (LAnd (LLess (Local2, 0x0A), LEqual (Local3, 0xFF)))
>                            {
>                                If (LEqual (DerefOf (Index (F10T, Local2)), Local0))
>                                {
>                                    If (LAnd (CTV, ATV))
>                                    {
>                                        Store (Local2, Local3)
>                                    }
>                                    Else
>                                    {
>                                        Add (Local2, 0x01, Local3)
>                                    }
>                                }
>
>                                Increment (Local2)
>                            }
>
>                            Store (0xFF, Local2)
>                            If (LNot (LEqual (Local3, 0xFF)))
>                            {
>                                While (LAnd (LLess (Local3, 0x0A), LEqual (Local2, 0xFF)))
>                                {
>                                    If (LEqual (And (DerefOf (Index (F10T, Local3)), Local1), DerefOf (Index (F10T, Local3))))
>                                    {
>                                        Store (DerefOf (Index (F10T, Local3)), Local2)
>                                    }
>
>                                    Increment (Local3)
>                                }
>                            }
>
>                            If (LEqual (Local2, 0xFF))
>                            {
>                                If (ALCD)
>                                {
>                                    Store (0x01, Local2)
>                                }
>                                Else
>                                {
>                                    If (ACRT)
>                                    {
>                                        Store (0x02, Local2)
>                                    }
>                                    Else
>                                    {
>                                        If (ADVI)
>                                        {
>                                            Store (0x04, Local2)
>                                        }
>                                        Else
>                                        {
>                                            Store (0x02, Local2)
>                                        }
>                                    }
>                                }
>                            }
>
>                            And (Local2, 0x01, WLCD)
>                            ShiftRight (And (Local2, 0x02), 0x01, WCRT)
>                            ShiftRight (And (Local2, 0x04), 0x02, WDVI)
>                            Store (Zero, WTV)
>                            Notify (\_SB.PCI0.GFX0, 0x80)
>                        }
>                        Else
>                        {
>                            If (LEqual (DSWF, 0x02))
>                            {
>                                And (CLCD, ALCD, WLCD)
>                                And (CCRT, ACRT, WCRT)
>                                And (CDVI, ADVI, WDVI)
>                                And (XOr (CTV, 0x01), ATV, WTV)
>                                If (LOr (LOr (WTV, WDVI), LOr (WCRT, WLCD)))
>                                {
>                                    If (LAnd (LAnd (WLCD, WCRT), WTV))
>                                    {
>                                        Store (Zero, WCRT)
>                                    }
>
>                                    If (LAnd (LAnd (WLCD, WDVI), WTV))
>                                    {
>                                        Store (Zero, WDVI)
>                                    }
>
>                                    If (LAnd (LAnd (WCRT, WDVI), WTV))
>                                    {
>                                        Store (Zero, WDVI)
>                                    }
>
>                                    Notify (\_SB.PCI0.GFX0, 0x80)
>                                }
>                            }
>                        }
>                    }
>                }
>
>                Method (UPDD, 0, NotSerialized)
>                {
>                    If (LNot (LLess (\_SB.OSTP (), 0x08)))
>                    {
>                        Notify (\_SB.PCI0, 0x00)
>                    }
>                    Else
>                    {
>                        Notify (\_SB.PCI0.GFX0, 0x00)
>                    }
>
>                    Sleep (0x02EE)
>                    Store (0xFF, DVID)
>                    Store (0x8E, CMD)
>                    Store (Zero, SSMI)
>                }
>
>                Method (_DOS, 1, NotSerialized)
>                {
>                    And (Arg0, 0x07, ADOS)
>                }
>
>                Method (_DOD, 0, NotSerialized)
>                {
>                    Return (Package (0x04)
>                    {
>                        0x00010100, 
>                        0x00010400, 
>                        0x00010200, 
>                        0x00010300
>                    })
>                }
>
>                Device (CRT)
>                {
>                    Method (_ADR, 0, NotSerialized)
>                    {
>                        Return (0x0100)
>                    }
>
>                    Method (_DCS, 0, NotSerialized)
>                    {
>                        If (XCRT ())
>                        {
>                            UPDD ()
>                            Return (Or (0x0D, Or (ShiftLeft (ACRT, 0x04), ShiftLeft (CCRT, 0x01))))
>                        }
>                        Else
>                        {
>                            Return (Zero)
>                        }
>                    }
>
>                    Method (_DGS, 0, NotSerialized)
>                    {
>                        Return (WCRT)
>                    }
>
>                    Method (_DSS, 1, NotSerialized)
>                    {
>                        Noop
>                    }
>                }
>
>                Device (LCD)
>                {
>                    Method (_ADR, 0, NotSerialized)
>                    {
>                        Return (0x0400)
>                    }
>
>                    Method (_DCS, 0, NotSerialized)
>                    {
>                        If (XLCD ())
>                        {
>                            UPDD ()
>                            Return (Or (0x0D, Or (ShiftLeft (ALCD, 0x04), ShiftLeft (CLCD, 0x01))))
>                        }
>                        Else
>                        {
>                            Return (Zero)
>                        }
>                    }
>
>                    Method (_DGS, 0, NotSerialized)
>                    {
>                        Return (WLCD)
>                    }
>
>                    Method (_DSS, 1, NotSerialized)
>                    {
>                        Noop
>                    }
>                }
>
>                Device (TV)
>                {
>                    Method (_ADR, 0, NotSerialized)
>                    {
>                        Return (0x0200)
>                    }
>
>                    Method (_DCS, 0, NotSerialized)
>                    {
>                        If (XTV ())
>                        {
>                            UPDD ()
>                            Return (Or (0x0D, Or (ShiftLeft (ATV, 0x04), ShiftLeft (CTV, 0x01))))
>                        }
>                        Else
>                        {
>                            Return (Zero)
>                        }
>                    }
>
>                    Method (_DGS, 0, NotSerialized)
>                    {
>                        Return (WTV)
>                    }
>
>                    Method (_DSS, 1, NotSerialized)
>                    {
>                        Noop
>                    }
>                }
>
>                Device (DVI)
>                {
>                    Method (_ADR, 0, NotSerialized)
>                    {
>                        Return (0x0300)
>                    }
>
>                    Method (_DCS, 0, NotSerialized)
>                    {
>                        If (XDVI ())
>                        {
>                            UPDD ()
>                            Return (Or (0x0D, Or (ShiftLeft (ADVI, 0x04), ShiftLeft (CDVI, 0x01))))
>                        }
>                        Else
>                        {
>                            Return (Zero)
>                        }
>                    }
>
>                    Method (_DGS, 0, NotSerialized)
>                    {
>                        Return (WDVI)
>                    }
>
>                    Method (_DSS, 1, NotSerialized)
>                    {
>                        Noop
>                    }
>                }
>            }
>
>            Device (PCIB)
>            {
>                Name (_ADR, 0x001E0000)
>                Method (_PRT, 0, NotSerialized)
>                {
>                    If (GPIC)
>                    {
>                        Return (Package (0x05)
>                        {
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x00, 
>                                0x00, 
>                                0x10
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x01, 
>                                0x00, 
>                                0x11
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x02, 
>                                0x00, 
>                                0x10
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0005FFFF, 
>                                0x00, 
>                                0x00, 
>                                0x12
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0005FFFF, 
>                                0x01, 
>                                0x00, 
>                                0x13
>                            }
>                        })
>                    }
>                    Else
>                    {
>                        Return (Package (0x05)
>                        {
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x00, 
>                                \_SB.PCI0.LPCB.LNKA, 
>                                0x00
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x01, 
>                                \_SB.PCI0.LPCB.LNKB, 
>                                0x00
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0003FFFF, 
>                                0x02, 
>                                \_SB.PCI0.LPCB.LNKA, 
>                                0x00
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0005FFFF, 
>                                0x00, 
>                                \_SB.PCI0.LPCB.LNKC, 
>                                0x00
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0x0005FFFF, 
>                                0x01, 
>                                \_SB.PCI0.LPCB.LNKD, 
>                                0x00
>                            }
>                        })
>                    }
>                }
>
>                Name (_PRW, Package (0x02)
>                {
>                    0x0B, 
>                    0x04
>                })
>                Method (_INI, 0, NotSerialized)
>                {
>                    Store (Zero, RI2M)
>                }
>            }
>
>            Device (MBIO)
>            {
>                Name (_HID, EisaId ("PNP0C02"))
>                Method (_STA, 0, NotSerialized)
>                {
>                    Return (0x0F)
>                }
>
>                Name (RSRC, ResourceTemplate ()
>                {
>                    IO (Decode16, 0x0010, 0x0010, 0x01, 0x10)
>                    IO (Decode16, 0x0024, 0x0024, 0x01, 0x02)
>                    IO (Decode16, 0x0028, 0x0028, 0x01, 0x02)
>                    IO (Decode16, 0x002C, 0x002C, 0x01, 0x02)
>                    IO (Decode16, 0x002E, 0x002E, 0x01, 0x02)
>                    IO (Decode16, 0x0030, 0x0030, 0x01, 0x02)
>                    IO (Decode16, 0x0034, 0x0034, 0x01, 0x02)
>                    IO (Decode16, 0x0038, 0x0038, 0x01, 0x02)
>                    IO (Decode16, 0x003C, 0x003C, 0x01, 0x02)
>                    IO (Decode16, 0x0050, 0x0050, 0x01, 0x04)
>                    IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
>                    IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
>                    IO (Decode16, 0x0072, 0x0072, 0x01, 0x06)
>                    IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
>                    IO (Decode16, 0x0090, 0x0090, 0x01, 0x10)
>                    IO (Decode16, 0x00A4, 0x00A4, 0x01, 0x02)
>                    IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
>                    IO (Decode16, 0x00AC, 0x00AC, 0x01, 0x02)
>                    IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x02)
>                    IO (Decode16, 0x00B2, 0x00B2, 0x01, 0x02)
>                    IO (Decode16, 0x00B4, 0x00B4, 0x01, 0x02)
>                    IO (Decode16, 0x00B8, 0x00B8, 0x01, 0x02)
>                    IO (Decode16, 0x00BC, 0x00BC, 0x01, 0x02)
>                    IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
>                    IO (Decode16, 0x0800, 0x0800, 0x01, 0x10)
>                    IO (Decode16, 0x1000, 0x1000, 0x01, 0x80)
>                    IO (Decode16, 0x1080, 0x1080, 0x01, 0x80)
>                    IO (Decode16, 0x1100, 0x1100, 0x01, 0x20)
>                    IO (Decode16, 0x1180, 0x1180, 0x01, 0x40)
>                    IO (Decode16, 0xF800, 0xF800, 0x01, 0x80)
>                    IO (Decode16, 0xF880, 0xF880, 0x01, 0x80)
>                    IO (Decode16, 0xFC00, 0xFC00, 0x01, 0x80)
>                    IO (Decode16, 0xFC80, 0xFC80, 0x01, 0x80)
>                    IO (Decode16, 0xFD00, 0xFD00, 0x01, 0x80)
>                    IO (Decode16, 0xFE00, 0xFE00, 0x01, 0x02)
>                    Memory32Fixed (ReadWrite, 0xF0000000, 0x00004000)
>                    Memory32Fixed (ReadWrite, 0xF0004000, 0x00001000)
>                    Memory32Fixed (ReadWrite, 0xF0005000, 0x00001000)
>                    Memory32Fixed (ReadWrite, 0xFED1C000, 0x00004000)
>                    Memory32Fixed (ReadWrite, 0xFEC00000, 0x00001000)
>                    Memory32Fixed (ReadWrite, 0xFEE00000, 0x00001000)
>                    Memory32Fixed (ReadWrite, 0xFEF00000, 0x00100000)
>                    Memory32Fixed (ReadWrite, 0x000CF000, 0x00001000)
>                    Memory32Fixed (ReadWrite, 0xFFB00000, 0x00100000)
>                })
>                Method (_CRS, 0, Serialized)
>                {
>                    CreateDWordField (RSRC, 0x0170, MBBS)
>                    CreateDWordField (RSRC, 0x0174, MBLN)
>                    CreateDWordField (RSRC, 0x017C, FWBS)
>                    CreateDWordField (RSRC, 0x0180, FWLN)
>                    CreateWordField (RSRC, 0x010A, LPMN)
>                    CreateWordField (RSRC, 0x010C, LPMX)
>                    CreateByteField (RSRC, 0x010F, LPLN)
>                    Store (UMST, MBBS)
>                    Store (UMSZ, MBLN)
>                    If (FWHM)
>                    {
>                        Store (Zero, FWBS)
>                        Store (Zero, FWLN)
>                    }
>
>                    If (LEqual (TPMF, 0x02))
>                    {
>                        Add (0xFD00, 0x0C, LPMN)
>                        Add (0xFD00, 0x0C, LPMX)
>                        Subtract (0x80, 0x0C, LPLN)
>                    }
>
>                    Return (RSRC)
>                }
>            }
>
>            Device (LPCB)
>            {
>                Name (_ADR, 0x001F0000)
>                OperationRegion (LPC0, PCI_Config, 0x40, 0xC0)
>                Field (LPC0, AnyAcc, NoLock, Preserve)
>                {
>                    Offset (0x20), 
>                    PARC,   8, 
>                    PBRC,   8, 
>                    PCRC,   8, 
>                    PDRC,   8, 
>                    Offset (0x28), 
>                    PERC,   8, 
>                    PFRC,   8, 
>                    PGRC,   8, 
>                    PHRC,   8
>                }
>
>                OperationRegion (SIO, SystemIO, 0x2E, 0x02)
>                OperationRegion (FJIO, SystemIO, 0xFD60, 0x15)
>                Scope (\)
>                {
>                    Field (\_SB.PCI0.LPCB.FJIO, ByteAcc, NoLock, Preserve)
>                    {
>                        AIDC,   8, 
>                        ADTC,   8, 
>                        AIDB,   8, 
>                        ADTB,   8, 
>                        AIDA,   8, 
>                        ADTA,   8, 
>                        AIDD,   8, 
>                        ADTD,   8, 
>                        Offset (0x10), 
>                        PMID,   8, 
>                        Offset (0x14), 
>                        PMDT,   8
>                    }
>                }
>
>                OperationRegion (OGIO, SystemIO, 0x1180, 0x3C)
>                Scope (\)
>                {
>                    Field (\_SB.PCI0.LPCB.OGIO, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x0E), 
>                            ,   7, 
>                        PXCL,   1, 
>                        Offset (0x2C), 
>                            ,   1, 
>                        EXPL,   1, 
>                        Offset (0x2D), 
>                        LPOL,   1, 
>                        Offset (0x38), 
>                            ,   1, 
>                        PXRS,   1
>                    }
>                }
>
>                OperationRegion (OPIO, SystemIO, 0x1000, 0x67)
>                Scope (\)
>                {
>                    Field (\_SB.PCI0.LPCB.OPIO, ByteAcc, NoLock, Preserve)
>                    {
>                            ,   14, 
>                        EXWS,   1, 
>                        Offset (0x10), 
>                        Offset (0x11), 
>                        FOCT,   1, 
>                        Offset (0x28), 
>                            ,   9, 
>                        EXPS,   1
>                    }
>                }
>
>                Method (_INI, 0, NotSerialized)
>                {
>                    \_SB.OSTP ()
>                    AINI ()
>                    \_SB.PCI0.LPCB.CMBT.SWCF ()
>                    PRCF ()
>                    If (CondRefOf (\DC1S, Local0))
>                    {
>                        Store (One, RPEN)
>                        Store (B2TC, RPDS)
>                    }
>                }
>
>                Scope (\)
>                {
>                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x09), 
>                        RI1M,   1, 
>                        RI2M,   1, 
>                        RI3M,   1, 
>                        RI4M,   1, 
>                        RI1,    1, 
>                        RI2,    1, 
>                        RI3,    1, 
>                        RI4,    1, 
>                            ,   2, 
>                        CVCL,   1, 
>                            ,   3, 
>                        BLCT,   2, 
>                        Offset (0x20), 
>                        G5P0,   8, 
>                        G5C0,   8, 
>                        G3P0,   8, 
>                        G3C0,   8, 
>                        Offset (0x40), 
>                        SSF0,   8, 
>                        SSF1,   8, 
>                        SSM0,   8, 
>                        SSM1,   8, 
>                        SSI0,   8, 
>                        SSTM,   8, 
>                        SSF2,   8, 
>                        SSM2,   8, 
>                        SSI1,   8, 
>                        Offset (0x52), 
>                        G3P1,   8, 
>                        G3C1,   8, 
>                        G3P2,   8, 
>                        G3C2,   8, 
>                        QSWC,   8, 
>                        Offset (0x60), 
>                        SSS0,   8, 
>                        SSS1,   8
>                    }
>
>                    IndexField (AIDB, ADTB, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x29), 
>                        BRCL,   8, 
>                        LCDB,   8, 
>                        Offset (0x30), 
>                        LCDC,   8
>                    }
>
>                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
>                    {
>                        TASF,   1, 
>                        TBSF,   1, 
>                        B1SU,   1, 
>                        B1SD,   1, 
>                        B2SU,   1, 
>                        B2SD,   1, 
>                        Offset (0x02), 
>                            ,   4, 
>                        VSTB,   1, 
>                        Offset (0x05), 
>                            ,   6, 
>                        ACPW,   1, 
>                        Offset (0x20), 
>                        BCTL,   8, 
>                        Offset (0x23), 
>                        TAF,    1, 
>                        TASM,   1, 
>                            ,   2, 
>                        TBF,    1, 
>                        TBSM,   1, 
>                        Offset (0x24), 
>                        TIMA,   8, 
>                        TIMB,   8, 
>                        Offset (0x28), 
>                        CDLP,   8, 
>                        HDLP,   8, 
>                        FDLP,   8, 
>                        Offset (0x4E), 
>                        B1UM,   1, 
>                        B1DM,   1, 
>                            ,   1, 
>                        B1TC,   1, 
>                        B2UM,   1, 
>                        B2DM,   1, 
>                            ,   1, 
>                        B2TC,   1, 
>                        BAPC,   6
>                    }
>
>                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
>                    {
>                        STAE,   8
>                    }
>
>                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x80), 
>                        GIDI,   8, 
>                        GIDC,   8, 
>                        GIDO,   8, 
>                        Offset (0x90), 
>                        G3SI,   8, 
>                        G3SC,   8, 
>                        G3SO,   8, 
>                        G3SM,   8, 
>                        Offset (0xA0), 
>                        WOXF,   8, 
>                        WOXE,   8, 
>                        WOXD,   8, 
>                        WOXS,   8, 
>                        Offset (0xB0), 
>                        AMPV,   6
>                    }
>                }
>
>                Scope (\)
>                {
>                    IndexField (PMID, PMDT, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0xA0), 
>                        UPPR,   1, 
>                        ERRO,   1, 
>                        PASS,   1, 
>                        PSOK,   1, 
>                        PSNG,   1, 
>                        TOUT,   1, 
>                        SIRN,   1, 
>                        STSC,   1, 
>                        OVFL,   1, 
>                        LWMD,   1, 
>                        TALM,   1, 
>                        EMGC,   1, 
>                        OCNT,   4, 
>                        Offset (0xC0), 
>                        Offset (0xC1), 
>                        B1P,    1, 
>                        B2P,    1, 
>                        B1C,    1, 
>                        B2C,    1, 
>                        B1ER,   1, 
>                        B2ER,   1, 
>                        PKSH,   1, 
>                        CMB,    1, 
>                        B1CP,   8, 
>                        B2CP,   8, 
>                        BAVG,   8, 
>                        B1VH,   8, 
>                        B1VL,   8, 
>                        B2VH,   8, 
>                        B2VL,   8, 
>                        B1TM,   8, 
>                        B2TM,   8, 
>                        B1CH,   8, 
>                        B1CL,   8, 
>                        B2CH,   8, 
>                        B2CL,   8, 
>                        BTMH,   8, 
>                        BTML,   8, 
>                        B1LH,   8, 
>                        B1LL,   8, 
>                        B2LH,   8, 
>                        B2LL,   8, 
>                        B1ID,   4, 
>                        B1NO,   4, 
>                        B2ID,   4, 
>                        B2NO,   4, 
>                        B1DV,   8, 
>                        B2DV,   8, 
>                        B1DH,   8, 
>                        B1DL,   8, 
>                        B2DH,   8, 
>                        B2DL,   8, 
>                        TBSI,   8, 
>                        TBSH,   8, 
>                        TBSL,   8
>                    }
>                }
>
>                Scope (\)
>                {
>                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x22), 
>                            ,   4, 
>                        SOUT,   1, 
>                        Offset (0x52), 
>                        BRST,   1, 
>                            ,   1, 
>                        BY1C,   2
>                    }
>
>                    IndexField (AIDC, ADTC, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x4F), 
>                        BY1O,   1, 
>                        BY2O,   1
>                    }
>
>                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x80), 
>                        BY1I,   4
>                    }
>
>                    IndexField (PMID, PMDT, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0xE0), 
>                        BHDD,   1, 
>                        BOPT,   1
>                    }
>                }
>
>                Method (AINI, 0, NotSerialized)
>                {
>                    And (SSM1, 0xCF, SSM1)
>                    If (TTIM)
>                    {
>                        Store (Zero, TMBF)
>                        Store (0x01, TBSM)
>                        Store (0x00, TBSF)
>                        Store (0xF0, TIMB)
>                    }
>                    Else
>                    {
>                        Store (Zero, TBSM)
>                    }
>
>                    Store (LWMD, PLWM)
>                    Store (TALM, PTAL)
>                    Store (0x95, CMD)
>                    Or (PLWM, ShiftLeft (PTAL, 0x01), DVID)
>                    Store (Zero, SSMI)
>                    If (LAnd (TALM, LNot (ACPW)))
>                    {
>                        Store (One, FOCT)
>                    }
>                    Else
>                    {
>                        Store (Zero, FOCT)
>                    }
>                }
>
>                Device (TPM)
>                {
>                    Name (_HID, EisaId ("IFX0101"))
>                    Name (_UID, 0x01)
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x004E, 0x004E, 0x01, 0x02)
>                        IO (Decode16, 0xFD00, 0xFD00, 0x01, 0x0C)
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (TPMF)
>                        {
>                            If (LEqual (TPMF, 0x02))
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x00)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>                }
>
>                Name (RGSI, 0x19)
>                Device (FJEX)
>                {
>                    Name (_HID, "FUJ02B1")
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Method (RBLL, 0, NotSerialized)
>                    {
>                        Return (BLLM)
>                    }
>
>                    Scope (\)
>                    {
>                        Name (LBLL, 0x00)
>                        Name (LLCD, Ones)
>                    }
>
>                    Method (GBLL, 0, NotSerialized)
>                    {
>                        Store (LBLL, Local2)
>                        Store (LCDB, Local1)
>                        If (LNot (LEqual (LLCD, Local1)))
>                        {
>                            Store (Local1, LLCD)
>                            Name (BBCT, Buffer (BLLM) {})
>                            Store (BLLT, BBCT)
>                            Store (BLLM, Local0)
>                            While (Local0)
>                            {
>                                Decrement (Local0)
>                                If (LEqual (GBUF (BBCT, Local0), Local1))
>                                {
>                                    Store (Local0, Local2)
>                                    Store (Local0, LBLL)
>                                    Store (Zero, Local0)
>                                }
>                            }
>                        }
>
>                        If (BHKF)
>                        {
>                            Store (Zero, BHKF)
>                            Or (Local2, 0x80000000, Local2)
>                        }
>
>                        Return (Local2)
>                    }
>
>                    Method (SBLL, 1, NotSerialized)
>                    {
>                        If (NGTF)
>                        {
>                            Store (Arg0, LSBL)
>                            Return (Zero)
>                        }
>
>                        If (LLess (Arg0, BLLM))
>                        {
>                            Name (BBCT, Buffer (BLLM) {})
>                            Store (BLLT, BBCT)
>                            CreateByteField (BBCT, Arg0, BLL0)
>                            Store (BLL0, LCDB)
>                            Store (Arg0, DVID)
>                            Store (0x82, CMD)
>                            Store (Zero, SSMI)
>                        }
>                    }
>
>                    Method (GBUF, 2, NotSerialized)
>                    {
>                        CreateByteField (Arg0, Arg1, BLL0)
>                        Return (BLL0)
>                    }
>
>                    Method (GMOU, 0, NotSerialized)
>                    {
>                        Store (0x02, DVID)
>                        Store (0x91, CMD)
>                        Store (Zero, SSMI)
>                        Store (DVID, Local0)
>                        If (MHKF)
>                        {
>                            Store (Zero, MHKF)
>                            Or (Local0, 0x80000000, Local0)
>                        }
>
>                        Return (Local0)
>                    }
>
>                    Method (SMOU, 1, NotSerialized)
>                    {
>                        If (LNot (LGreater (Arg0, One)))
>                        {
>                            Store (Arg0, DVID)
>                            Store (0x91, CMD)
>                            Store (Zero, SSMI)
>                        }
>                    }
>
>                    Method (GHKS, 0, NotSerialized)
>                    {
>                        Return (AHKF)
>                    }
>
>                    Method (GSIF, 0, NotSerialized)
>                    {
>                        If (IMTF)
>                        {
>                            Or (RGSI, 0x08, RGSI)
>                        }
>                        Else
>                        {
>                            And (RGSI, 0xFFFFFFF7, RGSI)
>                        }
>
>                        Return (RGSI)
>                    }
>                }
>
>                Scope (\)
>                {
>                    Name (BTWK, Zero)
>                    Name (BTBL, Zero)
>                    Name (BTST, Zero)
>                    IndexField (AIDA, ADTA, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x20), 
>                            ,   5, 
>                        ABEX,   1, 
>                        Offset (0x44), 
>                            ,   2, 
>                        WLSW,   1, 
>                        Offset (0x52), 
>                            ,   1, 
>                        WLRF,   1, 
>                        Offset (0x54), 
>                            ,   3, 
>                        ABAT,   1
>                    }
>
>                    IndexField (AIDD, ADTD, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x92), 
>                            ,   3, 
>                        ABON,   1, 
>                            ,   1, 
>                        ABDT,   1
>                    }
>
>                    IndexField (PMID, PMDT, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0xE0), 
>                            ,   7, 
>                        ABLC,   1
>                    }
>                }
>
>                Device (CMBT)
>                {
>                    Name (_HID, "FUJ02E1")
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (ABEX)
>                        {
>                            Return (0x00)
>                        }
>                        Else
>                        {
>                            If (BLEN)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        Store (Zero, BTWK)
>                        Store (Zero, BTBL)
>                    }
>
>                    Method (INFO, 0, NotSerialized)
>                    {
>                        If (LEqual (_STA (), 0x0F))
>                        {
>                            Store (0x97, Local0)
>                        }
>                        Else
>                        {
>                            Store (0x90, Local0)
>                        }
>
>                        Or (Local0, 0x08, Local0)
>                        Return (Local0)
>                    }
>
>                    Method (STAT, 0, NotSerialized)
>                    {
>                        Store (0x00, Local0)
>                        If (ABON)
>                        {
>                            Or (Local0, 0x02, Local0)
>                        }
>
>                        If (BTWK)
>                        {
>                            Or (Local0, 0x04, Local0)
>                        }
>
>                        If (WLRF)
>                        {
>                            Or (Local0, 0x08, Local0)
>                        }
>
>                        If (LNot (ABAT))
>                        {
>                            Or (Local0, 0x10, Local0)
>                        }
>
>                        If (ABLC)
>                        {
>                            Or (Local0, 0x20, Local0)
>                        }
>
>                        If (BTBL)
>                        {
>                            Or (Local0, 0x80, Local0)
>                        }
>
>                        Return (Local0)
>                    }
>
>                    Method (CNTL, 2, NotSerialized)
>                    {
>                        If (And (Arg0, 0x02))
>                        {
>                            If (LEqual (_STA (), 0x0F))
>                            {
>                                If (And (Arg1, 0x02))
>                                {
>                                    Store (One, ABON)
>                                }
>                                Else
>                                {
>                                    Store (Zero, ABON)
>                                }
>                            }
>                        }
>
>                        If (And (Arg0, 0x04))
>                        {
>                            If (LEqual (_STA (), 0x0F))
>                            {
>                                ShiftRight (And (Arg1, 0x04), 0x02, BTWK)
>                            }
>                        }
>
>                        If (LAnd (And (Arg0, 0x08), WLEN))
>                        {
>                            ShiftRight (And (Arg1, 0x08), 0x03, WLRF)
>                        }
>
>                        If (And (Arg0, 0x10))
>                        {
>                            If (And (Arg1, 0x10))
>                            {
>                                Store (Zero, ABAT)
>                            }
>                            Else
>                            {
>                                Store (One, ABAT)
>                            }
>                        }
>
>                        If (And (Arg0, 0x20))
>                        {
>                            ShiftRight (And (Arg1, 0x20), 0x05, ABLC)
>                        }
>
>                        If (And (Arg0, 0x80))
>                        {
>                            ShiftRight (And (Arg1, 0x80), 0x07, BTBL)
>                            If (BTBL)
>                            {
>                                If (WLSW)
>                                {
>                                    Notify (CMBT, 0x81)
>                                }
>                                Else
>                                {
>                                    Notify (CMBT, 0x82)
>                                }
>                            }
>                        }
>                    }
>
>                    Method (SWCF, 0, NotSerialized)
>                    {
>                        If (BTBL)
>                        {
>                            If (WLSW)
>                            {
>                                Notify (CMBT, 0x81)
>                            }
>                            Else
>                            {
>                                Notify (CMBT, 0x82)
>                            }
>                        }
>                        Else
>                        {
>                            If (WLSW)
>                            {
>                                If (LEqual (_STA (), 0x0F))
>                                {
>                                    Store (One, ABON)
>                                    Store (Zero, ABDT)
>                                    Store (One, ABLC)
>                                    If (WLEN)
>                                    {
>                                        Store (One, WLRF)
>                                    }
>                                    Else
>                                    {
>                                        Store (Zero, WLRF)
>                                    }
>
>                                    Store (Zero, ABAT)
>                                }
>                                Else
>                                {
>                                    Store (Zero, ABON)
>                                    Store (Zero, ABDT)
>                                    If (WLEN)
>                                    {
>                                        Store (One, WLRF)
>                                        Store (One, ABLC)
>                                    }
>                                    Else
>                                    {
>                                        Store (Zero, WLRF)
>                                        Store (Zero, ABLC)
>                                    }
>
>                                    Store (One, ABAT)
>                                }
>                            }
>                            Else
>                            {
>                                Store (Zero, ABON)
>                                Store (Zero, ABDT)
>                                Store (Zero, WLRF)
>                                Store (Zero, ABLC)
>                                Store (One, ABAT)
>                            }
>                        }
>                    }
>
>                    Method (BPTS, 1, NotSerialized)
>                    {
>                        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
>                        {
>                            Store (WLRF, BTST)
>                            Or (ShiftLeft (ABAT, 0x01), BTST, BTST)
>                            Or (ShiftLeft (WLSW, 0x02), BTST, BTST)
>                            Or (ShiftLeft (ABON, 0x03), BTST, BTST)
>                            Or (ShiftLeft (ABDT, 0x04), BTST, BTST)
>                            If (LAnd (LEqual (_STA (), 0x0F), LAnd (BTWK, WLSW)))
>                            {
>                                Store (Zero, WLRF)
>                                Store (Zero, ABAT)
>                            }
>                            Else
>                            {
>                                Store (Zero, WLRF)
>                                Store (One, ABAT)
>                            }
>
>                            Store (Zero, ABLC)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x05))
>                            {
>                                Store (Zero, ABON)
>                                Store (Zero, ABDT)
>                                Store (Zero, WLRF)
>                                Store (Zero, ABLC)
>                                Store (One, ABAT)
>                            }
>                        }
>                    }
>
>                    Method (BWAK, 1, NotSerialized)
>                    {
>                        If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04)))
>                        {
>                            Store (0x94, CMD)
>                            Store (Zero, SSMI)
>                            If (WBLT)
>                            {
>                                Notify (\_SB.PWRB, 0x02)
>                            }
>
>                            Store (And (BTST, 0x01), WLRF)
>                            ShiftRight (And (BTST, 0x02), 0x01, ABAT)
>                            ShiftRight (And (BTST, 0x08), 0x03, ABON)
>                            ShiftRight (And (BTST, 0x10), 0x04, ABDT)
>                            If (LAnd (WLSW, LOr (WLEN, ABON)))
>                            {
>                                Store (One, ABLC)
>                            }
>
>                            If (LNot (LEqual (ShiftRight (And (BTST, 0x04), 0x02), WLSW)))
>                            {
>                                SWCF ()
>                            }
>                        }
>                    }
>                }
>
>                Device (DMAC)
>                {
>                    Name (_HID, EisaId ("PNP0200"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
>                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
>                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
>                        DMA (Compatibility, NotBusMaster, Transfer16) {4}
>                    })
>                }
>
>                Device (TIME)
>                {
>                    Name (_HID, EisaId ("PNP0100"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
>                        IRQNoFlags () {0}
>                    })
>                }
>
>                Device (PIC)
>                {
>                    Name (_HID, EisaId ("PNP0000"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
>                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
>                        IRQNoFlags () {2}
>                    })
>                }
>
>                Device (RTC)
>                {
>                    Name (_HID, EisaId ("PNP0B00"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x02)
>                        IRQNoFlags () {8}
>                    })
>                }
>
>                Device (SPKR)
>                {
>                    Name (_HID, EisaId ("PNP0800"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
>                    })
>                }
>
>                Device (MATH)
>                {
>                    Name (_HID, EisaId ("PNP0C04"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
>                        IRQNoFlags () {13}
>                    })
>                }
>
>                Device (KBC)
>                {
>                    Name (R101, 0x0303D041)
>                    Name (R106, 0x2003D041)
>                    Method (_HID, 0, NotSerialized)
>                    {
>                        If (SIDF)
>                        {
>                            Return (R101)
>                        }
>                        Else
>                        {
>                            Return (R106)
>                        }
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
>                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
>                        IRQNoFlags () {1}
>                    })
>                }
>
>                Device (PS2M)
>                {
>                    Name (_HID, EisaId ("PNP0F13"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IRQNoFlags () {12}
>                    })
>                }
>
>                Device (FWH)
>                {
>                    Name (_HID, EisaId ("INT0800"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (FWHM)
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        Memory32Fixed (ReadWrite, 0xFFB00000, 0x00100000)
>                    })
>                }
>
>                Scope (\_SB.PCI0.LPCB)
>                {
>                    OperationRegion (LIOD, PCI_Config, 0x80, 0x0A)
>                }
>
>                Field (LIOD, AnyAcc, NoLock, Preserve)
>                {
>                    CADR,   3, 
>                        ,   1, 
>                    CBDR,   3, 
>                    Offset (0x01), 
>                    LPDR,   2, 
>                        ,   2, 
>                    FDDR,   1, 
>                    Offset (0x02), 
>                    CALE,   1, 
>                    CBLE,   1, 
>                    LPLE,   1, 
>                    FDLE,   1, 
>                    Offset (0x08), 
>                    GD2E,   1, 
>                        ,   3, 
>                    GD2B,   12
>                }
>
>                Name (TCOM, Package (0x08)
>                {
>                    0x03F8, 
>                    0x02F8, 
>                    0x0220, 
>                    0x0228, 
>                    0x0238, 
>                    0x02E8, 
>                    0x0338, 
>                    0x03E8
>                })
>                Name (TLPT, Package (0x03)
>                {
>                    0x0378, 
>                    0x0278, 
>                    0x03BC
>                })
>                Name (TFDD, Package (0x02)
>                {
>                    0x03F0, 
>                    0x0370
>                })
>                Method (DENA, 3, Serialized)
>                {
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
>                        If (LNot (LEqual (Local0, Ones)))
>                        {
>                            Store (Local0, CADR)
>                            Store (One, CALE)
>                        }
>                    }
>                    Else
>                    {
>                        If (LOr (LEqual (Arg0, 0x01), LEqual (Arg0, 0x02)))
>                        {
>                            Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
>                            If (LNot (LEqual (Local0, Ones)))
>                            {
>                                Store (Local0, CBDR)
>                                Store (One, CBLE)
>                            }
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x03))
>                            {
>                                Store (Match (TCOM, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
>                                If (LNot (LEqual (Local0, Ones)))
>                                {
>                                    Store (Local0, CBDR)
>                                    Store (One, CBLE)
>                                    ShiftRight (Arg2, 0x04, GD2B)
>                                    Store (One, GD2E)
>                                }
>                            }
>                            Else
>                            {
>                                If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x05)))
>                                {
>                                    Store (Match (TLPT, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
>                                    If (LNot (LEqual (Local0, Ones)))
>                                    {
>                                        Store (Local0, LPDR)
>                                        Store (One, LPLE)
>                                    }
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x07))
>                                    {
>                                        Store (Match (TFDD, MEQ, Arg1, MTR, 0x00, 0x00), Local0)
>                                        If (LNot (LEqual (Local0, Ones)))
>                                        {
>                                            Store (Local0, FDDR)
>                                            Store (One, FDLE)
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>                }
>
>                Method (DDIS, 1, Serialized)
>                {
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        Store (Zero, CALE)
>                    }
>                    Else
>                    {
>                        If (LOr (LEqual (Arg0, 0x01), LEqual (Arg0, 0x02)))
>                        {
>                            Store (Zero, CBLE)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x03))
>                            {
>                                Store (Zero, CBLE)
>                                Store (Zero, GD2E)
>                            }
>                            Else
>                            {
>                                If (LOr (LEqual (Arg0, 0x04), LEqual (Arg0, 0x05)))
>                                {
>                                    Store (Zero, LPLE)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x07))
>                                    {
>                                        Store (Zero, FDLE)
>                                    }
>                                }
>                            }
>                        }
>                    }
>                }
>
>                Field (SIO, ByteAcc, NoLock, Preserve)
>                {
>                    SIID,   8, 
>                    SIDT,   8
>                }
>
>                IndexField (SIID, SIDT, ByteAcc, NoLock, Preserve)
>                {
>                        ,   3, 
>                    FDCP,   1, 
>                    Offset (0x01), 
>                        ,   2, 
>                    PPP,    1, 
>                    PPM,    1, 
>                    Offset (0x02), 
>                        ,   3, 
>                    U1P,    1, 
>                        ,   3, 
>                    U2P,    1, 
>                    Offset (0x04), 
>                    PPEM,   2, 
>                    Offset (0x0C), 
>                    U2MD,   6, 
>                    Offset (0x20), 
>                    FDA,    8, 
>                        ,   2, 
>                    ETOS,   1, 
>                    Offset (0x23), 
>                    PPA,    8, 
>                    U1A,    8, 
>                    U2A,    8, 
>                    PPD,    4, 
>                    FDD,    4, 
>                    PPI,    4, 
>                    FDI,    4, 
>                    U2I,    4, 
>                    U1I,    4, 
>                    Offset (0x2B), 
>                    IRA,    8, 
>                    IRD,    4
>                }
>
>                Mutex (MTXS, 0x00)
>                Method (ENTR, 0, NotSerialized)
>                {
>                    Acquire (MTXS, 0xFFFF)
>                    Store (0x55, SIID)
>                }
>
>                Method (EXIT, 0, NotSerialized)
>                {
>                    Store (0xAA, SIID)
>                    Release (MTXS)
>                }
>
>                Method (SETR, 5, NotSerialized)
>                {
>                    ENTR ()
>                    If (Arg3)
>                    {
>                        Subtract (FindSetRightBit (Arg3), One, Local0)
>                    }
>                    Else
>                    {
>                        Store (Zero, Local0)
>                    }
>
>                    If (Arg4)
>                    {
>                        Subtract (FindSetRightBit (Arg4), One, Local1)
>                    }
>                    Else
>                    {
>                        Store (0x0F, Local1)
>                    }
>
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        ShiftRight (Arg1, 0x02, U1A)
>                        Store (Local0, U1I)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            ShiftRight (Arg1, 0x02, U2A)
>                            Store (Local0, U2I)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                ShiftRight (Arg1, 0x02, U2A)
>                                Store (Local0, U2I)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    ShiftRight (Arg1, 0x02, U2A)
>                                    ShiftRight (Arg2, 0x03, IRA)
>                                    Store (Local0, U2I)
>                                    Store (Local1, IRD)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        ShiftRight (Arg1, 0x02, PPA)
>                                        Store (Local0, PPI)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            ShiftRight (Arg1, 0x02, PPA)
>                                            Store (Local0, PPI)
>                                            Store (Local1, PPD)
>                                        }
>                                        Else
>                                        {
>                                            If (LEqual (Arg0, 0x07))
>                                            {
>                                                ShiftRight (Arg1, 0x02, FDA)
>                                                Store (Local0, FDI)
>                                                Store (Local1, FDD)
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    EXIT ()
>                    If (Arg1)
>                    {
>                        If (CondRefOf (DENA, Local0))
>                        {
>                            DENA (Arg0, Arg1, Arg2)
>                        }
>
>                        SETM (Arg0)
>                    }
>                    Else
>                    {
>                        If (CondRefOf (DDIS, Local0))
>                        {
>                            DDIS (Arg0)
>                        }
>                    }
>                }
>
>                Method (GETR, 5, NotSerialized)
>                {
>                    ENTR ()
>                    Store (Zero, Local0)
>                    Store (0x0F, Local1)
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        ShiftLeft (U1A, 0x02, Arg1)
>                        Store (U1I, Local0)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            ShiftLeft (U2A, 0x02, Arg1)
>                            Store (U2I, Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                ShiftLeft (U2A, 0x02, Arg1)
>                                Store (U2I, Local0)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    ShiftLeft (U2A, 0x02, Arg1)
>                                    ShiftLeft (IRA, 0x03, Arg2)
>                                    Store (U2I, Local0)
>                                    Store (IRD, Local1)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        ShiftLeft (PPA, 0x02, Arg1)
>                                        Store (PPI, Local0)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            ShiftLeft (PPA, 0x02, Arg1)
>                                            Store (PPI, Local0)
>                                            Store (PPD, Local1)
>                                        }
>                                        Else
>                                        {
>                                            If (LEqual (Arg0, 0x07))
>                                            {
>                                                ShiftLeft (FDA, 0x02, Arg1)
>                                                Store (FDI, Local0)
>                                                Store (FDD, Local1)
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    If (Local0)
>                    {
>                        ShiftLeft (One, Local0, Arg3)
>                    }
>                    Else
>                    {
>                        Store (Zero, Arg3)
>                    }
>
>                    If (LNot (LEqual (Local1, 0x0F)))
>                    {
>                        ShiftLeft (One, Local1, Arg4)
>                    }
>                    Else
>                    {
>                        Store (Zero, Arg4)
>                    }
>
>                    EXIT ()
>                }
>
>                Method (SETM, 1, NotSerialized)
>                {
>                    ENTR ()
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        Store (One, U1P)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            Store (0x06, U2MD)
>                            Store (One, U2P)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                Store (0x0E, U2MD)
>                                Store (One, U2P)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    Store (0x0E, U2MD)
>                                    Store (One, U2P)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        If (LEqual (PPF, One))
>                                        {
>                                            Store (One, PPM)
>                                        }
>                                        Else
>                                        {
>                                            Store (Zero, PPM)
>                                            Store (Zero, PPEM)
>                                        }
>
>                                        Store (One, PPP)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            Store (Zero, PPM)
>                                            Store (0x02, PPEM)
>                                            Store (One, PPP)
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    EXIT ()
>                }
>
>                Method (SETP, 2, NotSerialized)
>                {
>                    ENTR ()
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        Store (Arg1, U1P)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            Store (Arg1, U2P)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                Store (Arg1, U2P)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    Store (Arg1, U2P)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        Store (Arg1, PPP)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            Store (Arg1, PPP)
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    EXIT ()
>                }
>
>                Method (GETP, 1, NotSerialized)
>                {
>                    Store (Zero, Local0)
>                    ENTR ()
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        Store (U1P, Local0)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            Store (U2P, Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                Store (U2P, Local0)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    Store (U2P, Local0)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        Store (PPP, Local0)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            Store (PPP, Local0)
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    EXIT ()
>                    Return (Local0)
>                }
>
>                Method (CHKM, 1, NotSerialized)
>                {
>                    If (LEqual (Arg0, 0x00))
>                    {
>                        If (SPAF)
>                        {
>                            Return (One)
>                        }
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            If (LEqual (SPBF, 0x03))
>                            {
>                                Return (One)
>                            }
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                If (LEqual (SPBF, One))
>                                {
>                                    Return (One)
>                                }
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    If (LEqual (SPBF, 0x02))
>                                    {
>                                        Return (One)
>                                    }
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        If (LOr (LEqual (PPF, One), LEqual (PPF, 0x02)))
>                                        {
>                                            Return (One)
>                                        }
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x05))
>                                        {
>                                            If (LEqual (PPF, 0x03))
>                                            {
>                                                Return (One)
>                                            }
>                                        }
>                                        Else
>                                        {
>                                            If (LEqual (Arg0, 0x07))
>                                            {
>                                                If (FDCF)
>                                                {
>                                                    Return (One)
>                                                }
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                        }
>                    }
>
>                    Return (Zero)
>                }
>
>                Device (UAR1)
>                {
>                    Name (_HID, EisaId ("PNP0501"))
>                    Name (_UID, 0x01)
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        IRQNoFlags () {4}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                        }
>                        EndDependentFn ()
>                        IRQNoFlags () {3,4,10,11}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x00))
>                        {
>                            GETR (0x00, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateWordField (RSRC, 0x09, IRQ1)
>                        GETR (0x00, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        Store (Local2, IRQ1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x09, IRQ1)
>                        SETR (0x00, IO11, Zero, IRQ1, Zero)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x00, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x00))
>                        {
>                            SETM (0x00)
>                        }
>                    }
>                }
>
>                Device (UAR2)
>                {
>                    Name (_HID, EisaId ("PNP0501"))
>                    Name (_UID, 0x02)
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        IRQNoFlags () {4}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                        }
>                        EndDependentFn ()
>                        IRQNoFlags () {3,4,10,11}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x01))
>                        {
>                            GETR (0x01, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateWordField (RSRC, 0x09, IRQ1)
>                        GETR (0x01, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        Store (Local2, IRQ1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x09, IRQ1)
>                        SETR (0x01, IO11, Zero, IRQ1, Zero)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x01, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x01))
>                        {
>                            SETM (0x01)
>                        }
>                    }
>                }
>
>                Device (IRDA)
>                {
>                    Name (_HID, EisaId ("PNP0510"))
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        IRQNoFlags () {3}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                        }
>                        EndDependentFn ()
>                        IRQNoFlags () {3,4,10,11}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x02))
>                        {
>                            GETR (0x02, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateWordField (RSRC, 0x09, IRQ1)
>                        GETR (0x02, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        Store (Local2, IRQ1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x09, IRQ1)
>                        SETR (0x02, IO11, Zero, IRQ1, Zero)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x02, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x02))
>                        {
>                            SETM (0x02)
>                        }
>                    }
>
>                    Method (_PSC, 0, NotSerialized)
>                    {
>                        If (GETP (0x02))
>                        {
>                            Return (Zero)
>                        }
>                        Else
>                        {
>                            Return (0x03)
>                        }
>                    }
>
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        SETP (0x02, One)
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        SETR (0x02, Zero, Zero, Zero, Zero)
>                        SETP (0x02, Zero)
>                    }
>                }
>
>                Device (FIR)
>                {
>                    Name (_HID, EisaId ("SMCF010"))
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        IO (Decode16, 0x0400, 0x0400, 0x80, 0x40)
>                        IRQNoFlags () {4}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                        }
>                        EndDependentFn ()
>                        IO (Decode16, 0x0400, 0x0580, 0x80, 0x40)
>                        IRQNoFlags () {3,4,10,11}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x03))
>                        {
>                            GETR (0x03, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateWordField (RSRC, 0x0A, IO21)
>                        CreateWordField (RSRC, 0x0C, IO22)
>                        CreateWordField (RSRC, 0x11, IRQ1)
>                        CreateByteField (RSRC, 0x14, DMA1)
>                        GETR (0x03, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        Store (Local1, IO21)
>                        Store (Local1, IO22)
>                        Store (Local2, IRQ1)
>                        Store (Local3, DMA1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x0C, IO21)
>                        CreateWordField (Arg0, 0x11, IRQ1)
>                        CreateByteField (Arg0, 0x14, DMA1)
>                        SETR (0x03, IO11, IO21, IRQ1, DMA1)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x03, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x03))
>                        {
>                            SETM (0x03)
>                        }
>                    }
>
>                    Method (_PSC, 0, NotSerialized)
>                    {
>                        If (GETP (0x03))
>                        {
>                            Return (Zero)
>                        }
>                        Else
>                        {
>                            Return (0x03)
>                        }
>                    }
>
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        SETP (0x03, One)
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        SETR (0x03, Zero, Zero, Zero, Zero)
>                        SETP (0x03, Zero)
>                    }
>                }
>
>                Device (LPT)
>                {
>                    Name (_HID, EisaId ("PNP0400"))
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                        IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                        IRQNoFlags () {7}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x04))
>                        {
>                            GETR (0x04, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateByteField (RSRC, 0x07, IO1L)
>                        CreateWordField (RSRC, 0x0A, IO21)
>                        CreateWordField (RSRC, 0x0C, IO22)
>                        CreateWordField (RSRC, 0x11, IRQ1)
>                        GETR (0x04, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        If (LEqual (Local0, 0x03BC))
>                        {
>                            Store (0x04, IO1L)
>                        }
>                        Else
>                        {
>                            Store (0x08, IO1L)
>                        }
>
>                        Add (Local0, 0x0400, IO21)
>                        Store (IO21, IO22)
>                        Store (Local2, IRQ1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x11, IRQ1)
>                        SETR (0x04, IO11, Zero, IRQ1, Zero)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x04, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x04))
>                        {
>                            SETM (0x04)
>                        }
>                    }
>                }
>
>                Device (ECP)
>                {
>                    Name (_HID, EisaId ("PNP0401"))
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                        IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                        IRQNoFlags () {7}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
>                            IRQNoFlags () {7}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
>                            IRQNoFlags () {5}
>                        }
>                        EndDependentFn ()
>                        DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x05))
>                        {
>                            GETR (0x05, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateByteField (RSRC, 0x07, IO1L)
>                        CreateWordField (RSRC, 0x0A, IO21)
>                        CreateWordField (RSRC, 0x0C, IO22)
>                        CreateWordField (RSRC, 0x11, IRQ1)
>                        CreateByteField (RSRC, 0x14, DMA1)
>                        GETR (0x05, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        If (LEqual (Local0, 0x03BC))
>                        {
>                            Store (0x04, IO1L)
>                        }
>                        Else
>                        {
>                            Store (0x08, IO1L)
>                        }
>
>                        Add (Local0, 0x0400, IO21)
>                        Store (IO21, IO22)
>                        Store (Local2, IRQ1)
>                        Store (Local3, DMA1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x11, IRQ1)
>                        CreateByteField (Arg0, 0x14, DMA1)
>                        SETR (0x05, IO11, Zero, IRQ1, DMA1)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x05, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        If (CHKM (0x05))
>                        {
>                            SETM (0x05)
>                        }
>                    }
>                }
>
>                Device (FDC)
>                {
>                    Name (_HID, EisaId ("PNP0700"))
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
>                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
>                        IRQNoFlags () {6}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                    })
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
>                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
>                        IRQNoFlags () {6}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (CHKM (0x07))
>                        {
>                            GETR (0x07, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                            If (Local0)
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO11)
>                        CreateWordField (RSRC, 0x04, IO12)
>                        CreateWordField (RSRC, 0x0A, IO21)
>                        CreateWordField (RSRC, 0x0C, IO22)
>                        CreateWordField (RSRC, 0x11, IRQ1)
>                        CreateByteField (RSRC, 0x14, DMA1)
>                        GETR (0x07, RefOf (Local0), RefOf (Local1), RefOf (Local2), RefOf (Local3))
>                        Store (Local0, IO11)
>                        Store (Local0, IO12)
>                        Add (Local0, 0x07, IO21)
>                        Store (IO21, IO22)
>                        Store (Local2, IRQ1)
>                        Store (Local3, DMA1)
>                        Return (RSRC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x04, IO11)
>                        CreateWordField (Arg0, 0x11, IRQ1)
>                        CreateByteField (Arg0, 0x14, DMA1)
>                        SETR (0x07, IO11, Zero, IRQ1, DMA1)
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        SETR (0x07, Zero, Zero, Zero, Zero)
>                    }
>
>                    Method (_FDE, 0, NotSerialized)
>                    {
>                        If (FDS0)
>                        {
>                            Store (0x01, Index (FDEB, 0x00))
>                        }
>
>                        If (FDS1)
>                        {
>                            Store (0x01, Index (FDEB, 0x04))
>                        }
>
>                        Return (FDEB)
>                    }
>
>                    Name (FDEB, Buffer (0x14)
>                    {
>                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
>                        0x00, 0x00, 0x00, 0x00
>                    })
>                    Device (DRV0)
>                    {
>                        Name (_ADR, 0x00)
>                        Method (_STA, 0, NotSerialized)
>                        {
>                            If (FDS0)
>                            {
>                                Store (0x0F, Local7)
>                            }
>                            Else
>                            {
>                                Store (0x00, Local7)
>                            }
>
>                            Return (Local7)
>                        }
>
>                        Method (_FDI, 0, NotSerialized)
>                        {
>                            If (LOr (FDS1, LNot (LEqual (FDS0, 0x04))))
>                            {
>                                MKFP (FDS0)
>                            }
>
>                            Return (FPPK)
>                        }
>                    }
>
>                    Device (DRV1)
>                    {
>                        Name (_ADR, 0x01)
>                        Method (_STA, 0, NotSerialized)
>                        {
>                            If (FDS1)
>                            {
>                                Store (0x0F, Local7)
>                            }
>                            Else
>                            {
>                                Store (0x00, Local7)
>                            }
>
>                            Return (Local7)
>                        }
>
>                        Method (_FDI, 0, NotSerialized)
>                        {
>                            MKFP (FDS1)
>                            Return (FPPK)
>                        }
>                    }
>
>                    Method (MKFP, 1, NotSerialized)
>                    {
>                        If (LEqual (Arg0, 0x01))
>                        {
>                            Store (FP5D, FPBF)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x02))
>                            {
>                                Store (FP5H, FPBF)
>                            }
>                            Else
>                            {
>                                If (LEqual (Arg0, 0x03))
>                                {
>                                    Store (FP3D, FPBF)
>                                }
>                                Else
>                                {
>                                    If (LEqual (Arg0, 0x04))
>                                    {
>                                        Store (FP3H, FPBF)
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (Arg0, 0x06))
>                                        {
>                                            Store (FP3E, FPBF)
>                                        }
>                                    }
>                                }
>                            }
>                        }
>
>                        If (FDS1)
>                        {
>                            Store (0x02, Index (FPBF, 0x00))
>                        }
>
>                        Store (0x00, Local0)
>                        While (LGreater (0x10, Local0))
>                        {
>                            Store (DerefOf (Index (FPBF, Local0)), Index (FPPK, Local0))
>                            Increment (Local0)
>                        }
>                    }
>
>                    Name (FPPK, Package (0x10)
>                    {
>                        0x01, 
>                        0x04, 
>                        0x4F, 
>                        0x12, 
>                        0x01, 
>                        0xDF, 
>                        0x02, 
>                        0x25, 
>                        0x02, 
>                        0x12, 
>                        0x1B, 
>                        0xFF, 
>                        0x6C, 
>                        0xF6, 
>                        0x0F, 
>                        0x05
>                    })
>                    Name (FPBF, Buffer (0x10) {})
>                    Name (FP5D, Buffer (0x10)
>                    {
>                        0x01, 0x01, 0x27, 0x09, 0x01, 0xDF, 0x02, 0x25, 
>                        0x02, 0x09, 0x2A, 0xFF, 0x50, 0xF6, 0x0F, 0x06
>                    })
>                    Name (FP5H, Buffer (0x10)
>                    {
>                        0x01, 0x02, 0x4F, 0x0F, 0x01, 0xDF, 0x04, 0x25, 
>                        0x02, 0x0F, 0x1B, 0xFF, 0x54, 0xF6, 0x0F, 0x06
>                    })
>                    Name (FP3D, Buffer (0x10)
>                    {
>                        0x01, 0x03, 0x4F, 0x09, 0x01, 0xEF, 0x02, 0x25, 
>                        0x02, 0x09, 0x1B, 0xFF, 0x50, 0xF6, 0x0F, 0x05
>                    })
>                    Name (FP3H, Buffer (0x10)
>                    {
>                        0x01, 0x04, 0x4F, 0x12, 0x01, 0xDF, 0x02, 0x25, 
>                        0x02, 0x12, 0x1B, 0xFF, 0x6C, 0xF6, 0x0F, 0x05
>                    })
>                    Name (FP3E, Buffer (0x10)
>                    {
>                        0x01, 0x06, 0x4F, 0x24, 0x01, 0xAA, 0x08, 0x25, 
>                        0x02, 0x24, 0x1B, 0xFF, 0x54, 0xF6, 0x0F, 0x05
>                    })
>                }
>
>                Scope (\_SB.PCI0.LPCB.UAR1)
>                {
>                    Name (_PRW, Package (0x02)
>                    {
>                        0x08, 
>                        0x03
>                    })
>                    Method (_PSW, 1, NotSerialized)
>                    {
>                        If (Arg0)
>                        {
>                            Store (Zero, RI1M)
>                        }
>                        Else
>                        {
>                            Store (One, RI1M)
>                        }
>                    }
>                }
>
>                Device (LNKA)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x01)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PARC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,10,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLA, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLA, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PARC, 0x0F), IRQ0)
>                        Return (RTLA)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PARC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PARC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKB)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x02)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PBRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,11,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLB, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLB, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PBRC, 0x0F), IRQ0)
>                        Return (RTLB)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PBRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PBRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKC)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x03)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PCRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,10,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLC, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLC, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PCRC, 0x0F), IRQ0)
>                        Return (RTLC)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PCRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PCRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKD)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x04)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PDRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,11,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLD, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLD, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PDRC, 0x0F), IRQ0)
>                        Return (RTLD)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PDRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PDRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKE)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x05)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PERC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,10,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLE, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLE, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PERC, 0x0F), IRQ0)
>                        Return (RTLE)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PERC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PERC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKF)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x06)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PFRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,11,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLF, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLF, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PFRC, 0x0F), IRQ0)
>                        Return (RTLF)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PFRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PFRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKG)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x07)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PGRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,10,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLG, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLG, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PGRC, 0x0F), IRQ0)
>                        Return (RTLG)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PGRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PGRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Device (LNKH)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x08)
>                    Method (_DIS, 0, Serialized)
>                    {
>                        Store (0x80, PHRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {1,3,4,5,6,7,11,12,14,15}
>                    })
>                    Method (_CRS, 0, Serialized)
>                    {
>                        Name (RTLH, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLH, 0x01, IRQ0)
>                        Store (Zero, IRQ0)
>                        ShiftLeft (0x01, And (PHRC, 0x0F), IRQ0)
>                        Return (RTLH)
>                    }
>
>                    Method (_SRS, 1, Serialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRQ0)
>                        FindSetRightBit (IRQ0, Local0)
>                        Decrement (Local0)
>                        Store (Local0, PHRC)
>                    }
>
>                    Method (_STA, 0, Serialized)
>                    {
>                        If (And (PHRC, 0x80))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>                }
>
>                Method (PRCF, 0, NotSerialized)
>                {
>                    If (B2TC)
>                    {
>                        Store (One, BY2O)
>                    }
>                    Else
>                    {
>                        Store (Zero, BY2O)
>                    }
>                }
>            }
>
>            Device (PATA)
>            {
>                Name (_ADR, 0x001F0001)
>                Name (PMMN, Buffer (0x28) {})
>                Name (PSMN, Buffer (0x28) {})
>                OperationRegion (ATIO, SystemIO, 0x01F7, 0x01)
>                Field (ATIO, ByteAcc, NoLock, Preserve)
>                {
>                    STSR,   8
>                }
>
>                OperationRegion (PCI, PCI_Config, 0x40, 0x18)
>                Field (PCI, ByteAcc, NoLock, Preserve)
>                {
>                    PTI0,   1, 
>                    PIE0,   1, 
>                    PPP0,   1, 
>                    PDT0,   1, 
>                    PTI1,   1, 
>                    PIE1,   1, 
>                    PPP1,   1, 
>                    PDT1,   1, 
>                    PRCT,   2, 
>                        ,   2, 
>                    PISP,   2, 
>                    PSIT,   1, 
>                    PIDE,   1, 
>                    Offset (0x04), 
>                    PRC1,   2, 
>                    PIS1,   2, 
>                    Offset (0x08), 
>                    PSD0,   1, 
>                    PSD1,   1, 
>                    Offset (0x0A), 
>                    PCT0,   2, 
>                        ,   2, 
>                    PCT1,   2, 
>                    Offset (0x14), 
>                    PCB0,   1, 
>                    PCB1,   1, 
>                        ,   2, 
>                    PMCC,   1, 
>                    PSCC,   1, 
>                        ,   6, 
>                    FPC0,   1, 
>                    FPC1,   1, 
>                    Offset (0x16), 
>                    PSMD,   2
>                }
>
>                Device (PRIM)
>                {
>                    Name (_ADR, 0x00)
>                    Device (MAST)
>                    {
>                        Name (_ADR, 0x00)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Name (GTFB, Buffer (0x15)
>                            {
>                                0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03, 
>                                0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x00, 0x00, 
>                                0x00, 0x00, 0x00, 0xA0, 0xF5
>                            })
>                            CreateByteField (GTFB, 0x01, SPIO)
>                            CreateByteField (GTFB, 0x08, SDMA)
>                            CreateByteField (GTFB, 0x14, SCMD)
>                            If (LNot (SSUP ()))
>                            {
>                                Store (0x00, SCMD)
>                            }
>
>                            If (LNot (PIE0))
>                            {
>                                Store (0x01, SPIO)
>                            }
>                            Else
>                            {
>                                If (LOr (PDT0, LNot (PTI0)))
>                                {
>                                    Store (0x08, SPIO)
>                                }
>                                Else
>                                {
>                                    If (LLess (Add (PISP, PRCT), 0x03))
>                                    {
>                                        Store (0x0A, SPIO)
>                                    }
>                                    Else
>                                    {
>                                        If (LLess (Add (PISP, PRCT), 0x05))
>                                        {
>                                            Store (0x0B, SPIO)
>                                        }
>                                        Else
>                                        {
>                                            Store (0x0C, SPIO)
>                                        }
>                                    }
>                                }
>                            }
>
>                            If (PSD0)
>                            {
>                                If (And (FPC0, PMCC))
>                                {
>                                    Store (0x45, SDMA)
>                                }
>                                Else
>                                {
>                                    If (And (PCB0, PMCC))
>                                    {
>                                        If (LEqual (PCT0, 0x02))
>                                        {
>                                            Store (0x44, SDMA)
>                                        }
>                                        Else
>                                        {
>                                            Store (0x43, SDMA)
>                                        }
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (PCT0, 0x02))
>                                        {
>                                            Store (0x42, SDMA)
>                                        }
>                                        Else
>                                        {
>                                            If (LEqual (PCT0, 0x01))
>                                            {
>                                                Store (0x41, SDMA)
>                                            }
>                                            Else
>                                            {
>                                                Store (0x40, SDMA)
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                            Else
>                            {
>                                If (LLess (Add (PISP, PRCT), 0x05))
>                                {
>                                    Store (0x21, SDMA)
>                                }
>                                Else
>                                {
>                                    Store (0x22, SDMA)
>                                }
>                            }
>
>                            Return (GTFB)
>                        }
>                    }
>
>                    Device (SLAV)
>                    {
>                        Name (_ADR, 0x01)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Name (GTFB, Buffer (0x15)
>                            {
>                                0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03, 
>                                0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x00, 0x00, 
>                                0x00, 0x00, 0x00, 0xB0, 0xF5
>                            })
>                            CreateByteField (GTFB, 0x01, SPIO)
>                            CreateByteField (GTFB, 0x08, SDMA)
>                            CreateByteField (GTFB, 0x14, SCMD)
>                            If (LNot (SSUP ()))
>                            {
>                                Store (0x00, SCMD)
>                            }
>
>                            If (LNot (PIE1))
>                            {
>                                Store (0x01, SPIO)
>                            }
>                            Else
>                            {
>                                If (LOr (PDT1, LNot (PTI1)))
>                                {
>                                    Store (0x08, SPIO)
>                                }
>                                Else
>                                {
>                                    If (PSIT)
>                                    {
>                                        If (LLess (Add (PIS1, PRC1), 0x03))
>                                        {
>                                            Store (0x0A, SPIO)
>                                        }
>                                        Else
>                                        {
>                                            If (LLess (Add (PIS1, PRC1), 0x05))
>                                            {
>                                                Store (0x0B, SPIO)
>                                            }
>                                            Else
>                                            {
>                                                Store (0x0C, SPIO)
>                                            }
>                                        }
>                                    }
>                                    Else
>                                    {
>                                        If (LLess (Add (PISP, PRCT), 0x03))
>                                        {
>                                            Store (0x0A, SPIO)
>                                        }
>                                        Else
>                                        {
>                                            If (LLess (Add (PISP, PRCT), 0x05))
>                                            {
>                                                Store (0x0B, SPIO)
>                                            }
>                                            Else
>                                            {
>                                                Store (0x0C, SPIO)
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>
>                            If (PSD1)
>                            {
>                                If (And (FPC1, PSCC))
>                                {
>                                    Store (0x45, SDMA)
>                                }
>                                Else
>                                {
>                                    If (And (PCB1, PSCC))
>                                    {
>                                        If (LEqual (PCT1, 0x02))
>                                        {
>                                            Store (0x44, SDMA)
>                                        }
>                                        Else
>                                        {
>                                            Store (0x43, SDMA)
>                                        }
>                                    }
>                                    Else
>                                    {
>                                        If (LEqual (PCT1, 0x02))
>                                        {
>                                            Store (0x42, SDMA)
>                                        }
>                                        Else
>                                        {
>                                            If (LEqual (PCT1, 0x01))
>                                            {
>                                                Store (0x41, SDMA)
>                                            }
>                                            Else
>                                            {
>                                                Store (0x40, SDMA)
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                            Else
>                            {
>                                If (PSIT)
>                                {
>                                    If (LLess (Add (PIS1, PRC1), 0x05))
>                                    {
>                                        Store (0x21, SDMA)
>                                    }
>                                    Else
>                                    {
>                                        Store (0x22, SDMA)
>                                    }
>                                }
>                                Else
>                                {
>                                    If (LLess (Add (PISP, PRCT), 0x05))
>                                    {
>                                        Store (0x21, SDMA)
>                                    }
>                                    Else
>                                    {
>                                        Store (0x22, SDMA)
>                                    }
>                                }
>                            }
>
>                            Return (GTFB)
>                        }
>                    }
>
>                    Method (_GTM, 0, NotSerialized)
>                    {
>                        Name (GTMB, Buffer (0x14) {})
>                        CreateDWordField (GTMB, 0x00, PIO0)
>                        CreateDWordField (GTMB, 0x04, DMA0)
>                        CreateDWordField (GTMB, 0x08, PIO1)
>                        CreateDWordField (GTMB, 0x0C, DMA1)
>                        CreateDWordField (GTMB, 0x10, FLAG)
>                        Store (0x10, FLAG)
>                        Or (FLAG, Or (ShiftLeft (PIE1, 0x03), ShiftLeft (PIE0, 0x01)), FLAG)
>                        If (LOr (PDT0, LNot (PTI0)))
>                        {
>                            Store (0x0384, PIO0)
>                        }
>                        Else
>                        {
>                            Multiply (Subtract (0x09, Add (PRCT, PISP)), 0x1E, PIO0)
>                        }
>
>                        If (LNot (PSD0))
>                        {
>                            Store (PIO0, DMA0)
>                        }
>                        Else
>                        {
>                            Or (FLAG, 0x01, FLAG)
>                            If (And (FPC0, PMCC))
>                            {
>                                Store (0x14, DMA0)
>                            }
>                            Else
>                            {
>                                If (And (PCB0, PMCC))
>                                {
>                                    Multiply (Subtract (0x04, PCT0), 0x0F, DMA0)
>                                }
>                                Else
>                                {
>                                    Multiply (Subtract (0x04, PCT0), 0x1E, DMA0)
>                                }
>                            }
>                        }
>
>                        If (LOr (PDT1, LNot (PTI1)))
>                        {
>                            Store (0x0384, PIO1)
>                        }
>                        Else
>                        {
>                            If (LNot (PSIT))
>                            {
>                                Store (PIO0, PIO1)
>                            }
>                            Else
>                            {
>                                Multiply (Subtract (0x09, Add (PRC1, PIS1)), 0x1E, PIO1)
>                            }
>                        }
>
>                        If (LNot (PSD1))
>                        {
>                            Store (PIO1, DMA1)
>                        }
>                        Else
>                        {
>                            Or (FLAG, 0x04, FLAG)
>                            If (And (FPC1, PSCC))
>                            {
>                                Store (0x14, DMA1)
>                            }
>                            Else
>                            {
>                                If (And (PCB1, PSCC))
>                                {
>                                    Multiply (Subtract (0x04, PCT1), 0x0F, DMA1)
>                                }
>                                Else
>                                {
>                                    Multiply (Subtract (0x04, PCT1), 0x1E, DMA1)
>                                }
>                            }
>                        }
>
>                        Return (GTMB)
>                    }
>
>                    Method (_STM, 3, NotSerialized)
>                    {
>                        CreateDWordField (Arg0, 0x00, PIO0)
>                        CreateDWordField (Arg0, 0x04, DMA0)
>                        CreateDWordField (Arg0, 0x08, PIO1)
>                        CreateDWordField (Arg0, 0x0C, DMA1)
>                        CreateDWordField (Arg0, 0x10, FLAG)
>                        Store (0x00, PIDE)
>                        Store (0x00, PSIT)
>                        If (LAnd (MSMF (), LEqual (SizeOf (Arg1), 0x0200)))
>                        {
>                            CreateField (Arg1, 0x01B0, 0x0140, MBUF)
>                            Store (MBUF, PMMN)
>                            CreateWordField (Arg1, 0x62, W490)
>                            CreateWordField (Arg1, 0x66, W510)
>                            CreateWordField (Arg1, 0x6A, W530)
>                            CreateWordField (Arg1, 0x7C, W620)
>                            CreateWordField (Arg1, 0x7E, W630)
>                            CreateWordField (Arg1, 0x80, W640)
>                            CreateWordField (Arg1, 0xB0, W880)
>                            Store (0x00, PISP)
>                            Store (0x00, PRCT)
>                            Store (0x00, PDT0)
>                            Store (0x00, PIE0)
>                            Store (0x00, PTI0)
>                            Store (0x00, PSD0)
>                            Store (0x00, PCT0)
>                            Store (0x00, PCB0)
>                            Store (0x00, PMCC)
>                            Store (0x00, FPC0)
>                            If (LAnd (And (FLAG, 0x02), And (W490, 0x0800)))
>                            {
>                                Store (0x01, PIE0)
>                            }
>
>                            If (LAnd (LNot (LGreater (PIO0, 0x78)), LAnd (And (W530, 0x02), And (W640, 0x02))))
>                            {
>                                Store (0x02, PISP)
>                                Store (0x03, PRCT)
>                                Store (0x01, PTI0)
>                            }
>                            Else
>                            {
>                                If (LAnd (LNot (LGreater (PIO0, 0xB4)), LAnd (And (W530, 0x02), And (W640, 0x01))))
>                                {
>                                    Store (0x02, PISP)
>                                    Store (0x01, PRCT)
>                                    Store (0x01, PTI0)
>                                }
>                                Else
>                                {
>                                    If (LAnd (LNot (LGreater (PIO0, 0xF0)), LNot (LLess (W510, 0x0200))))
>                                    {
>                                        Store (0x01, PISP)
>                                        Store (0x01, PTI0)
>                                    }
>                                    Else
>                                    {
>                                        Noop
>                                    }
>                                }
>                            }
>
>                            If (LNot (LEqual (DMA0, 0xFFFFFFFF)))
>                            {
>                                If (LAnd (And (FLAG, 0x01), LAnd (And (W530, 0x04), And (W880, 0x3F))))
>                                {
>                                    Store (0x01, PSD0)
>                                    If (LAnd (LNot (LGreater (DMA0, 0x14)), And (W880, 0x20)))
>                                    {
>                                        Store (0x01, PCT0)
>                                        Store (0x01, PMCC)
>                                        Store (0x01, FPC0)
>                                    }
>                                    Else
>                                    {
>                                        If (LAnd (LNot (LGreater (DMA0, 0x1E)), And (W880, 0x10)))
>                                        {
>                                            Store (0x02, PCT0)
>                                            Store (0x01, PMCC)
>                                            Store (0x01, PCB0)
>                                        }
>                                        Else
>                                        {
>                                            If (LAnd (LNot (LGreater (DMA0, 0x2D)), And (W880, 0x08)))
>                                            {
>                                                Store (0x01, PCT0)
>                                                Store (0x01, PMCC)
>                                                Store (0x01, PCB0)
>                                            }
>                                            Else
>                                            {
>                                                If (LAnd (LNot (LGreater (DMA0, 0x3C)), And (W880, 0x04)))
>                                                {
>                                                    Store (0x02, PCT0)
>                                                }
>                                                Else
>                                                {
>                                                    If (LAnd (LNot (LGreater (DMA0, 0x5A)), And (W880, 0x02)))
>                                                    {
>                                                        Store (0x01, PCT0)
>                                                    }
>                                                    Else
>                                                    {
>                                                        Noop
>                                                    }
>                                                }
>                                            }
>                                        }
>                                    }
>                                }
>                                Else
>                                {
>                                    If (LAnd (LNot (LGreater (DMA0, 0x78)), And (W630, 0x04)))
>                                    {
>                                        Store (0x02, PISP)
>                                        Store (0x03, PRCT)
>                                        Store (0x01, PTI0)
>                                    }
>                                    Else
>                                    {
>                                        If (LAnd (LNot (LGreater (DMA0, 0xB4)), And (W630, 0x02)))
>                                        {
>                                            Store (0x02, PISP)
>                                            Store (0x01, PRCT)
>                                            Store (0x01, PTI0)
>                                        }
>                                        Else
>                                        {
>                                            Noop
>                                        }
>                                    }
>                                }
>                            }
>                        }
>
>                        If (LAnd (SSMF (), LEqual (SizeOf (Arg2), 0x0200)))
>                        {
>                            CreateField (Arg2, 0x01B0, 0x0140, SBUF)
>                            Store (SBUF, PSMN)
>                            CreateWordField (Arg2, 0x62, W491)
>                            CreateWordField (Arg2, 0x66, W511)
>                            CreateWordField (Arg2, 0x6A, W531)
>                            CreateWordField (Arg2, 0x7C, W621)
>                            CreateWordField (Arg2, 0x7E, W631)
>                            CreateWordField (Arg2, 0x80, W641)
>                            CreateWordField (Arg2, 0xB0, W881)
>                            Store (0x00, PIS1)
>                            Store (0x00, PRC1)
>                            Store (0x00, PDT1)
>                            Store (0x00, PIE1)
>                            Store (0x00, PTI1)
>                            Store (0x00, PSD1)
>                            Store (0x00, PCT1)
>                            Store (0x00, PCB1)
>                            Store (0x00, PSCC)
>                            Store (0x00, FPC1)
>                            If (LAnd (And (FLAG, 0x08), And (W491, 0x0800)))
>                            {
>                                Store (0x01, PIE1)
>                            }
>
>                            If (LAnd (And (FLAG, 0x10), LAnd (LNot (LEqual (PIO1, 0xFFFFFFFF)), LNot (LEqual (PIO1, PIO0)))))
>                            {
>                                Store (0x01, PSIT)
>                                If (LAnd (LNot (LGreater (PIO1, 0x78)), LAnd (And (W531, 0x02), And (W641, 0x02))))
>                                {
>                                    Store (0x02, PIS1)
>                                    Store (0x03, PRC1)
>                                    Store (0x01, PTI1)
>                                }
>                                Else
>                                {
>                                    If (LAnd (LNot (LGreater (PIO1, 0xB4)), LAnd (And (W531, 0x02), And (W641, 0x01))))
>                                    {
>                                        Store (0x02, PIS1)
>                                        Store (0x01, PRC1)
>                                        Store (0x01, PTI1)
>                                    }
>                                    Else
>                                    {
>                                        If (LAnd (LNot (LGreater (PIO1, 0xF0)), LNot (LLess (W511, 0x0200))))
>                                        {
>                                            Store (0x01, PIS1)
>                                            Store (0x01, PTI1)
>                                        }
>                                        Else
>                                        {
>                                            Noop
>                                        }
>                                    }
>                                }
>                            }
>
>                            If (LNot (LEqual (DMA1, 0xFFFFFFFF)))
>                            {
>                                If (LAnd (And (FLAG, 0x04), LAnd (And (W531, 0x04), And (W881, 0x3F))))
>                                {
>                                    Store (0x01, PSD1)
>                                    If (LAnd (LNot (LGreater (DMA1, 0x14)), And (W881, 0x20)))
>                                    {
>                                        Store (0x01, PCT1)
>                                        Store (0x01, PSCC)
>                                        Store (0x01, FPC1)
>                                    }
>                                    Else
>                                    {
>                                        If (LAnd (LNot (LGreater (DMA1, 0x1E)), And (W881, 0x10)))
>                                        {
>                                            Store (0x02, PCT1)
>                                            Store (0x01, PSCC)
>                                            Store (0x01, PCB1)
>                                        }
>                                        Else
>                                        {
>                                            If (LAnd (LNot (LGreater (DMA1, 0x2D)), And (W881, 0x08)))
>                                            {
>                                                Store (0x01, PCT1)
>                                                Store (0x01, PSCC)
>                                                Store (0x01, PCB1)
>                                            }
>                                            Else
>                                            {
>                                                If (LAnd (LNot (LGreater (DMA1, 0x3C)), And (W881, 0x04)))
>                                                {
>                                                    Store (0x02, PCT1)
>                                                }
>                                                Else
>                                                {
>                                                    If (LAnd (LNot (LGreater (DMA1, 0x5A)), And (W881, 0x02)))
>                                                    {
>                                                        Store (0x01, PCT1)
>                                                    }
>                                                    Else
>                                                    {
>                                                        Noop
>                                                    }
>                                                }
>                                            }
>                                        }
>                                    }
>                                }
>                                Else
>                                {
>                                    If (LAnd (And (FLAG, 0x10), LNot (LEqual (DMA1, DMA0))))
>                                    {
>                                        Store (0x01, PSIT)
>                                        If (LAnd (LNot (LGreater (DMA1, 0x78)), And (W631, 0x04)))
>                                        {
>                                            Store (0x02, PIS1)
>                                            Store (0x03, PRC1)
>                                            Store (0x01, PTI1)
>                                        }
>                                        Else
>                                        {
>                                            If (LAnd (LNot (LGreater (DMA1, 0xB4)), And (W631, 0x02)))
>                                            {
>                                                Store (0x02, PIS1)
>                                                Store (0x01, PRC1)
>                                                Store (0x01, PTI1)
>                                            }
>                                            Else
>                                            {
>                                                Noop
>                                            }
>                                        }
>                                    }
>                                }
>                            }
>                        }
>
>                        Store (0x01, PIDE)
>                    }
>                }
>
>                Scope (\_SB.PCI0.PATA.PRIM)
>                {
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Method (MSMF, 0, NotSerialized)
>                    {
>                        Return (\_SB.PCI0.PATA.PRIM.MAST._STA ())
>                    }
>
>                    Method (SSMF, 0, NotSerialized)
>                    {
>                        Return (0x00)
>                    }
>                }
>
>                Scope (\_SB.PCI0.PATA.PRIM.MAST)
>                {
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (FBAY)
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            If (LAnd (\_SB.PCI0.PATA.PRIM.MAST.BIDE (), LAnd (BRST, BY1O)))
>                            {
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                Return (0x00)
>                            }
>                        }
>                    }
>
>                    Method (SSUP, 0, NotSerialized)
>                    {
>                        Return (LEqual (BY1I, 0x0A))
>                    }
>
>                    Method (BIDE, 0, NotSerialized)
>                    {
>                        Store (BY1I, Local0)
>                        Store (LEqual (Local0, 0x08), Local1)
>                        Or (LEqual (Local0, 0x0A), Local1, Local1)
>                        Or (LEqual (Local0, 0x0B), Local1, Local1)
>                        Or (LEqual (Local0, 0x0D), Local1, Local1)
>                        Return (Local1)
>                    }
>
>                    Method (BON, 0, NotSerialized)
>                    {
>                        Store (Zero, BRST)
>                        Store (Zero, PIE0)
>                        Store (0x02, PSMD)
>                        If (LEqual (BY1C, Zero))
>                        {
>                            Sleep (0x64)
>                            Store (BY1I, Local0)
>                            If (LNot (LEqual (Local0, 0x01)))
>                            {
>                                Store (One, BY1O)
>                                Sleep (0x46)
>                                Store (Zero, PSMD)
>                                Store (0x01, PIDE)
>                                Store (0x01, PSD0)
>                                Store (0x01, PMCC)
>                                Store (0x01, FPC0)
>                                And (BOPT, 0xFE, BOPT)
>                                And (BHDD, 0xFE, BHDD)
>                                If (LEqual (Local0, 0x08))
>                                {
>                                    Or (BOPT, One, BOPT)
>                                }
>
>                                If (LEqual (Local0, 0x0A))
>                                {
>                                    Or (BHDD, One, BHDD)
>                                }
>
>                                If (LEqual (Local0, 0x0B))
>                                {
>                                    Or (BOPT, One, BOPT)
>                                }
>
>                                If (LEqual (Local0, 0x0D))
>                                {
>                                    Or (BOPT, One, BOPT)
>                                }
>
>                                Sleep (0x1E)
>                                Store (One, BRST)
>                                Sleep (0x64)
>                                Store (Zero, Local1)
>                                While (LAnd (LAnd (And (STSR, 0x80), B1TC), LLess (Local1, 0x015E)))
>                                {
>                                    Sleep (0x64)
>                                    Add (Local1, 0x01, Local1)
>                                }
>                            }
>                        }
>                    }
>
>                    Method (BOFF, 0, NotSerialized)
>                    {
>                        Store (Zero, BRST)
>                        And (BOPT, 0xFE, BOPT)
>                        And (BHDD, 0xFE, BHDD)
>                        Sleep (0x1E)
>                        TMCL ()
>                        Store (0x02, PSMD)
>                        Sleep (0x46)
>                        Store (Zero, BY1O)
>                        Sleep (0x64)
>                    }
>
>                    Method (TMCL, 0, NotSerialized)
>                    {
>                        Store (0x00, PIDE)
>                        Store (0x00, PISP)
>                        Store (0x00, PRCT)
>                        Store (0x00, PDT0)
>                        Store (0x00, PIE0)
>                        Store (0x00, PTI0)
>                        Store (0x00, PSD0)
>                        Store (0x00, PCT0)
>                        Store (0x00, PCB0)
>                        Store (0x00, PMCC)
>                        Store (0x00, FPC0)
>                        Store (0x01, PIDE)
>                    }
>                }
>
>                Scope (\_SB.PCI0.PATA.PRIM.SLAV)
>                {
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x00)
>                    }
>
>                    Method (SSUP, 0, NotSerialized)
>                    {
>                        Return (0x00)
>                    }
>                }
>            }
>
>            Device (SATA)
>            {
>                Name (_ADR, 0x001F0002)
>            }
>
>            Device (USB0)
>            {
>                Name (_ADR, 0x001D0000)
>            }
>
>            Device (USB1)
>            {
>                Name (_ADR, 0x001D0001)
>            }
>
>            Device (USB2)
>            {
>                Name (_ADR, 0x001D0002)
>                Device (RHUB)
>                {
>                    Name (_ADR, 0x00)
>                    Device (USBE)
>                    {
>                        Name (_ADR, 0x01)
>                        Name (_EJD, "_SB.PCI0.EXP2.EXPC")
>                    }
>                }
>            }
>
>            Device (USB3)
>            {
>                Name (_ADR, 0x001D0003)
>            }
>
>            Device (USB7)
>            {
>                Name (_ADR, 0x001D0007)
>            }
>
>            Device (SBUS)
>            {
>                Name (_ADR, 0x001F0003)
>            }
>
>            Device (AUD0)
>            {
>                Name (_ADR, 0x001E0002)
>            }
>
>            Device (MODM)
>            {
>                Name (_ADR, 0x001E0003)
>                Name (_PRW, Package (0x02)
>                {
>                    0x05, 
>                    0x03
>                })
>            }
>
>            Device (AZAL)
>            {
>                Name (_ADR, 0x001B0000)
>                Name (_PRW, Package (0x02)
>                {
>                    0x05, 
>                    0x03
>                })
>            }
>
>            Device (EXP1)
>            {
>                Name (_ADR, 0x001C0000)
>                OperationRegion (P1CS, PCI_Config, 0x40, 0xC0)
>                Field (P1CS, AnyAcc, NoLock, Preserve)
>                {
>                    Offset (0x20), 
>                    RID1,   16, 
>                    PSP1,   1, 
>                    PPP1,   1, 
>                    Offset (0x9C), 
>                        ,   31, 
>                    PCS1,   1
>                }
>
>                Name (_PRW, Package (0x02)
>                {
>                    0x09, 
>                    0x04
>                })
>                Method (_PRT, 0, NotSerialized)
>                {
>                    If (\GPIC)
>                    {
>                        Return (Package (0x01)
>                        {
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x00, 
>                                0x00, 
>                                0x10
>                            }
>                        })
>                    }
>                    Else
>                    {
>                        Return (Package (0x01)
>                        {
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x00, 
>                                \_SB.PCI0.LPCB.LNKA, 
>                                0x00
>                            }
>                        })
>                    }
>                }
>            }
>
>            Device (EXP2)
>            {
>                Name (_ADR, 0x001C0001)
>                OperationRegion (P2CS, PCI_Config, 0x40, 0xC0)
>                Field (P2CS, AnyAcc, NoLock, Preserve)
>                {
>                    Offset (0x20), 
>                    RID2,   16, 
>                    PSP2,   1, 
>                    PPP2,   1
>                }
>
>                Method (_PRT, 0, NotSerialized)
>                {
>                    If (\GPIC)
>                    {
>                        Return (Package (0x02)
>                        {
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x00, 
>                                0x00, 
>                                0x11
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x01, 
>                                0x00, 
>                                0x12
>                            }
>                        })
>                    }
>                    Else
>                    {
>                        Return (Package (0x02)
>                        {
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x00, 
>                                \_SB.PCI0.LPCB.LNKB, 
>                                0x00
>                            }, 
>
>                            Package (0x04)
>                            {
>                                0xFFFF, 
>                                0x01, 
>                                \_SB.PCI0.LPCB.LNKC, 
>                                0x00
>                            }
>                        })
>                    }
>                }
>
>                Name (_PRW, Package (0x02)
>                {
>                    0x09, 
>                    0x04
>                })
>                Device (EXPC)
>                {
>                    Name (_ADR, 0x00)
>                    Name (_EJD, "_SB.PCI0.USB2.RHUB.USBE")
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PXRS)
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_RMV, 0, NotSerialized)
>                    {
>                        Return (One)
>                    }
>
>                    Method (EXIN, 0, NotSerialized)
>                    {
>                        Sleep (0x64)
>                        Store (Zero, PXCL)
>                        Sleep (0x01)
>                        Store (One, PXRS)
>                        Store (Zero, EXPL)
>                    }
>
>                    Method (EXRM, 0, NotSerialized)
>                    {
>                        Store (Zero, PXRS)
>                        Store (One, PXCL)
>                        Store (One, EXPL)
>                    }
>                }
>            }
>        }
>
>        Scope (\)
>        {
>            Name (WBTN, Zero)
>            Name (NGTM, Zero)
>            Name (LSBL, Zero)
>            Name (BNBF, Buffer (0x20) {})
>            Name (BNSP, Zero)
>            Name (BNGP, Zero)
>            Name (BNCT, Zero)
>        }
>
>        Device (FEXT)
>        {
>            Name (_HID, "FUJ02E3")
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0F)
>            }
>
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (Zero, BNSP)
>                Store (Zero, BNGP)
>                Store (Zero, BNCT)
>                Store (Zero, IRBC)
>                Store (Zero, IRBF)
>            }
>
>            Method (FUNC, 4, Serialized)
>            {
>                Store (0x80000000, Local0)
>                If (LEqual (Arg0, 0x1001))
>                {
>                    Store (S001 (Arg1, Arg2, Arg3), Local0)
>                }
>                Else
>                {
>                    If (LEqual (Arg0, 0x1002))
>                    {
>                        Store (S002 (Arg1, Arg2, Arg3), Local0)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x1004))
>                        {
>                            Store (S004 (Arg1, Arg2, Arg3), Local0)
>                        }
>                    }
>                }
>
>                Return (Local0)
>            }
>
>            Method (S001, 3, NotSerialized)
>            {
>                Store (0x80000000, Local0)
>                If (LEqual (Arg0, Zero))
>                {
>                    Store (LEDI, Local0)
>                }
>                Else
>                {
>                    If (LEqual (Arg0, One))
>                    {
>                        And (Arg2, 0x03, Local1)
>                        If (LAnd (And (Arg1, LEDI), Local1))
>                        {
>                            Store (0x9B, CMD)
>                            ShiftRight (And (Arg2, 0x00030000), 0x08, DVID)
>                            Store (Zero, SSMI)
>                        }
>
>                        Store (Zero, Local0)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x02))
>                        {
>                            If (And (Arg1, LEDI))
>                            {
>                                Store (0x9B, CMD)
>                                Store (One, DVID)
>                                Store (Zero, SSMI)
>                                Or (ShiftLeft (DVID, 0x10), One, Local0)
>                            }
>                            Else
>                            {
>                                Store (Zero, Local0)
>                            }
>                        }
>                    }
>                }
>
>                Return (Local0)
>            }
>
>            Method (S002, 3, NotSerialized)
>            {
>                Store (0x80000000, Local0)
>                If (LEqual (Arg0, Zero))
>                {
>                    Store (BTNI, Local0)
>                }
>                Else
>                {
>                    If (LEqual (Arg0, One))
>                    {
>                        Store (GIRB (), Local0)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x02))
>                        {
>                            Store (0x9B, CMD)
>                            Store (0x02, DVID)
>                            Store (Zero, SSMI)
>                            Store (DVID, Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x03))
>                            {
>                                If (Arg1)
>                                {
>                                    Not (Arg1, Local1)
>                                    And (Arg2, Arg1, Local2)
>                                    Or (And (WBTN, Local1), Local2, WBTN)
>                                    Store (0x9B, CMD)
>                                    Or (ShiftLeft (WBTN, 0x08), 0x03, DVID)
>                                    Store (Zero, SSMI)
>                                }
>
>                                Store (WBTN, Local0)
>                            }
>                        }
>                    }
>                }
>
>                Return (Local0)
>            }
>
>            Method (SIRB, 1, NotSerialized)
>            {
>                If (LLess (BNCT, 0x10))
>                {
>                    CreateWordField (BNBF, BNSP, BNP1)
>                    Store (Arg0, BNP1)
>                    Increment (BNCT)
>                    Add (BNSP, 0x02, BNSP)
>                    If (LNot (LLess (BNSP, 0x20)))
>                    {
>                        Store (Zero, BNSP)
>                    }
>                }
>            }
>
>            Method (GIRB, 0, NotSerialized)
>            {
>                If (BNCT)
>                {
>                    CreateWordField (BNBF, BNGP, BNP2)
>                    Store (BNP2, Local0)
>                    Or (Local0, 0x40000000, Local0)
>                    Decrement (BNCT)
>                    Add (BNGP, 0x02, BNGP)
>                    If (LNot (LLess (BNGP, 0x20)))
>                    {
>                        Store (Zero, BNGP)
>                    }
>                }
>                Else
>                {
>                    Store (Zero, Local0)
>                }
>
>                Return (Local0)
>            }
>
>            Method (S004, 3, NotSerialized)
>            {
>                Store (0x80000000, Local0)
>                If (LEqual (Arg0, Zero))
>                {
>                    Store (NGTI, Local0)
>                }
>                Else
>                {
>                    If (LEqual (Arg0, One))
>                    {
>                        If (LAnd (LEqual (Arg1, 0x04), And (NGTI, 0x04)))
>                        {
>                            And (Arg2, 0x03, Local1)
>                            If (LOr (LEqual (Local1, 0x03), LEqual (Local1, 0x02)))
>                            {
>                                If (LNot (NGTF))
>                                {
>                                    SVBL ()
>                                    Store (One, NGTF)
>                                }
>
>                                SBLC (Local1)
>                                Store (Local1, NGTM)
>                                Store (Zero, Local0)
>                            }
>
>                            If (LNot (Local1))
>                            {
>                                If (NGTF)
>                                {
>                                    Store (Zero, NGTF)
>                                    RSBL ()
>                                    SBLC (Zero)
>                                }
>
>                                Store (Zero, NGTM)
>                                Store (Zero, Local0)
>                            }
>                        }
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x02))
>                        {
>                            If (LAnd (LEqual (Arg1, 0x04), And (NGTI, 0x04)))
>                            {
>                                Store (NGTM, Local0)
>                            }
>                        }
>                    }
>                }
>
>                Return (Local0)
>            }
>        }
>
>        Scope (\_SB.FEXT)
>        {
>            Method (SBLC, 1, NotSerialized)
>            {
>                If (LNot (Arg0))
>                {
>                    Store (Zero, BLCT)
>                }
>                Else
>                {
>                    If (LEqual (Arg0, 0x03))
>                    {
>                        Store (One, BLCT)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x02))
>                        {
>                            Name (BBCT, Buffer (BLLM) {})
>                            Store (BLLT, BBCT)
>                            CreateByteField (BBCT, Zero, BLL0)
>                            Store (BLL0, LCDB)
>                            Store (0x01000000, DVID)
>                            Or (DVID, BLL0, DVID)
>                            Store (0x82, CMD)
>                            Store (Zero, SSMI)
>                            Store (Zero, BLCT)
>                        }
>                    }
>                }
>            }
>
>            Method (SVBL, 0, NotSerialized)
>            {
>                And (\_SB.PCI0.LPCB.FJEX.GBLL (), 0x7FFFFFFF, LSBL)
>            }
>
>            Method (RSBL, 0, NotSerialized)
>            {
>                \_SB.PCI0.LPCB.FJEX.SBLL (LSBL)
>            }
>        }
>
>        Device (LID)
>        {
>            Name (_HID, EisaId ("PNP0C0D"))
>            Method (_LID, 0, NotSerialized)
>            {
>                If (CVCL)
>                {
>                    Return (Zero)
>                }
>                Else
>                {
>                    Return (One)
>                }
>            }
>
>            Name (_PRW, Package (0x02)
>            {
>                0x18, 
>                0x04
>            })
>            Method (_PSW, 1, NotSerialized)
>            {
>                Noop
>            }
>        }
>
>        Device (PWRB)
>        {
>            Name (_HID, EisaId ("PNP0C0C"))
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0F)
>            }
>        }
>
>        Device (AC)
>        {
>            Name (_HID, "ACPI0003")
>            Scope (\)
>            {
>                Name (ACPS, Ones)
>            }
>
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (ACPW, ACPS)
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0F)
>            }
>
>            Method (_PSR, 0, NotSerialized)
>            {
>                _INI ()
>                If (ACPW)
>                {
>                    Return (One)
>                }
>                Else
>                {
>                    Return (Zero)
>                }
>            }
>
>            Name (_PCL, Package (0x01)
>            {
>                \_SB
>            })
>            Method (ACHK, 0, NotSerialized)
>            {
>                Store (ACPW, Local0)
>                If (LNot (LEqual (Local0, ACPS)))
>                {
>                    Sleep (0x28)
>                    Notify (\_SB.AC, 0x80)
>                    Store (Zero, DVID)
>                    Store (0x8D, CMD)
>                    Store (Zero, SSMI)
>                    Notify (\_PR.CPU0, 0x80)
>                    Store (Local0, ACPS)
>                }
>            }
>        }
>
>        Device (CMB1)
>        {
>            Name (_HID, EisaId ("PNP0C0A"))
>            Name (_UID, One)
>            Name (_PCL, Package (0x01)
>            {
>                \_SB
>            })
>            Scope (\)
>            {
>                Name (B1PS, Ones)
>                Name (B1RS, Ones)
>                Name (B1CS, Ones)
>                Name (B1LS, Ones)
>                Name (BIF1, Package (0x0D)
>                {
>                    0x01, 
>                    0x00, 
>                    0x00, 
>                    0x01, 
>                    0x00, 
>                    0x00, 
>                    0x00, 
>                    0x01, 
>                    0x01, 
>                    "", 
>                    "1", 
>                    "LION", 
>                    "Fujitsu"
>                })
>                Name (BST1, Package (0x04) {})
>            }
>
>            Method (MKWD, 2, NotSerialized)
>            {
>                If (And (Arg1, 0x80))
>                {
>                    Or (0xFFFF0000, Arg0, Local0)
>                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
>                    Subtract (Zero, Local0, Local0)
>                }
>                Else
>                {
>                    Store (Arg0, Local0)
>                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
>                }
>
>                Return (Local0)
>            }
>
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (B1P, B1PS)
>                Store (B1CP, B1RS)
>                Store (B1C, B1CS)
>                Store (MKWD (B1LL, B1LH), B1LS)
>            }
>
>            Method (_BIF, 0, NotSerialized)
>            {
>                Name (BUFF, Buffer (0x0C) {})
>                Store (B1NO, Local5)
>                CreateByteField (BIDT, B1ID, B1IX)
>                Store (MKWD (B1DL, B1DH), Index (BIF1, 0x01))
>                Store (MKWD (B1LL, B1LH), Index (BIF1, 0x02))
>                Store (Multiply (Add (B1DV, 0x02), 0x0E10), Index (BIF1, 0x04))
>                If (Local5)
>                {
>                    Store (DerefOf (Index (BMST, B1IX)), BUFF)
>                    Store (0x07, Local0)
>                    Store (Local5, Local2)
>                    While (LAnd (Local2, LNot (LLess (Local0, 0x02))))
>                    {
>                        Store (Subtract (DerefOf (Index (BUFF, Local0)), 0x30), Local1)
>                        Divide (Add (Local1, Local2), 0x0A, Local1, Local2)
>                        Store (Add (Local1, 0x30), Index (BUFF, Local0))
>                        Decrement (Local0)
>                    }
>
>                    Store (BUFF, Index (BIF1, 0x09))
>                }
>                Else
>                {
>                    Store (DerefOf (Index (BMNT, B1IX)), Index (BIF1, 0x09))
>                }
>
>                Return (BIF1)
>            }
>
>            Method (_BST, 0, NotSerialized)
>            {
>                _INI ()
>                Store (Zero, Local0)
>                If (B1P)
>                {
>                    If (B1C)
>                    {
>                        Or (Local0, 0x02, Local0)
>                    }
>                    Else
>                    {
>                        Or (Local0, One, Local0)
>                    }
>
>                    If (LNot (LGreater (B1CP, One)))
>                    {
>                        Or (Local0, 0x04, Local0)
>                    }
>                }
>
>                Store (MKWD (B1CL, B1CH), Local1)
>                Divide (Multiply (B1CP, MKWD (B1LL, B1LH)), 0x03E8, Local4, Local2)
>                If (Local4)
>                {
>                    Increment (Local2)
>                }
>
>                Multiply (Local2, 0x0A, Local2)
>                Store (MKWD (B1VL, B1VH), Local3)
>                Store (Local0, Index (BST1, Zero))
>                Store (Local1, Index (BST1, One))
>                Store (Local2, Index (BST1, 0x02))
>                Store (Local3, Index (BST1, 0x03))
>                Return (BST1)
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                If (B1P)
>                {
>                    Return (0x1F)
>                }
>
>                Return (0x0F)
>            }
>
>            Method (BCHK, 0, NotSerialized)
>            {
>                If (LNot (LEqual (B1P, B1PS)))
>                {
>                    Notify (\_SB.CMB1, 0x81)
>                    Store (B1P, B1PS)
>                }
>
>                If (B1PS)
>                {
>                    Store (MKWD (B1LL, B1LH), Local0)
>                    If (LNot (LEqual (Local0, B1LS)))
>                    {
>                        Notify (\_SB.CMB1, 0x81)
>                    }
>
>                    If (LOr (LNot (LEqual (B1C, B1CS)), LNot (LEqual (B1CP, B1RS))))
>                    {
>                        Notify (\_SB.CMB1, 0x80)
>                    }
>
>                    Store (Local0, B1LS)
>                    Store (B1C, B1CS)
>                    Store (B1CP, B1RS)
>                }
>            }
>        }
>
>        Device (CMB2)
>        {
>            Name (_HID, EisaId ("PNP0C0A"))
>            Name (_UID, 0x02)
>            Name (_PCL, Package (0x01)
>            {
>                \_SB
>            })
>            Scope (\)
>            {
>                Name (B2PS, Ones)
>                Name (B2RS, Ones)
>                Name (B2CS, Ones)
>                Name (B2LS, Ones)
>                Name (BIF2, Package (0x0D)
>                {
>                    0x01, 
>                    0x00, 
>                    0x00, 
>                    0x01, 
>                    0x00, 
>                    0x00, 
>                    0x00, 
>                    0x01, 
>                    0x01, 
>                    "", 
>                    "2", 
>                    "LION", 
>                    "Fujitsu"
>                })
>                Name (BST2, Package (0x04) {})
>            }
>
>            Method (MKWD, 2, NotSerialized)
>            {
>                If (And (Arg1, 0x80))
>                {
>                    Or (0xFFFF0000, Arg0, Local0)
>                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
>                    Subtract (Zero, Local0, Local0)
>                }
>                Else
>                {
>                    Store (Arg0, Local0)
>                    Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
>                }
>
>                Return (Local0)
>            }
>
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (B2P, B2PS)
>                Store (B2CP, B2RS)
>                Store (B2C, B2CS)
>                Store (MKWD (B2LL, B2LH), B2LS)
>            }
>
>            Method (_BIF, 0, NotSerialized)
>            {
>                Name (BUFF, Buffer (0x0C) {})
>                Store (B2NO, Local5)
>                CreateByteField (BIDT, B2ID, B2IX)
>                Store (MKWD (B2DL, B2DH), Index (BIF2, 0x01))
>                Store (MKWD (B2LL, B2LH), Index (BIF2, 0x02))
>                Store (Multiply (Add (B2DV, 0x02), 0x0E10), Index (BIF2, 0x04))
>                If (Local5)
>                {
>                    Store (DerefOf (Index (BMST, B2IX)), BUFF)
>                    Store (0x07, Local0)
>                    Store (Local5, Local2)
>                    While (LAnd (Local2, LNot (LLess (Local0, 0x02))))
>                    {
>                        Store (Subtract (DerefOf (Index (BUFF, Local0)), 0x30), Local1)
>                        Divide (Add (Local1, Local2), 0x0A, Local1, Local2)
>                        Store (Add (Local1, 0x30), Index (BUFF, Local0))
>                        Decrement (Local0)
>                    }
>
>                    Store (BUFF, Index (BIF2, 0x09))
>                }
>                Else
>                {
>                    Store (DerefOf (Index (BMNT, B2IX)), Index (BIF2, 0x09))
>                }
>
>                Return (BIF2)
>            }
>
>            Method (_BST, 0, NotSerialized)
>            {
>                _INI ()
>                Store (Zero, Local0)
>                If (B2P)
>                {
>                    If (B2C)
>                    {
>                        Or (Local0, 0x02, Local0)
>                    }
>                    Else
>                    {
>                        Or (Local0, One, Local0)
>                    }
>
>                    If (LNot (LGreater (B2CP, One)))
>                    {
>                        Or (Local0, 0x04, Local0)
>                    }
>                }
>
>                Store (MKWD (B2CL, B2CH), Local1)
>                Divide (Multiply (B2CP, MKWD (B2LL, B2LH)), 0x03E8, Local4, Local2)
>                If (Local4)
>                {
>                    Increment (Local2)
>                }
>
>                Multiply (Local2, 0x0A, Local2)
>                Store (MKWD (B2VL, B2VH), Local3)
>                Store (Local0, Index (BST2, Zero))
>                Store (Local1, Index (BST2, One))
>                Store (Local2, Index (BST2, 0x02))
>                Store (Local3, Index (BST2, 0x03))
>                Return (BST2)
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                If (FBAY)
>                {
>                    Return (0x00)
>                }
>                Else
>                {
>                    If (B2P)
>                    {
>                        Return (0x1F)
>                    }
>
>                    Return (0x0F)
>                }
>            }
>
>            Method (BCHK, 0, NotSerialized)
>            {
>                If (LNot (LEqual (B2P, B2PS)))
>                {
>                    Notify (\_SB.CMB2, 0x81)
>                    Store (B2P, B2PS)
>                }
>
>                If (B2PS)
>                {
>                    Store (MKWD (B2LL, B2LH), Local0)
>                    If (LNot (LEqual (Local0, B2LS)))
>                    {
>                        Notify (\_SB.CMB2, 0x81)
>                    }
>
>                    If (LOr (LNot (LEqual (B2C, B2CS)), LNot (LEqual (B2CP, B2RS))))
>                    {
>                        Notify (\_SB.CMB2, 0x80)
>                    }
>
>                    Store (Local0, B2LS)
>                    Store (B2C, B2CS)
>                    Store (B2CP, B2RS)
>                }
>            }
>        }
>    }
>
>    Scope (_GPE)
>    {
>        Method (_L05, 0, NotSerialized)
>        {
>            Notify (\_SB.PCI0.AZAL, 0x02)
>        }
>
>        Method (_L08, 0, NotSerialized)
>        {
>            If (LNot (LOr (RI2M, RI2)))
>            {
>                Notify (\_SB.PCI0.PCIB, 0x02)
>            }
>
>            If (LNot (RI1M))
>            {
>                Notify (\_SB.PCI0.LPCB.UAR1, 0x02)
>            }
>        }
>
>        Method (_L09, 0, NotSerialized)
>        {
>            If (\_SB.PCI0.EXP1.PSP1)
>            {
>                Store (0x01, \_SB.PCI0.EXP1.PSP1)
>                Store (0x01, \_SB.PCI0.EXP1.PCS1)
>                Store (0x01, EXPS)
>                Store (0x01, EXWS)
>                Notify (\_SB.PCI0.EXP1, 0x02)
>            }
>
>            If (\_SB.PCI0.EXP2.PSP2)
>            {
>                Store (0x01, \_SB.PCI0.EXP2.PSP2)
>                Notify (\_SB.PCI0.EXP2, 0x02)
>            }
>        }
>
>        Method (_L0B, 0, NotSerialized)
>        {
>            Notify (\_SB.PCI0.PCIB, 0x02)
>        }
>
>        Method (_L10, 0, NotSerialized)
>        {
>            Store (SSF0, Local0)
>            Store (Local0, SSF0)
>            And (Local0, Not (SSM0), Local0)
>            Store (SSF1, Local1)
>            Store (Local1, SSF1)
>            And (Local1, Not (SSM1), Local1)
>            Store (SSF2, Local2)
>            Store (Local2, SSF2)
>            And (Local2, Not (SSM2), Local2)
>            If (And (Local2, 0x10))
>            {
>                \_SB.AC.ACHK ()
>                \_SB.CMB1.BCHK ()
>                \_SB.CMB2.BCHK ()
>                If (LOr (LNot (LEqual (LWMD, PLWM)), LNot (LEqual (TALM, PTAL))))
>                {
>                    Store (LWMD, PLWM)
>                    Store (TALM, PTAL)
>                    Store (0x95, CMD)
>                    Or (PLWM, ShiftLeft (PTAL, 0x01), DVID)
>                    Store (Zero, SSMI)
>                }
>
>                If (LAnd (TALM, LNot (ACPW)))
>                {
>                    Store (One, FOCT)
>                }
>                Else
>                {
>                    Store (Zero, FOCT)
>                }
>            }
>
>            If (And (Local0, 0x01))
>            {
>                \_SB.PCI0.GFX0.PHTK ()
>                Store (0x80, CMD)
>                Store (Zero, SSMI)
>                \_SB.PCI0.GFX0.AHTK ()
>                If (AHKF)
>                {
>                    Notify (\_SB.PCI0.LPCB.FJEX, 0x80)
>                }
>
>                If (IRBF)
>                {
>                    \_SB.FEXT.SIRB (IRBC)
>                    Notify (\_SB.FEXT, 0x80)
>                    Store (Zero, IRBF)
>                }
>            }
>
>            If (And (Local1, 0x30))
>            {
>                \_SB.PCI0.LPCB.CMBT.SWCF ()
>            }
>
>            If (And (Local2, 0x08))
>            {
>                Store (B1SU, Local3)
>                Store (B1SD, Local4)
>                Store (TBSF, Local5)
>                Store (B2SU, Local6)
>                Store (B2SD, Local7)
>                Store (Zero, STAE)
>                If (LNot (FBAY))
>                {
>                    If (LAnd (Local3, LNot (B1TC)))
>                    {
>                        \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
>                        Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
>                    }
>
>                    If (LOr (LAnd (Local4, B1TC), LAnd (Local5, TMBF)))
>                    {
>                        \_SB.PCI0.PATA.PRIM.MAST.BON ()
>                        If (LAnd (LAnd (BRST, BY1O), B1TC))
>                        {
>                            Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
>                        }
>                    }
>                }
>
>                If (Local5)
>                {
>                    If (LNot (TMBF))
>                    {
>                        Store (0xF0, TIMB)
>                        If (LLess (TCNT, 0xFFFFFFFF))
>                        {
>                            Increment (TCNT)
>                        }
>                    }
>                    Else
>                    {
>                        Store (Zero, TMBF)
>                        If (TTIM)
>                        {
>                            Store (0xD2, TIMB)
>                        }
>                        Else
>                        {
>                            Store (Zero, TBSM)
>                        }
>                    }
>                }
>
>                If (LOr (Local6, Local7))
>                {
>                    Sleep (0x03E8)
>                    Store (Zero, B2SU)
>                    Store (Zero, B2SD)
>                    \_SB.PCI0.LPCB.PRCF ()
>                    If (RPEN)
>                    {
>                        If (LNot (LEqual (B2TC, RPDS)))
>                        {
>                            Store (B2TC, RPDS)
>                            If (RPDS)
>                            {
>                                Notify (\_SB.REPL, Zero)
>                            }
>                            Else
>                            {
>                                Sleep (0x0FA0)
>                                Notify (\_SB.REPL, One)
>                            }
>                        }
>                    }
>                }
>            }
>        }
>
>        Method (_L11, 0, NotSerialized)
>        {
>            If (EXPL)
>            {
>                \_SB.PCI0.EXP2.EXPC.EXIN ()
>            }
>            Else
>            {
>                \_SB.PCI0.EXP2.EXPC.EXRM ()
>            }
>
>            Sleep (0x64)
>            Notify (\_SB.PCI0.EXP2.EXPC, One)
>        }
>
>        Method (_L18, 0, NotSerialized)
>        {
>            Sleep (0xFA)
>            Store (0x97, CMD)
>            Store (Zero, SSMI)
>            Not (LPOL, LPOL)
>            Notify (\_SB.LID, 0x80)
>        }
>    }
>
>    Name (_S0, Package (0x04)
>    {
>        0x00, 
>        0x00, 
>        0x00, 
>        0x00
>    })
>    Name (_S3, Package (0x04)
>    {
>        0x05, 
>        0x05, 
>        0x00, 
>        0x00
>    })
>    Name (_S4, Package (0x04)
>    {
>        0x06, 
>        0x06, 
>        0x00, 
>        0x00
>    })
>    Name (_S5, Package (0x04)
>    {
>        0x07, 
>        0x07, 
>        0x00, 
>        0x00
>    })
>    Method (_PTS, 1, NotSerialized)
>    {
>        If (LAnd (LNot (LLess (Arg0, One)), LNot (LGreater (Arg0, 0x04))))
>        {
>            If (LNot (FBAY))
>            {
>                If (\_SB.PCI0.PATA.PRIM.MAST._STA ())
>                {
>                    Store (Zero, BYIS)
>                }
>                Else
>                {
>                    Store (0xFF, BYIS)
>                }
>            }
>
>            If (RPEN)
>            {
>                Store (RPDS, DC1S)
>            }
>
>            If (\_SB.PCI0.EXP2.EXPC._STA ())
>            {
>                Store (Zero, EXIS)
>            }
>            Else
>            {
>                Store (0xFF, EXIS)
>            }
>        }
>
>        \_SB.PCI0.LPCB.CMBT.BPTS (Arg0)
>        Store (Zero, WAPB)
>        If (LAnd (LEqual (TPMF, 0x02), LNot (LLess (Arg0, 0x04))))
>        {
>            Store (0xA0, CMD)
>            Store (Arg0, INF)
>            Store (Zero, SSMI)
>        }
>
>        If (TTIM)
>        {
>            Store (0x9A, CMD)
>            Store (TCNT, DVID)
>            Store (Zero, TCNT)
>            Store (Zero, SSMI)
>        }
>
>        While (\_SB.PCI0.EXP1.PSP1)
>        {
>            Store (One, \_SB.PCI0.EXP1.PSP1)
>        }
>
>        While (\_SB.PCI0.EXP1.PCS1)
>        {
>            Store (One, \_SB.PCI0.EXP1.PCS1)
>        }
>
>        While (EXPS)
>        {
>            Store (One, EXPS)
>        }
>
>        While (EXWS)
>        {
>            Store (One, EXWS)
>        }
>    }
>
>    Method (_WAK, 1, NotSerialized)
>    {
>        \_SB.PCI0.LPCB.AINI ()
>        \_SB.PCI0.PCIB._INI ()
>        \_SB.FEXT._INI ()
>        \_SB.PCI0.LPCB.CMBT.BWAK (Arg0)
>        If (LEqual (Arg0, 0x03))
>        {
>            Store (0x9B, CMD)
>            Store (0x04, DVID)
>            Store (Zero, SSMI)
>        }
>
>        If (WAPB)
>        {
>            Notify (\_SB.PWRB, 0x02)
>        }
>
>        If (LEqual (Arg0, 0x04))
>        {
>            \_SB.FEXT.FUNC (0x1002, 0x03, Ones, WBTN)
>        }
>
>        If (LAnd (LNot (LLess (Arg0, One)), LNot (LGreater (Arg0, 0x04))))
>        {
>            If (LNot (FBAY))
>            {
>                If (LEqual (BYIS, 0xFF))
>                {
>                    If (\_SB.PCI0.PATA.PRIM.MAST.BIDE ())
>                    {
>                        If (LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ()))
>                        {
>                            \_SB.PCI0.PATA.PRIM.MAST.BON ()
>                        }
>
>                        If (LAnd (LAnd (BRST, BY1O), B1TC))
>                        {
>                            Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
>                        }
>                    }
>                }
>                Else
>                {
>                    If (LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ()))
>                    {
>                        \_SB.PCI0.PATA.PRIM.MAST.TMCL ()
>                        Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
>                    }
>                    Else
>                    {
>                        If (LEqual (Arg0, 0x04))
>                        {
>                            Store (0x87, CMD)
>                            Store (Zero, DVID)
>                            Store (Zero, SSMI)
>                            Name (BFMN, Buffer (0x28) {})
>                            Store (PIID, BFMN)
>                            Store (Zero, Local0)
>                            Store (Zero, Local1)
>                            While (LAnd (LNot (Local0), LLess (Local1, 0x28)))
>                            {
>                                If (LEqual (DerefOf (Index (\_SB.PCI0.PATA.PMMN, Local1)), DerefOf (Index (BFMN, Local1))))
>                                {
>                                    Increment (Local1)
>                                }
>                                Else
>                                {
>                                    Store (0x01, Local0)
>                                }
>                            }
>
>                            If (Local0)
>                            {
>                                \_SB.PCI0.PATA.PRIM.MAST.BOFF ()
>                                Notify (\_SB.PCI0.PATA.PRIM.MAST, One)
>                            }
>                        }
>                    }
>
>                    If (LAnd (\_SB.PCI0.PATA.PRIM.MAST.BIDE (), LNot (\_SB.PCI0.PATA.PRIM.MAST._STA ())))
>                    {
>                        Store (0x01, TMBF)
>                        Store (0x01, TBSM)
>                        Store (0x00, TBSF)
>                        Store (0x1E, TIMB)
>                    }
>                }
>            }
>
>            \_SB.PCI0.LPCB.PRCF ()
>            If (RPEN)
>            {
>                If (LNot (LEqual (B2TC, DC1S)))
>                {
>                    Store (B2TC, RPDS)
>                    If (RPDS)
>                    {
>                        Notify (\_SB.REPL, Zero)
>                    }
>                    Else
>                    {
>                        Notify (\_SB.REPL, One)
>                    }
>                }
>            }
>
>            If (\_SB.PCI0.EXP2.EXPC._STA ())
>            {
>                If (EXIS)
>                {
>                    Notify (\_SB.PCI0.EXP2.EXPC, One)
>                }
>            }
>            Else
>            {
>                If (LNot (EXIS))
>                {
>                    Notify (\_SB.PCI0.EXP2.EXPC, One)
>                }
>            }
>        }
>
>        If (NGTM)
>        {
>            \_SB.FEXT.FUNC (0x1004, 0x01, 0x04, 0x00)
>        }
>
>        Return (Zero)
>    }
>}
>

Actions: View

Attachments on bug 151517: 68857 | 69602 | 69656 | 70613 | 73634