Attachment 1585 Details for Bug 1678 – dsdt.dsl that fixes freezings when starting X by changing some IRQs

dsdt.dsl that fixes freezings when starting X by changing some IRQs

dsdt.dsl(fixed) (text/plain), 95.38 KB, created by Thomas Riedel on 2004-12-21 15:08:28 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Riedel

Created: 2004-12-21 15:08:28 UTC

Size: 95.38 KB

patch

obsolete

>/*
> * Intel ACPI Component Architecture
> * AML Disassembler version 20041203
> *
> * Disassembly of dsdt.dat, Mon Dec 20 23:10:19 2004
> */
>DefinitionBlock ("DSDT.aml", "DSDT", 1, "COMPAL", "CY26____", 100925440)
>{
>    Scope (_PR)
>    {
>        Processor (CPU0, 0x00, 0x00008010, 0x06)
>        {
>            Method (_PPC, 0, NotSerialized)
>            {
>                Return (0x00)
>            }
>        }
>    }
>
>    Name (_S0, Package (0x04)
>    {
>        0x00, 
>        0x00, 
>        0x00, 
>        0x00
>    })
>    Name (_S3, Package (0x04)
>    {
>        0x03, 
>        0x03, 
>        0x00, 
>        0x00
>    })
>    Name (_S4, Package (0x04)
>    {
>        0x04, 
>        0x04, 
>        0x00, 
>        0x00
>    })
>    Name (_S5, Package (0x04)
>    {
>        0x05, 
>        0x05, 
>        0x00, 
>        0x00
>    })
>    OperationRegion (PORT, SystemIO, 0x80, 0x01)
>    Field (PORT, ByteAcc, NoLock, Preserve)
>    {
>        P80H,   8
>    }
>
>    OperationRegion (XCMS, SystemIO, 0x72, 0x02)
>    Field (XCMS, ByteAcc, NoLock, Preserve)
>    {
>        XCM1,   8, 
>        XCM2,   8
>    }
>
>    IndexField (XCM1, XCM2, ByteAcc, NoLock, Preserve)
>    {
>        Offset (0x3F), 
>        SLPT,   8
>    }
>
>    Method (_PTS, 1, NotSerialized)
>    {
>        If (LEqual (Arg0, 0x04))
>        {
>            If (\_SB.PCI0.LPCB.EC0.ECOK)
>            {
>                Store (Arg0, SLPT)
>                Store (0x01, \_SB.PCI0.LPCB.EC0.S4S)
>            }
>
>            \_SB.PCI0.LPCB.PHSS (0x99)
>        }
>    }
>
>    Method (_WAK, 1, NotSerialized)
>    {
>        If (LEqual (Arg0, 0x04))
>        {
>            If (\_SB.PCI0.LPCB.EC0.ECOK)
>            {
>                Store (0x00, SLPT)
>                \_SB.PCI0.LPCB.PHSS (0x98)
>            }
>        }
>    Return(Package(0x02){0x00, 0x00})	
>    }
>
>    Name (ECDY, 0x00)
>    Scope (\_SB)
>    {
>        Device (LID)
>        {
>            Name (_HID, EisaId ("PNP0C0D"))
>            Method (_LID, 0, NotSerialized)
>            {
>                Store ("LID", Debug)
>                Return (\_SB.PCI0.PWR.RSM2)
>            }
>        }
>
>        Mutex (\PSMX, 0x00)
>        Device (PWRB)
>        {
>            Name (_HID, EisaId ("PNP0C0C"))
>        }
>
>        Device (PCI0)
>        {
>            Name (_HID, EisaId ("PNP0A03"))
>            Name (_ADR, 0x00)
>            Device (PWR)
>            {
>                Name (_ADR, 0x00060000)
>                OperationRegion (PREG, PCI_Config, 0x00, 0x0100)
>                Field (PREG, AnyAcc, NoLock, Preserve)
>                {
>                    Offset (0x80), 
>                        ,   6, 
>                    ENB1,   1, 
>                        ,   6, 
>                    THPE,   2, 
>                    ENB2,   1, 
>                    Offset (0x88), 
>                        ,   2, 
>                    RSM2,   1
>                }
>            }
>
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (0x00, SLPT)
>            }
>
>            OperationRegion (BAR1, PCI_Config, 0x14, 0x04)
>            Field (BAR1, ByteAcc, NoLock, Preserve)
>            {
>                Z000,   32
>            }
>
>            OperationRegion (MREG, PCI_Config, 0xB8, 0x14)
>            Field (MREG, ByteAcc, NoLock, Preserve)
>            {
>                CS0,    8, 
>                CS1,    8, 
>                CS2,    8, 
>                CS3,    8, 
>                Offset (0x10), 
>                FBSL,   8, 
>                FBSM,   8
>            }
>
>            Method (TOM, 0, NotSerialized)
>            {
>                Multiply (FBSL, 0x00010000, Local0)
>                Multiply (FBSM, 0x01000000, Local1)
>                Add (Local0, Local1, Local0)
>                Return (Local0)
>            }
>
>            OperationRegion (VGAM, SystemMemory, 0x000C0002, 0x01)
>            Field (VGAM, ByteAcc, Lock, Preserve)
>            {
>                VSIZ,   8
>            }
>
>            Name (RSRC, ResourceTemplate ()
>            {
>                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, SubDecode,
>                    0x0000,
>                    0x0000,
>                    0x00FF,
>                    0x0000,
>                    0x0100, 0x00)
>                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
>                    0x00000000,
>                    0x000A0000,
>                    0x000BFFFF,
>                    0x00000000,
>                    0x00020000, 0x00)
>                DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
>                    0x00000000,
>                    0x00100000,
>                    0xFFFDFFFF,
>                    0x00000000,
>                    0xFFEE0000, 0x00)
>                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
>                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x0000,
>                    0x0000,
>                    0x0CF7,
>                    0x0000,
>                    0x0CF8, 0x00)
>                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x0000,
>                    0x0D00,
>                    0xFFFF,
>                    0x0000,
>                    0xF300, 0x00)
>            })
>            Method (_CRS, 0, Serialized)
>            {
>                CreateDWordField (RSRC, 0x1F, VMAX)
>                CreateDWordField (RSRC, 0x27, VLEN)
>                ShiftLeft (VSIZ, 0x09, Local0)
>                Add (Local0, 0x000BFFFF, VMAX)
>                Add (Local0, 0x00020000, VLEN)
>                CreateDWordField (RSRC, 0x36, BTMN)
>                CreateDWordField (RSRC, 0x3A, BTMX)
>                CreateDWordField (RSRC, 0x42, BTLN)
>                Store (\_SB.PCI0.TOM (), BTMN)
>                Subtract (0xFFF80000, BTMN, BTLN)
>                Subtract (Add (BTMN, BTLN), 0x01, BTMX)
>                Return (RSRC)
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0F)
>            }
>
>            Name (_PRT, Package (0x0A)
>            {
>                Package (0x04)
>                {
>                    0x0002FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKU, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0003FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKG, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0008FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKH, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0009FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKB, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x000AFFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKC, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x000BFFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKA, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x000BFFFF, 
>                    0x01, 
>                    \_SB.PCI0.LPCB.LNKB, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x000FFFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKE, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0010FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKB, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0014FFFF, 
>                    0x00, 
>                    \_SB.PCI0.LPCB.LNKD, 
>                    0x00
>                }
>            })
>            Device (LPCB)
>            {
>                Name (_ADR, 0x00070000)
>                OperationRegion (PUSB, PCI_Config, 0x74, 0x01)
>                Field (PUSB, ByteAcc, NoLock, Preserve)
>                {
>                    PIRU,   4, 
>                    Offset (0x01)
>                }
>
>                OperationRegion (PIRX, PCI_Config, 0x48, 0x04)
>                Field (PIRX, ByteAcc, NoLock, Preserve)
>                {
>                    PIRA,   4, 
>                    PIRB,   4, 
>                    PIRC,   4, 
>                    PIRD,   4, 
>                    PIRE,   4, 
>                    PIRF,   4, 
>                    PIRG,   4, 
>                    PIRH,   4
>                }
>
>                Name (IXLT, Package (0x10)
>                {
>                    0x00, 
>                    0x0200, 
>                    0x08, 
>                    0x0400, 
>                    0x10, 
>                    0x20, 
>                    0x80, 
>                    0x40, 
>                    0x02, 
>                    0x0800, 
>                    0x00, 
>                    0x1000, 
>                    0x00, 
>                    0x4000, 
>                    0x00, 
>                    0x8000
>                })
>                Device (LNKA)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x01)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRA)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {3}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRA)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLA, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLA, 0x01, IRQ0)
>                        Store (PIRA, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ0)
>                        Return (RTLA)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRA)
>                    }
>                }
>
>                Device (LNKB)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x02)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRB)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {5}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRB)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLB, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLB, 0x01, IRQ1)
>                        Store (PIRB, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ1)
>                        Return (RTLB)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRB)
>                    }
>                }
>
>                Device (LNKC)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x03)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRC)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {11}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRC)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLC, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Exclusive) {}
>                        })
>                        CreateWordField (RTLC, 0x01, IRQ2)
>                        Store (PIRC, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ2)
>                        Return (RTLC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRC)
>                    }
>                }
>
>                Device (LNKD)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x04)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRD)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {10}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRD)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLD, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLD, 0x01, IRQ3)
>                        Store (PIRD, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ3)
>                        Return (RTLD)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRD)
>                    }
>                }
>
>                Device (LNKE)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x05)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRE)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {5}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRE)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLE, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLE, 0x01, IRQ4)
>                        Store (PIRE, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ4)
>                        Return (RTLE)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRE)
>                    }
>                }
>
>                Device (LNKF)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x06)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRF)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {3,5,9,10}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRF)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLF, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLF, 0x01, IRQ5)
>                        Store (PIRF, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ5)
>                        Return (RTLF)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRF)
>                    }
>                }
>
>                Device (LNKG)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x07)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRG)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {10}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRG)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLG, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLG, 0x01, IRQ6)
>                        Store (PIRG, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ6)
>                        Return (RTLG)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRG)
>                    }
>                }
>
>                Device (LNKH)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x08)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRH)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {10}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRH)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLH, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLH, 0x01, IRQ7)
>                        Store (PIRH, Local1)
>                        Store (DerefOf (Index (IXLT, Local1)), IRQ7)
>                        Return (RTLH)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRH)
>                    }
>                }
>
>                Device (LNKU)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x09)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (PIRU)
>                        {
>                            Return (0x0B)
>                        }
>                        Else
>                        {
>                            Return (0x09)
>                        }
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {9}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (0x00, PIRU)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RTLU, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateWordField (RTLU, 0x01, IRQ8)
>                        Store (PIRU, Local1)
>                        Store (DerefOf (Index (IXLT, Local1, Local0)), IRQ8)
>                        Return (Local0)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x01, IRA0)
>                        Store (Match (IXLT, MEQ, IRA0, MGT, 0x00, 0x00), PIRU)
>                    }
>                }
>
>                Device (DMAC)
>                {
>                    Name (_HID, EisaId ("PNP0200"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
>                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
>                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
>                        DMA (Compatibility, NotBusMaster, Transfer8_16) {4}
>                    })
>                }
>
>                Device (PIC)
>                {
>                    Name (_HID, EisaId ("PNP0000"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
>                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
>                        IRQ (Edge, ActiveHigh, Exclusive) {2}
>                    })
>                }
>
>                Device (TIME)
>                {
>                    Name (_HID, EisaId ("PNP0100"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
>                        IRQ (Edge, ActiveHigh, Exclusive) {0}
>                    })
>                }
>
>                Device (RTC)
>                {
>                    Name (_HID, EisaId ("PNP0B00"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0070, 0x0070, 0x01, 0x02)
>                        IO (Decode16, 0x0072, 0x0072, 0x01, 0x02)
>                        IRQ (Edge, ActiveHigh, Exclusive) {8}
>                    })
>                }
>
>                Device (MATH)
>                {
>                    Name (_HID, EisaId ("PNP0C04"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x0F)
>                        IRQ (Edge, ActiveHigh, Exclusive) {13}
>                    })
>                }
>
>                Device (SPKR)
>                {
>                    Name (_HID, EisaId ("PNP0800"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
>                    })
>                }
>
>                Device (KBC0)
>                {
>                    Name (_HID, EisaId ("PNP0303"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
>                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
>                        IRQ (Edge, ActiveHigh, Exclusive) {1}
>                    })
>                }
>
>                Device (MSE0)
>                {
>                    Name (_HID, EisaId ("PNP0F13"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IRQ (Edge, ActiveHigh, Exclusive) {12}
>                    })
>                }
>
>                Device (SYSR)
>                {
>                    Name (_HID, EisaId ("PNP0C02"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x004E, 0x004E, 0x01, 0x02)
>                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
>                        IO (Decode16, 0x00B0, 0x00B0, 0x01, 0x04)
>                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
>                        IO (Decode16, 0x0200, 0x0200, 0x01, 0x10)
>                        IO (Decode16, 0x040B, 0x040B, 0x01, 0x01)
>                        IO (Decode16, 0x0480, 0x0480, 0x01, 0x10)
>                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
>                        IO (Decode16, 0x04D6, 0x04D6, 0x01, 0x01)
>                        IO (Decode16, 0x8000, 0x8000, 0x01, 0x80)
>                        IO (Decode16, 0xFE10, 0xFE10, 0x01, 0x02)
>                    })
>                }
>
>                Device (MEM)
>                {
>                    Name (_HID, EisaId ("PNP0C01"))
>                    Name (MSRC, ResourceTemplate ()
>                    {
>                        Memory32Fixed (ReadWrite, 0x00000000, 0x00000000)
>                        Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
>                        Memory32Fixed (ReadOnly, 0x000C0000, 0x0000F000)
>                        Memory32Fixed (ReadOnly, 0x000DC000, 0x00004000)
>                        Memory32Fixed (ReadOnly, 0x000EC000, 0x00014000)
>                        Memory32Fixed (ReadWrite, 0x00100000, 0x07F00000)
>                        Memory32Fixed (ReadOnly, 0xFFF80000, 0x00080000)
>                    })
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateDWordField (MSRC, 0x04, BARX)
>                        CreateDWordField (MSRC, 0x08, GALN)
>                        Store (0x1000, GALN)
>                        Store (\_SB.PCI0.Z000, Local0)
>                        And (Local0, 0xFFFFFFF0, BARX)
>                        CreateDWordField (MSRC, 0x44, EMLN)
>                        Subtract (\_SB.PCI0.TOM (), 0x00100000, EMLN)
>                        Return (MSRC)
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>                }
>
>                OperationRegion (SMI0, SystemIO, 0x0000FE00, 0x00000002)
>                Field (SMI0, AnyAcc, NoLock, Preserve)
>                {
>                    SMIC,   8
>                }
>
>                OperationRegion (SMI1, SystemMemory, 0x1BEFFE3D, 0x00000100)
>                Field (SMI1, AnyAcc, NoLock, Preserve)
>                {
>                    BCMD,   8, 
>                    DID,    32, 
>                    INFO,   1024
>                }
>
>                Field (SMI1, AnyAcc, NoLock, Preserve)
>                {
>                    AccessAs (ByteAcc, 0x00), 
>                    Offset (0x05), 
>                    INF,    8, 
>                    INF1,   32
>                }
>
>                Mutex (PSMX, 0x00)
>                Method (PHSS, 1, NotSerialized)
>                {
>                    Acquire (PSMX, 0xFFFF)
>                    Store (0x80, BCMD)
>                    Store (Arg0, DID)
>                    Store (Zero, SMIC)
>                    Release (PSMX)
>                }
>
>                OperationRegion (SIIO, SystemIO, 0x0370, 0x02)
>                Field (SIIO, ByteAcc, NoLock, Preserve)
>                {
>                    INDX,   8, 
>                    DATA,   8
>                }
>
>                IndexField (INDX, DATA, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x30), 
>                    CR30,   8, 
>                    Offset (0x60), 
>                    CR60,   8, 
>                    CR61,   8, 
>                    Offset (0x70), 
>                    CR70,   8, 
>                    Offset (0x74), 
>                    CR74,   8, 
>                    Offset (0xF0), 
>                    CRF0,   8, 
>                    CRF1,   8, 
>                    CRF2,   8, 
>                    Offset (0xF4), 
>                    CRF4,   8, 
>                    CRF5,   8
>                }
>
>                Method (ENFG, 1, NotSerialized)
>                {
>                    Acquire (MTIO, 0xFFFF)
>                    Store (0x51, INDX)
>                    Store (0x23, INDX)
>                    Store (0x07, INDX)
>                    Store (Arg0, DATA)
>                }
>
>                Method (EXFG, 0, NotSerialized)
>                {
>                    Store (0xBB, INDX)
>                    Release (MTIO)
>                }
>
>                Device (FDC)
>                {
>                    Name (_HID, EisaId ("PNP0700"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG (0x00)
>                        And (CR30, 0x01, Local0)
>                        And (CR60, 0x03, Local1)
>                        EXFG ()
>                        If (LAnd (Local0, Local1))
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            Return (0x0D)
>                        }
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        \_SB.PCI0.LPCB.COM1.SAVE ()
>                        ENFG (0x00)
>                        Store (0x00, CR30)
>                        Store (0x00, CR60)
>                        Store (0x00, CR61)
>                        Store (0x00, CR70)
>                        Store (0x04, CR74)
>                        EXFG ()
>                    }
>
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
>                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
>                        IRQNoFlags () {6}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                    })
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO1L)
>                        CreateWordField (RSRC, 0x04, IO1H)
>                        CreateWordField (RSRC, 0x0A, IO2L)
>                        CreateWordField (RSRC, 0x0C, IO2H)
>                        CreateWordField (RSRC, 0x11, IRQX)
>                        CreateByteField (RSRC, 0x14, DMAX)
>                        Store (Zero, IO1L)
>                        Store (Zero, IO1H)
>                        Store (Zero, IO2L)
>                        Store (Zero, IO2H)
>                        Store (Zero, IRQX)
>                        Store (Zero, DMAX)
>                        ENFG (0x00)
>                        Store (CR30, Local0)
>                        Store (CR60, Local1)
>                        If (LAnd (Local0, Local1))
>                        {
>                            Store (_PRS, RSRC)
>                        }
>
>                        EXFG ()
>                        Return (RSRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
>                        IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
>                        IRQNoFlags () {6}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        Store (Arg0, RSRC)
>                        CreateWordField (RSRC, 0x02, IOX)
>                        CreateWordField (RSRC, 0x11, IRQX)
>                        CreateByteField (RSRC, 0x14, DMAX)
>                        ENFG (0x00)
>                        And (IOX, 0xFF, CR61)
>                        ShiftRight (IOX, 0x08, CR60)
>                        FindSetRightBit (IRQX, Local0)
>                        If (Local0)
>                        {
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, CR70)
>                        FindSetRightBit (DMAX, Local0)
>                        If (Local0)
>                        {
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, CR74)
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PSC, 0, NotSerialized)
>                    {
>                        ENFG (0x00)
>                        And (CR30, 0x01, Local0)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (0x00)
>                        }
>                        Else
>                        {
>                            Return (0x03)
>                        }
>                    }
>
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        ENFG (0x00)
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        ENFG (0x00)
>                        Store (0x00, CR30)
>                        EXFG ()
>                    }
>                }
>
>                Device (LPT)
>                {
>                    Method (_HID, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        And (CRF0, 0x02, Local0)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (0x0104D041)
>                        }
>                        Else
>                        {
>                            Return (0x0004D041)
>                        }
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        And (CR30, 0x01, Local0)
>                        And (CR60, 0x03, Local1)
>                        EXFG ()
>                        If (LAnd (Local0, Local1))
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            Return (0x0D)
>                        }
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        Store (0x00, CR30)
>                        Store (0x00, CR60)
>                        Store (0x00, CR61)
>                        Store (0x00, CR70)
>                        Store (0x04, CR74)
>                        EXFG ()
>                    }
>
>                    Name (CRSA, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
>                        IRQNoFlags () {}
>                    })
>                    Name (CRSB, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x08)
>                        IRQNoFlags () {}
>                        DMA (Compatibility, NotBusMaster, Transfer8) {}
>                    })
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (CRSA, 0x02, IOAL)
>                        CreateWordField (CRSA, 0x04, IOAH)
>                        CreateByteField (CRSA, 0x07, LENA)
>                        CreateWordField (CRSA, 0x09, IRAX)
>                        Store (Zero, IOAL)
>                        Store (Zero, IOAH)
>                        Store (Zero, LENA)
>                        Store (Zero, IRAX)
>                        CreateWordField (CRSB, 0x02, IOBL)
>                        CreateWordField (CRSB, 0x04, IOBH)
>                        CreateByteField (CRSB, 0x07, LENB)
>                        CreateWordField (CRSB, 0x0A, IOCL)
>                        CreateWordField (CRSB, 0x0C, IOCH)
>                        CreateByteField (CRSB, 0x0F, LENC)
>                        CreateWordField (CRSB, 0x11, IRBX)
>                        CreateByteField (CRSB, 0x14, DMAX)
>                        Store (Zero, IOBL)
>                        Store (Zero, IOBH)
>                        Store (Zero, LENB)
>                        Store (Zero, IOCL)
>                        Store (Zero, IOCH)
>                        Store (Zero, LENC)
>                        Store (Zero, IRBX)
>                        Store (Zero, DMAX)
>                        ENFG (0x03)
>                        Store (CR60, IOAL)
>                        ShiftLeft (IOAL, 0x08, Local1)
>                        Or (CR61, Local1, Local2)
>                        Store (Local2, IOAL)
>                        Store (Local2, IOAH)
>                        Store (Local2, IOBL)
>                        Store (Local2, IOBH)
>                        And (CRF0, 0x02, Local0)
>                        If (Local0)
>                        {
>                            Add (Local2, 0x0400, IOCL)
>                            Add (Local2, 0x0400, IOCH)
>                            If (LEqual (Local2, 0x03BC))
>                            {
>                                Store (0x04, LENA)
>                                Store (0x04, LENB)
>                                Store (0x04, LENC)
>                            }
>                            Else
>                            {
>                                Store (0x08, LENA)
>                                Store (0x08, LENB)
>                                Store (0x08, LENC)
>                            }
>                        }
>
>                        Store (CR70, Local1)
>                        ShiftLeft (One, Local1, IRAX)
>                        ShiftLeft (One, Local1, IRBX)
>                        Store (CR74, Local1)
>                        ShiftLeft (One, Local1, DMAX)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (CRSB)
>                        }
>                        Else
>                        {
>                            Return (CRSA)
>                        }
>                    }
>
>                    Name (PRSA, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IRQNoFlags () {5,7}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IRQNoFlags () {5,7}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IRQNoFlags () {5,7}
>                        }
>                        EndDependentFn ()
>                    })
>                    Name (PRSB, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x01, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x01, 0x08)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x01, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x01, 0x08)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x01, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x01, 0x04)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {1,3}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_PRS, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        And (CRF0, 0x02, Local0)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (PRSB)
>                        }
>                        Else
>                        {
>                            Return (PRSA)
>                        }
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        And (CRF0, 0x02, Local0)
>                        If (Local0)
>                        {
>                            Store (Arg0, CRSB)
>                            CreateWordField (CRSB, 0x02, IOB)
>                            CreateWordField (CRSB, 0x11, IRQB)
>                            CreateByteField (CRSB, 0x14, DMAX)
>                            And (IOB, 0xFF, CR61)
>                            ShiftRight (IOB, 0x08, CR60)
>                            FindSetRightBit (IRQB, Local0)
>                            If (Local0)
>                            {
>                                Decrement (Local0)
>                            }
>
>                            Store (Local0, CR70)
>                            FindSetRightBit (DMAX, Local0)
>                            If (Local0)
>                            {
>                                Decrement (Local0)
>                            }
>
>                            Store (Local0, CR74)
>                        }
>                        Else
>                        {
>                            Store (Arg0, CRSA)
>                            CreateWordField (CRSA, 0x02, IOA)
>                            CreateWordField (CRSA, 0x09, IRQA)
>                            And (IOA, 0xFF, CR61)
>                            ShiftRight (IOA, 0x08, CR60)
>                            FindSetRightBit (IRQA, Local0)
>                            If (Local0)
>                            {
>                                Decrement (Local0)
>                            }
>
>                            Store (Local0, CR70)
>                        }
>
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PSC, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        And (CR30, 0x01, Local0)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (0x00)
>                        }
>                        Else
>                        {
>                            Return (0x03)
>                        }
>                    }
>
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        ENFG (0x03)
>                        Store (0x00, CR30)
>                        EXFG ()
>                    }
>                }
>
>                Device (COM1)
>                {
>                    Name (_HID, EisaId ("PNP0501"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        And (CR30, 0x01, Local0)
>                        And (CR60, 0x03, Local1)
>                        EXFG ()
>                        If (LAnd (Local0, Local1))
>                        {
>                            Return (0x0F)
>                        }
>                        Else
>                        {
>                            Return (0x0D)
>                        }
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        Store (0x00, CR30)
>                        Store (0x00, CR60)
>                        Store (0x00, CR61)
>                        Store (0x00, CR70)
>                        EXFG ()
>                    }
>
>                    Name (RSRC, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                        IRQNoFlags () {4}
>                    })
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        CreateWordField (RSRC, 0x02, IO1L)
>                        CreateWordField (RSRC, 0x04, IO1H)
>                        CreateWordField (RSRC, 0x09, IRQX)
>                        Store (Zero, IO1L)
>                        Store (Zero, IO1H)
>                        Store (Zero, IRQX)
>                        ENFG (0x04)
>                        And (CR30, 0x01, Local0)
>                        If (Local0)
>                        {
>                            Store (CR60, IO1L)
>                            ShiftLeft (IO1L, 0x08, Local1)
>                            Or (CR61, Local1, Local2)
>                            Store (Local2, IO1L)
>                            Store (Local2, IO1H)
>                            Store (CR70, Local1)
>                            ShiftLeft (One, Local1, IRQX)
>                        }
>                        Else
>                        {
>                            Store (Zero, IO1L)
>                            Store (Zero, IO1H)
>                            Store (Zero, IRQX)
>                        }
>
>                        EXFG ()
>                        Return (RSRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                            IRQNoFlags () {4}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                            IRQNoFlags () {3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                            IRQNoFlags () {4}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                            IRQNoFlags () {3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
>                            IRQNoFlags () {3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
>                            IRQNoFlags () {4}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
>                            IRQNoFlags () {3}
>                        }
>                        StartDependentFn (0x00, 0x01)
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
>                            IRQNoFlags () {4}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        Store (Arg0, RSRC)
>                        CreateWordField (RSRC, 0x02, IO1L)
>                        CreateWordField (RSRC, 0x09, IRQX)
>                        ENFG (0x04)
>                        And (IO1L, 0xFF, CR61)
>                        ShiftRight (IO1L, 0x08, CR60)
>                        FindSetRightBit (IRQX, Local0)
>                        If (Local0)
>                        {
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, CR70)
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PSC, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        And (CR30, 0x01, Local0)
>                        EXFG ()
>                        If (Local0)
>                        {
>                            Return (0x00)
>                        }
>                        Else
>                        {
>                            Return (0x03)
>                        }
>                    }
>
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        Store (0x01, CR30)
>                        EXFG ()
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        Store (0x00, CR30)
>                        EXFG ()
>                    }
>
>                    Name (_PRW, Package (0x02)
>                    {
>                        0x0A, 
>                        0x04
>                    })
>                    Name (SV60, 0x00)
>                    Name (SV61, 0x00)
>                    Name (IRQV, 0x00)
>                    Method (SAVE, 0, NotSerialized)
>                    {
>                        ENFG (0x04)
>                        And (CR30, 0x01, Local0)
>                        If (Local0)
>                        {
>                            Store (CR60, SV60)
>                            Store (CR61, SV61)
>                            Store (CR70, IRQV)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Method (REST, 0, NotSerialized)
>                    {
>                        If (LNot (LEqual (SV60, Zero)))
>                        {
>                            ENFG (0x04)
>                            Or (CR30, 0x01, CR30)
>                            Store (SV60, CR60)
>                            Store (SV61, CR61)
>                            Store (IRQV, CR70)
>                            EXFG ()
>                        }
>                    }
>                }
>
>                Mutex (MTIO, 0x00)
>                Method (ECOK, 0, NotSerialized)
>                {
>                    If (LEqual (\_SB.PCI0.LPCB.EC0.ECOK, 0x01))
>                    {
>                        Return (0x01)
>                    }
>                    Else
>                    {
>                        Return (0x00)
>                    }
>                }
>
>                Device (EC0)
>                {
>                    Name (_HID, EisaId ("PNP0C09"))
>                    Name (_GPE, 0x19)
>                    Name (ECOK, Zero)
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
>                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
>                    })
>                    Method (_REG, 2, NotSerialized)
>                    {
>                        If (LEqual (Arg0, 0x03))
>                        {
>                            Store (Arg1, ECOK)
>                        }
>                    }
>
>                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
>                    Field (ERAM, ByteAcc, Lock, Preserve)
>                    {
>                        Offset (0x60), 
>                        SMPR,   8, 
>                        SMST,   8, 
>                        SMAD,   8, 
>                        SMCM,   8, 
>                        SMD0,   256, 
>                        BCNT,   8, 
>                        SMAA,   8, 
>                        Offset (0x90), 
>                        CHGM,   16, 
>                        CHGS,   16, 
>                        CHGC,   16, 
>                        CHGV,   16, 
>                        CHGA,   16, 
>                        BAL0,   1, 
>                        BAL1,   1, 
>                        BAL2,   1, 
>                        BAL3,   1, 
>                        Offset (0x9C), 
>                        BEEP,   1, 
>                        FAN1,   1, 
>                        FAN2,   1, 
>                        CRT,    1, 
>                        EXFD,   1, 
>                        PHDD,   1, 
>                        SHDD,   1, 
>                        FDD,    1, 
>                        SBTN,   1, 
>                        VIDO,   1, 
>                        VOLD,   1, 
>                        VOLU,   1, 
>                        MUTE,   1, 
>                        CONT,   1, 
>                        BRGT,   1, 
>                        HBTN,   1, 
>                        S4S,    1, 
>                        SKEY,   1, 
>                        BKEY,   1, 
>                        Offset (0xA3), 
>                        S0LD,   1, 
>                        S3LD,   1, 
>                        VGAQ,   1, 
>                        PCMQ,   1, 
>                        PCMR,   1, 
>                        ADP,    1, 
>                        SYS6,   1, 
>                        SYS7,   1, 
>                        PWAK,   1, 
>                        MWAK,   1, 
>                        LWAK,   1, 
>                        Offset (0xA5), 
>                        FOT,    8, 
>                        FSD1,   8, 
>                        FSD2,   8, 
>                        Offset (0xAF), 
>                        THMM,   1, 
>                        FNB0,   1, 
>                        FNB1,   1, 
>                        Offset (0xB0), 
>                        CTMP,   8, 
>                            ,   1, 
>                        LIDS,   1, 
>                        PMEE,   1, 
>                        PWBT,   1, 
>                        RINI,   1, 
>                        Offset (0xB8), 
>                        BCTL,   6, 
>                        BLED,   1, 
>                        Offset (0xB9), 
>                        BRTS,   8, 
>                        Offset (0xBB), 
>                        WLAT,   1, 
>                        BTAT,   1, 
>                        WLEX,   1, 
>                        BTEX,   1, 
>                        KLSW,   1, 
>                        Offset (0xBE), 
>                        RSMT,   16, 
>                            ,   4, 
>                        BMF0,   3, 
>                        BTY0,   1, 
>                        BST0,   8, 
>                        BRC0,   16, 
>                        BSN0,   16, 
>                        BPV0,   16, 
>                        BDV0,   16, 
>                        BDC0,   16, 
>                        BFC0,   16, 
>                        GAU0,   8, 
>                        Offset (0xE0), 
>                            ,   4, 
>                        BMF1,   3, 
>                        BTY1,   1, 
>                        BST1,   8, 
>                        BRC1,   16, 
>                        BSN1,   16, 
>                        BPV1,   16, 
>                        BDV1,   16, 
>                        BDC1,   16, 
>                        BFC1,   16, 
>                        GAU1,   8
>                    }
>
>                    OperationRegion (CCLK, SystemIO, 0x8010, 0x04)
>                    Field (CCLK, DWordAcc, NoLock, Preserve)
>                    {
>                            ,   1, 
>                        DUTY,   3, 
>                        THEN,   1, 
>                        Offset (0x01)
>                    }
>
>                    OperationRegion (ECRM, EmbeddedControl, 0x00, 0xFF)
>                    Field (ECRM, ByteAcc, Lock, Preserve)
>                    {
>                        Offset (0xAE), 
>                        THR0,   7, 
>                        THR7,   1
>                    }
>
>                    Method (PCLK, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.LPCB.EC0.THR7, 0x01))
>                        {
>                            Store (0x00, \_SB.PCI0.PWR.ENB1)
>                            Store (0x01, \_SB.PCI0.PWR.ENB2)
>                            Store (0x03, \_SB.PCI0.PWR.THPE)
>                            Store (0x04, Local0)
>                            Not (Local0, Local0)
>                            Add (Local0, 0x01, Local0)
>                            And (Local0, 0x07, Local0)
>                            Store (Local0, DUTY)
>                            Store (0x01, THEN)
>                        }
>                        Else
>                        {
>                            If (LEqual (\_SB.PCI0.LPCB.EC0.THR0, 0x00))
>                            {
>                                Store (0x00, THEN)
>                                Store (0x01, \_SB.PCI0.PWR.ENB1)
>                                Store (0x00, \_SB.PCI0.PWR.ENB2)
>                                Store (0x00, \_SB.PCI0.PWR.THPE)
>                                Store (0x00, DUTY)
>                            }
>                            Else
>                            {
>                                Store (\_SB.PCI0.LPCB.EC0.THR0, P80H)
>                                Store (0x00, \_SB.PCI0.PWR.ENB1)
>                                Store (0x01, \_SB.PCI0.PWR.ENB2)
>                                Store (0x03, \_SB.PCI0.PWR.THPE)
>                                Store (\_SB.PCI0.LPCB.EC0.THR0, Local0)
>                                Not (Local0, Local0)
>                                Add (Local0, 0x01, Local0)
>                                And (Local0, 0x07, Local0)
>                                Store (Local0, DUTY)
>                                Store (0x01, THEN)
>                            }
>                        }
>                    }
>
>                    Method (_Q11, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_11=====", Debug)
>                        If (\_SB.PCI0.LPCB.EC0.BRGT)
>                        {
>                            Store (\_SB.PCI0.LPCB.EC0.BRTS, INF)
>                            PHSS (0x08)
>                            Store (0x00, \_SB.PCI0.LPCB.EC0.BRGT)
>                        }
>                    }
>
>                    Method (_Q16, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_16=====", Debug)
>                        Store (0x01, LIDS)
>                        Notify (\_SB.LID, 0x80)
>                    }
>
>                    Method (_Q1C, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_1C=====", Debug)
>                        Store ("=====Display switch=====", Debug)
>                        If (\_SB.PCI0.LPCB.EC0.VIDO)
>                        {
>                            PHSS (0x01)
>                            Store (0x00, \_SB.PCI0.LPCB.EC0.VIDO)
>                        }
>                    }
>
>                    Method (_Q1D, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_1D=====", Debug)
>                        Store (0x1D, P80H)
>                        Sleep (0x07D0)
>                        If (\_SB.PCI0.LPCB.EC0.ECOK)
>                        {
>                            Store (0x1D, P80H)
>                            Sleep (0x07D0)
>                            PCLK ()
>                        }
>                    }
>
>                    Method (_Q1E, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_1E=====", Debug)
>                        Store (0x1E, P80H)
>                        Sleep (0x07D0)
>                        If (\_SB.PCI0.LPCB.EC0.ECOK)
>                        {
>                            Store (0x1D, P80H)
>                            Sleep (0x07D0)
>                            PCLK ()
>                        }
>                    }
>
>                    Method (_Q22, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_22=====", Debug)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                    }
>
>                    Method (_Q23, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_23=====", Debug)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                    }
>
>                    Method (_Q25, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_25=====", Debug)
>                        Sleep (0x07D0)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
>                        Sleep (0x64)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                    }
>
>                    Method (_Q37, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_37=====", Debug)
>                        Notify (\_SB.PCI0.LPCB.ACAD, 0x80)
>                        Sleep (0x64)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
>                        Sleep (0x64)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                    }
>
>                    Method (_Q38, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_38=====", Debug)
>                        Notify (\_SB.PCI0.LPCB.ACAD, 0x80)
>                        Sleep (0x64)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
>                        Sleep (0x64)
>                        Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                    }
>
>                    Method (_Q41, 0, NotSerialized)
>                    {
>                        Store ("=====QUERY_41=====", Debug)
>                    }
>                }
>
>                Device (BAT1)
>                {
>                    Name (_HID, EisaId ("PNP0C0A"))
>                    Name (_UID, 0x01)
>                    Name (_PCL, Package (0x01)
>                    {
>                        \_SB
>                    })
>                    Name (FUCC, 0x0F3C)
>                    Name (PBIF, Package (0x0D)
>                    {
>                        0x01, 
>                        0x0F3C, 
>                        0x0F3C, 
>                        0x01, 
>                        0x39D0, 
>                        0x0186, 
>                        0x75, 
>                        0x40, 
>                        0x40, 
>                        "BAT1", 
>                        " ", 
>                        "LiON", 
>                        "FSC "
>                    })
>                    Name (PBST, Package (0x04)
>                    {
>                        0x01, 
>                        0x00, 
>                        0x079F, 
>                        0x39D0
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
>                        {
>                            Store ("==Battery _STA==", Debug)
>                            Store (0x01, Local0)
>                            Store (\_SB.PCI0.LPCB.EC0.BAL0, Local0)
>                            If (LNot (LEqual (Local0, 0x00)))
>                            {
>                                Return (0x1F)
>                            }
>                            Else
>                            {
>                                Return (0x0F)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x1F)
>                        }
>                    }
>
>                    Method (_BIF, 0, NotSerialized)
>                    {
>                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
>                        {
>                            Store ("==Battery _BIF==", Debug)
>                            Store (\_SB.PCI0.LPCB.EC0.BDC0, Local0)
>                            Store (Local0, Index (PBIF, 0x01))
>                            Store (Local0, Local2)
>                            Store (Local2, Index (PBIF, 0x02))
>                            Store (Local2, FUCC)
>                            Store (\_SB.PCI0.LPCB.EC0.BMF0, Local1)
>                            If (LEqual (Local1, 0x01))
>                            {
>                                Store ("Sanyo_LiON", Index (PBIF, 0x09))
>                            }
>                            Else
>                            {
>                                If (LEqual (Local1, 0x02))
>                                {
>                                    Store ("Sony_LiON", Index (PBIF, 0x09))
>                                }
>                                Else
>                                {
>                                    If (LEqual (Local1, 0x04))
>                                    {
>                                        Store ("Panasonic_LiON", Index (PBIF, 0x09))
>                                    }
>                                    Else
>                                    {
>                                        Store ("Samsung_LiON", Index (PBIF, 0x09))
>                                    }
>                                }
>                            }
>                        }
>
>                        Return (PBIF)
>                    }
>
>                    Method (_BST, 0, NotSerialized)
>                    {
>                        If (\_SB.PCI0.LPCB.EC0.ADP)
>                        {
>                            Store (0x02, Local0)
>                        }
>                        Else
>                        {
>                            Store (0x01, Local0)
>                        }
>
>                        Store (DerefOf (Index (PBST, 0x02)), Local2)
>                        If (LAnd (\_SB.PCI0.LPCB.EC0.ECOK, LEqual (ECDY, 0x00)))
>                        {
>                            Store ("==Battery _BST==", Debug)
>                            Store (\_SB.PCI0.LPCB.EC0.GAU0, Local2)
>                            Store (FUCC, Local1)
>                            Store (Local2, Local4)
>                            Multiply (Local2, Local1, Local2)
>                            If (Local2)
>                            {
>                                Divide (Local2, 0x64, Local1, Local2)
>                                If (LNot (LGreater (Local4, 0x63)))
>                                {
>                                    Increment (Local2)
>                                }
>                            }
>
>                            If (\_SB.PCI0.LPCB.EC0.ADP)
>                            {
>                                If (LEqual (Local4, 0x64))
>                                {
>                                    Store (0x00, Local0)
>                                }
>                            }
>                        }
>
>                        Store (Local0, Index (PBST, 0x00))
>                        Store (Local2, Index (PBST, 0x02))
>                        If (LGreater (ECDY, 0x00))
>                        {
>                            Decrement (ECDY)
>                            If (LEqual (ECDY, 0x00))
>                            {
>                                Notify (\_SB.PCI0.LPCB.BAT1, 0x81)
>                                Notify (\_SB.PCI0.LPCB.BAT1, 0x80)
>                            }
>                        }
>
>                        Return (PBST)
>                    }
>                }
>
>                OperationRegion (GPIO, SystemIO, 0x8000, 0x3B)
>                Field (GPIO, WordAcc, Lock, Preserve)
>                {
>                    AccessAs (DWordAcc, 0x00), 
>                    Offset (0x18), 
>                        ,   2, 
>                    LPOL,   1
>                }
>
>                Device (ACAD)
>                {
>                    Name (_HID, "ACPI0003")
>                    Name (_PCL, Package (0x01)
>                    {
>                        \_SB
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Method (_PSR, 0, NotSerialized)
>                    {
>                        Return (\_SB.PCI0.LPCB.EC0.ADP)
>                    }
>                }
>            }
>
>            Device (IDE)
>            {
>                Name (_ADR, 0x00040000)
>                Method (_INI, 0, NotSerialized)
>                {
>                }
>
>                Name (UDMT, Package (0x08)
>                {
>                    0x1E, 
>                    0x2D, 
>                    0x3C, 
>                    0x5A, 
>                    0x78, 
>                    0x78, 
>                    0x78, 
>                    0x14
>                })
>                Name (PIOT, Package (0x05)
>                {
>                    0x78, 
>                    0xB4, 
>                    0xF0, 
>                    0x017F, 
>                    0x0258
>                })
>                Name (PIOC, Package (0x05)
>                {
>                    0x04, 
>                    0x06, 
>                    0x08, 
>                    0x0D, 
>                    0x10
>                })
>                Name (CBCT, Package (0x05)
>                {
>                    0x31, 
>                    0x33, 
>                    0x01, 
>                    0x03, 
>                    0x0A
>                })
>                Name (DACT, Package (0x05)
>                {
>                    0x03, 
>                    0x03, 
>                    0x04, 
>                    0x05, 
>                    0x08
>                })
>                Name (DRCT, Package (0x05)
>                {
>                    0x01, 
>                    0x03, 
>                    0x04, 
>                    0x08, 
>                    0x08
>                })
>                Name (PXLM, Package (0x05)
>                {
>                    0x02, 
>                    0x01, 
>                    0x00, 
>                    0x00, 
>                    0x00
>                })
>                OperationRegion (PCI, PCI_Config, 0x00, 0x60)
>                Field (PCI, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x09), 
>                        ,   4, 
>                    SCHE,   1, 
>                    PCHE,   1, 
>                    Offset (0x0A), 
>                    Offset (0x4B), 
>                    U66E,   1, 
>                    Offset (0x4C), 
>                    Offset (0x53), 
>                    CDFI,   1, 
>                    CDUD,   1, 
>                    Offset (0x54), 
>                    PFTH,   8, 
>                    SFTH,   8, 
>                    PUDC,   8, 
>                    SUDC,   8, 
>                    PAST,   8, 
>                    PCBT,   8, 
>                    PTM0,   8, 
>                    PTM1,   8, 
>                    SAST,   8, 
>                    SCBT,   8, 
>                    STM0,   8, 
>                    STM1,   8
>                }
>
>                Method (GTM, 3, NotSerialized)
>                {
>                    Store (Buffer (0x14) {}, Local0)
>                    CreateDWordField (Local0, 0x00, PIO0)
>                    CreateDWordField (Local0, 0x04, DMA0)
>                    CreateDWordField (Local0, 0x08, PIO1)
>                    CreateDWordField (Local0, 0x0C, DMA1)
>                    CreateDWordField (Local0, 0x10, FLAG)
>                    Store (Zero, PIO0)
>                    Store (Zero, DMA0)
>                    Store (Zero, PIO1)
>                    Store (Zero, DMA1)
>                    Store (Zero, FLAG)
>                    If (Arg0)
>                    {
>                        ShiftRight (And (Arg0, 0x70), 0x04, Local1)
>                        If (LEqual (Local1, Zero))
>                        {
>                            Store (0x08, Local1)
>                        }
>
>                        Add (And (Arg0, 0x0F, Local2), Local1, Local1)
>                        Store (Match (^PIOC, MLE, Local1, MTR, 0x00, 0x00), Local2)
>                        Store (DerefOf (Index (^PIOT, Local2)), PIO0)
>                        If (LNot (LGreater (PIO0, 0xF0)))
>                        {
>                            Or (FLAG, 0x02, FLAG)
>                        }
>                    }
>
>                    If (And (Arg2, 0x08))
>                    {
>                        Store (DerefOf (Index (^UDMT, And (Arg2, 0x07))), DMA0)
>                        Or (FLAG, 0x01, FLAG)
>                    }
>                    Else
>                    {
>                        Store (PIO0, DMA0)
>                    }
>
>                    If (Arg1)
>                    {
>                        ShiftRight (And (Arg1, 0x70), 0x04, Local1)
>                        If (LEqual (Local1, Zero))
>                        {
>                            Store (0x08, Local1)
>                        }
>
>                        Add (And (Arg1, 0x0F, Local2), Local1, Local1)
>                        Store (Match (^PIOC, MLE, Local1, MTR, 0x00, 0x00), Local2)
>                        Store (DerefOf (Index (^PIOT, Local2)), PIO1)
>                        If (LNot (LGreater (PIO1, 0xF0)))
>                        {
>                            Or (FLAG, 0x08, FLAG)
>                        }
>                    }
>
>                    If (And (Arg2, 0x80))
>                    {
>                        Store (DerefOf (Index (^UDMT, ShiftRight (And (Arg2, 0x70), 0x04))), DMA1)
>                        Or (FLAG, 0x04, FLAG)
>                    }
>                    Else
>                    {
>                        Store (PIO1, DMA1)
>                    }
>
>                    Or (FLAG, 0x10, FLAG)
>                    Return (Local0)
>                }
>
>                Method (STM, 3, NotSerialized)
>                {
>                    Store (Buffer (0x06)
>                        {
>                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00
>                        }, Local7)
>                    CreateByteField (Local7, 0x00, TM0)
>                    CreateByteField (Local7, 0x01, TM1)
>                    CreateByteField (Local7, 0x02, UDC)
>                    CreateByteField (Local7, 0x03, AST)
>                    CreateByteField (Local7, 0x04, CBT)
>                    CreateByteField (Local7, 0x05, U66)
>                    CreateDWordField (Arg0, 0x00, PIO0)
>                    CreateDWordField (Arg0, 0x04, DMA0)
>                    CreateDWordField (Arg0, 0x08, PIO1)
>                    CreateDWordField (Arg0, 0x0C, DMA1)
>                    CreateDWordField (Arg0, 0x10, FLAG)
>                    Store (FLAG, Local6)
>                    Store (Ones, Local4)
>                    If (LOr (DMA0, PIO0))
>                    {
>                        If (LAnd (DMA0, LNot (PIO0)))
>                        {
>                            If (And (Local6, 0x01))
>                            {
>                                If (LAnd (LLess (DMA0, 0x1E), LNot (LLess (DMA0, 0x0F))))
>                                {
>                                    Store (0x07, Local0)
>                                }
>                                Else
>                                {
>                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
>                                }
>
>                                Or (Local0, 0x08, UDC)
>                                If (LLess (DMA0, 0x3C))
>                                {
>                                    Store (One, U66)
>                                }
>                            }
>
>                            Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
>                            Store (Local0, Local4)
>                        }
>
>                        If (LAnd (LNot (DMA0), PIO0))
>                        {
>                            Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
>                            Store (Local0, Local4)
>                        }
>
>                        If (LAnd (DMA0, PIO0))
>                        {
>                            If (And (Local6, 0x01))
>                            {
>                                If (LAnd (LLess (DMA0, 0x1E), LNot (LLess (DMA0, 0x0F))))
>                                {
>                                    Store (0x07, Local0)
>                                }
>                                Else
>                                {
>                                    Store (Match (^UDMT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
>                                }
>
>                                Or (Local0, 0x08, UDC)
>                                If (LLess (DMA0, 0x3C))
>                                {
>                                    Store (One, U66)
>                                }
>                            }
>
>                            If (LNot (LLess (PIO0, DMA0)))
>                            {
>                                Store (Match (^PIOT, MGE, PIO0, MTR, 0x00, 0x00), Local0)
>                                Store (Local0, Local4)
>                            }
>                            Else
>                            {
>                                Store (Match (^PIOT, MGE, DMA0, MTR, 0x00, 0x00), Local0)
>                                Store (Local0, Local4)
>                            }
>
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM0)
>                        }
>                    }
>
>                    Store (Ones, Local5)
>                    If (LOr (DMA1, PIO1))
>                    {
>                        If (LAnd (DMA1, LNot (PIO1)))
>                        {
>                            If (And (Local6, 0x04))
>                            {
>                                If (LAnd (LLess (DMA1, 0x1E), LNot (LLess (DMA1, 0x0F))))
>                                {
>                                    Store (0x07, Local0)
>                                }
>                                Else
>                                {
>                                    Store (Match (^UDMT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
>                                }
>
>                                Or (ShiftLeft (Or (Local0, 0x08), 0x04), UDC, UDC)
>                                If (LLess (DMA1, 0x3C))
>                                {
>                                    Store (One, U66)
>                                }
>                            }
>
>                            Store (Match (^PIOT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
>                            Store (Local0, Local5)
>                        }
>
>                        If (LAnd (LNot (DMA1), PIO1))
>                        {
>                            Store (Match (^PIOT, MGE, PIO1, MTR, 0x00, 0x00), Local0)
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
>                            Store (Local0, Local5)
>                        }
>
>                        If (LAnd (DMA1, PIO1))
>                        {
>                            If (And (Local6, 0x04))
>                            {
>                                If (LAnd (LLess (DMA1, 0x1E), LNot (LLess (DMA1, 0x0F))))
>                                {
>                                    Store (0x07, Local0)
>                                }
>                                Else
>                                {
>                                    Store (Match (^UDMT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
>                                }
>
>                                Or (ShiftLeft (Or (Local0, 0x08), 0x04), UDC, UDC)
>                                If (LLess (DMA1, 0x3C))
>                                {
>                                    Store (One, U66)
>                                }
>                            }
>
>                            If (LNot (LLess (PIO1, DMA1)))
>                            {
>                                Store (Match (^PIOT, MGE, PIO1, MTR, 0x00, 0x00), Local0)
>                                Store (Local0, Local5)
>                            }
>                            Else
>                            {
>                                Store (Match (^PIOT, MGE, DMA1, MTR, 0x00, 0x00), Local0)
>                                Store (Local0, Local5)
>                            }
>
>                            Store (DerefOf (Index (^DACT, Local0)), Local2)
>                            Store (DerefOf (Index (^DRCT, Local0)), Local3)
>                            Add (Local3, ShiftLeft (Local2, 0x04), TM1)
>                        }
>                    }
>
>                    If (LEqual (Local4, Ones))
>                    {
>                        If (LEqual (Local5, Ones))
>                        {
>                            Store (Zero, CBT)
>                        }
>                        Else
>                        {
>                            Store (DerefOf (Index (^CBCT, Local5)), CBT)
>                        }
>                    }
>                    Else
>                    {
>                        If (LEqual (Local5, Ones))
>                        {
>                            Store (DerefOf (Index (^CBCT, Local4)), CBT)
>                        }
>                        Else
>                        {
>                            If (LNot (LLess (Local4, Local5)))
>                            {
>                                Store (DerefOf (Index (^CBCT, Local4)), CBT)
>                            }
>                            Else
>                            {
>                                Store (DerefOf (Index (^CBCT, Local5)), CBT)
>                            }
>                        }
>                    }
>
>                    Store (0x02, AST)
>                    Return (Local7)
>                }
>
>                Method (GTF0, 3, NotSerialized)
>                {
>                    Store (Buffer (0x07)
>                        {
>                            0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
>                        }, Local7)
>                    CreateByteField (Local7, 0x01, MODE)
>                    If (And (Arg1, 0x08))
>                    {
>                        And (Arg1, 0x07, Local0)
>                        If (LEqual (Local0, 0x07))
>                        {
>                            Store (0x05, MODE)
>                        }
>                        Else
>                        {
>                            Subtract (0x04, Local0, MODE)
>                        }
>
>                        Or (MODE, 0x40, MODE)
>                    }
>                    Else
>                    {
>                        And (Arg2, 0x0F, Local0)
>                        Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
>                        Store (DerefOf (Index (^PXLM, Local1)), MODE)
>                        Or (MODE, 0x20, MODE)
>                    }
>
>                    Concatenate (Local7, Local7, Local6)
>                    And (Arg2, 0x0F, Local0)
>                    Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
>                    Subtract (0x04, Local1, MODE)
>                    Or (MODE, 0x08, MODE)
>                    Concatenate (Local6, Local7, Local5)
>                    Return (Local5)
>                }
>
>                Method (GTF1, 3, NotSerialized)
>                {
>                    Store (Buffer (0x07)
>                        {
>                            0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
>                        }, Local7)
>                    CreateByteField (Local7, 0x01, MODE)
>                    If (And (Arg1, 0x80))
>                    {
>                        ShiftRight (And (Arg1, 0x70), 0x04, Local0)
>                        If (LEqual (Local0, 0x07))
>                        {
>                            Store (0x05, MODE)
>                        }
>                        Else
>                        {
>                            Subtract (0x04, Local0, MODE)
>                        }
>
>                        Or (MODE, 0x40, MODE)
>                    }
>                    Else
>                    {
>                        And (Arg2, 0x0F, Local0)
>                        Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
>                        Store (DerefOf (Index (^PXLM, Local1)), MODE)
>                        Or (MODE, 0x20, MODE)
>                    }
>
>                    Concatenate (Local7, Local7, Local6)
>                    And (Arg2, 0x0F, Local0)
>                    Store (Match (^DRCT, MEQ, Local0, MTR, 0x00, 0x00), Local1)
>                    Subtract (0x04, Local1, MODE)
>                    Or (MODE, 0x08, MODE)
>                    Concatenate (Local6, Local7, Local5)
>                    Return (Local5)
>                }
>
>                Device (PRIM)
>                {
>                    Name (_ADR, 0x00)
>                    Name (_PSC, 0x00)
>                    Method (_PS0, 0, NotSerialized)
>                    {
>                        Store (0x00, _PSC)
>                    }
>
>                    Method (_PS3, 0, NotSerialized)
>                    {
>                        Store (0x03, _PSC)
>                    }
>
>                    Method (_GTM, 0, NotSerialized)
>                    {
>                        Store ("GTM - Primary Controller", Debug)
>                        Store (^^GTM (^^PTM0, ^^PTM1, ^^PUDC), Local0)
>                        Return (Local0)
>                    }
>
>                    Method (_STM, 3, NotSerialized)
>                    {
>                        Store ("STM - Primary Controller", Debug)
>                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
>                        CreateByteField (Local0, 0x00, TM0)
>                        CreateByteField (Local0, 0x01, TM1)
>                        CreateByteField (Local0, 0x02, UDC)
>                        CreateByteField (Local0, 0x03, AST)
>                        CreateByteField (Local0, 0x04, CBT)
>                        CreateByteField (Local0, 0x05, U66)
>                        Store (TM0, ^^PTM0)
>                        Store (TM1, ^^PTM1)
>                        Store (UDC, ^^PUDC)
>                        Store (AST, ^^PAST)
>                        Store (CBT, ^^PCBT)
>                        If (U66)
>                        {
>                            Store (U66, ^^U66E)
>                        }
>
>                        Store (0x55, ^^PFTH)
>                    }
>
>                    Device (MAST)
>                    {
>                        Name (_ADR, 0x00)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Store ("GTF - Primary Master", Debug)
>                            Store (^^^GTF0 (^^^PCHE, ^^^PUDC, ^^^PTM0), Local0)
>                            Return (Local0)
>                        }
>                    }
>
>                    Device (SLAV)
>                    {
>                        Name (_ADR, 0x01)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Store ("GTF - Primary Slave", Debug)
>                            Store (^^^GTF1 (^^^PCHE, ^^^PUDC, ^^^PTM1), Local0)
>                            Return (Local0)
>                        }
>                    }
>                }
>
>                Device (SECN)
>                {
>                    Name (_ADR, 0x01)
>                    Method (_GTM, 0, NotSerialized)
>                    {
>                        Store ("GTM - Secondary Controller", Debug)
>                        Store (^^GTM (^^STM0, ^^STM1, ^^SUDC), Local0)
>                        Return (Local0)
>                    }
>
>                    Method (_STM, 3, NotSerialized)
>                    {
>                        Store ("STM - Secondary Controller", Debug)
>                        Store (^^STM (Arg0, Arg1, Arg2), Local0)
>                        CreateByteField (Local0, 0x00, TM0)
>                        CreateByteField (Local0, 0x01, TM1)
>                        CreateByteField (Local0, 0x02, UDC)
>                        CreateByteField (Local0, 0x03, AST)
>                        CreateByteField (Local0, 0x04, CBT)
>                        CreateByteField (Local0, 0x05, U66)
>                        Store (TM0, ^^STM0)
>                        Store (TM1, ^^STM1)
>                        Store (UDC, ^^SUDC)
>                        Store (AST, ^^SAST)
>                        Store (CBT, ^^SCBT)
>                        If (U66)
>                        {
>                            Store (U66, ^^U66E)
>                        }
>
>                        Store (0x55, ^^SFTH)
>                    }
>
>                    Device (MAST)
>                    {
>                        Name (_ADR, 0x00)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Store ("GTF - Secondary Master", Debug)
>                            Store (^^^GTF0 (^^^SCHE, ^^^SUDC, ^^^STM0), Local0)
>                            Return (Local0)
>                        }
>                    }
>
>                    Device (SLAV)
>                    {
>                        Name (_ADR, 0x01)
>                        Method (_GTF, 0, NotSerialized)
>                        {
>                            Store ("GTF - Secondary Slave", Debug)
>                            Store (^^^GTF1 (^^^SCHE, ^^^SUDC, ^^^STM1), Local0)
>                            Return (Local0)
>                        }
>                    }
>                }
>            }
>
>            Device (AGP)
>            {
>                Name (_ADR, 0x00010000)
>                Name (_PSC, 0x00)
>                Name (_PRT, Package (0x01)
>                {
>                    Package (0x04)
>                    {
>                        0x0005FFFF, 
>                        0x00, 
>                        \_SB.PCI0.LPCB.LNKC, 
>                        0x00
>                    }
>                })
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x00, _PSC)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x02, _PSC)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x03, _PSC)
>                }
>            }
>
>            Device (USB0)
>            {
>                Name (_ADR, 0x00020000)
>            }
>
>            Device (USB1)
>            {
>                Name (_ADR, 0x000F0000)
>            }
>
>            Device (AUDO)
>            {
>                Name (_ADR, 0x00080000)
>            }
>
>            Device (MODM)
>            {
>                Name (_ADR, 0x00030000)
>                Name (_PSC, 0x00)
>                Name (_PRW, Package (0x02)
>                {
>                    0x09, 
>                    0x04
>                })
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x00, _PSC)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x02, _PSC)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x03, _PSC)
>                }
>            }
>
>            Device (ENET)
>            {
>                Name (_ADR, 0x00090000)
>                Name (_PSC, 0x00)
>                Name (_PRW, Package (0x02)
>                {
>                    0x0A, 
>                    0x04
>                })
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x00, _PSC)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x02, _PSC)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x03, _PSC)
>                }
>            }
>
>            Device (V194)
>            {
>                Name (_ADR, 0x000A0000)
>            }
>
>            Device (CDB0)
>            {
>                Name (_ADR, 0x000B0000)
>                Name (_PSC, 0x00)
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x00, _PSC)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x02, _PSC)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x03, _PSC)
>                }
>            }
>
>            Device (CDB1)
>            {
>                Name (_ADR, 0x000B0001)
>                Name (_PSC, 0x00)
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x00, _PSC)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x02, _PSC)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x03, _PSC)
>                }
>            }
>
>            Device (SLT1)
>            {
>                Name (_ADR, 0x00100000)
>            }
>
>            Device (SLT2)
>            {
>                Name (_ADR, 0x00140000)
>            }
>        }
>    }
>
>    Scope (_GPE)
>    {
>        Method (_L09, 0, NotSerialized)
>        {
>            Notify (\_SB.PCI0.MODM, 0x02)
>        }
>
>        Method (_L0A, 0, NotSerialized)
>        {
>            Notify (\_SB.PCI0.ENET, 0x02)
>        }
>
>        Method (_L02, 0, NotSerialized)
>        {
>            Store ("======LID=====", Debug)
>            Notify (\_SB.LID, 0x80)
>        }
>    }
>
>    Scope (_TZ)
>    {
>        Name (TBSE, 0x0AAC)
>        Name (DTMP, 0x0CA0)
>        Name (DCRT, 0x12AE)
>        Name (DAC0, 0x0D68)
>        Name (DPSV, 0x127C)
>        ThermalZone (THRM)
>        {
>            Method (_TMP, 0, NotSerialized)
>            {
>                If (\_SB.PCI0.LPCB.EC0.ECOK)
>                {
>                    If (\_SB.PCI0.LPCB.EC0.CTMP)
>                    {
>                        Return (Add (Multiply (\_SB.PCI0.LPCB.EC0.CTMP, 0x0A), TBSE))
>                    }
>                    Else
>                    {
>                        Return (DTMP)
>                    }
>                }
>                Else
>                {
>                    Return (DTMP)
>                }
>            }
>
>            Method (_AC0, 0, NotSerialized)
>            {
>                Return (DAC0)
>            }
>
>            Method (_PSV, 0, NotSerialized)
>            {
>                Return (DPSV)
>            }
>
>            Method (_CRT, 0, NotSerialized)
>            {
>                Return (DCRT)
>            }
>
>            Name (_PSL, Package (0x01)
>            {
>                \_PR.CPU0
>            })
>            Name (_TC1, 0x02)
>            Name (_TC2, 0x05)
>            Name (_TSP, 0x96)
>        }
>    }
>}
>

Actions: View

Attachments on bug 1678: 1145 | 1146 | 1440 | 1585 | 1597

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.