/*
 * Intel ACPI Component Architecture
 * AML Disassembler version 20051216
 *
 * Disassembly of s30.dsdt, Thu Oct 12 23:54:20 2006
 *
 * Original Table Header:
 *     Signature        "DSDT"
 *     Length           0x000037DF (14303)
 *     Revision         0x01
 *     OEM ID           "PTL"
 *     OEM Table ID     "TP-18"
 *     OEM Revision     0x00000145 (325)
 *     Creator ID       "MSFT"
 *     Creator Revision 0x0100000B (16777227)
 */
DefinitionBlock ("DSDT.aml", "DSDT", 1, "PTL", "TP-18", 0x00000145)
{
    Name (_S0, Package (0x02)
    {
        0x05, 
        0x05
    })
    Name (_S1, Package (0x02)
    {
        0x04, 
        0x04
    })
    Name (_S3, Package (0x02)
    {
        0x01, 
        0x01
    })
    Name (_S4, Package (0x02)
    {
        0x00, 
        0x00
    })
    Name (_S5, Package (0x02)
    {
        0x00, 
        0x00
    })
    Scope (_PR)
    {
        Processor (CPU0, 0x00, 0x00008010, 0x06) {}
    }

    Scope (\_TZ)
    {
        Name (TPL, 0x0CDC)
        Name (TACT, 0x0D04)
        Name (TAC1, 0x0D18)
        Name (TPAS, 0x0E61)
        Name (TSUS, 0x0E76)
        Name (TPC, 0x0E94)
        Name (TPTM, 0x0CA0)
        Name (TBSE, 0x0AB6)
        Name (TCUN, 0x00)
        Name (FAST, 0x00)
        Name (TZMP, 0x00)
        Name (TVAR, Buffer (0x05)
        {
            0x00, 0x20, 0x1F, 0x0C, 0x1F
        })
        CreateByteField (TVAR, 0x00, PLCY)
        CreateWordField (TVAR, 0x01, CTOS)
        CreateWordField (TVAR, 0x03, CTHY)
        PowerResource (PFAN, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ( _STA)", Debug)
                Return (FAST)
            }

            Method (_ON, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ (_ON)", Debug)
                If (LNot (LLess (TCUN, 0x0A)))
                {
                    Store (0x89, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                    Store (0x86, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                }

                Store (0x01, FAST)
                Return (FAST)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ (_OFF)", Debug)
                If (LNot (LLess (TCUN, 0x0A)))
                {
                    Store (0x87, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                }

                Store (0x00, FAST)
                Return (FAST)
            }
        }

        PowerResource (PFA1, 0x00, 0x0000)
        {
            Method (_STA, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ( _STA)", Debug)
                Return (FAST)
            }

            Method (_ON, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ (_ON)", Debug)
                If (LNot (LLess (TCUN, 0x0A)))
                {
                    Store (0x88, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                    Store (0x86, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                }

                Store (0x01, FAST)
                Return (FAST)
            }

            Method (_OFF, 0, NotSerialized)
            {
                Store ("------------------------------- _TZ (_OFF)", Debug)
                If (LNot (LLess (TCUN, 0x0A)))
                {
                    Store (0x87, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                }

                Store (0x00, FAST)
                Return (FAST)
            }
        }

        Device (FAN)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x01)
            Name (_PR0, Package (0x01)
            {
                PFAN
            })
        }

        Device (FA1)
        {
            Name (_HID, EisaId ("PNP0C0B"))
            Name (_UID, 0x02)
            Name (_PR0, Package (0x01)
            {
                PFA1
            })
        }

        ThermalZone (THRM)
        {
            Method (_AC0, 0, NotSerialized)
            {
                Store ("------------------------------- _AC0", Debug)
                Return (TACT)
            }

            Name (_AL0, Package (0x01)
            {
                FAN
            })
            Method (_AC1, 0, NotSerialized)
            {
                Store ("------------------------------- _AC1", Debug)
                Return (TAC1)
            }

            Name (_AL1, Package (0x01)
            {
                FA1
            })
            Name (_TSP, 0x32)
            Method (_CRT, 0, NotSerialized)
            {
                Return (TPC)
            }

            Method (_TMP, 0, NotSerialized)
            {
                If (LEqual (TCUN, 0x0A))
                {
                    Increment (TCUN)
                    Store (0x00, FAST)
                    Store (0x87, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                    Return (TPTM)
                }
                Else
                {
                    If (LNot (LLess (TCUN, 0x0B)))
                    {
                        Store (\_SB.PCI0.ISA.SMI (0x96, 0x00, 0x00, 0x00, 0x00), Local1)
                        Store ("Current Temperature is ----------- ", Debug)
                        If (LEqual (Local1, 0x00))
                        {
                            Store (0x32, Local1)
                            Store ("0,  So fixed to :", Debug)
                        }

                        Store (Local1, Debug)
                        Multiply (Local1, 0x0A, Local1)
                        Add (Local1, 0x0AAC, Local1)
                        Return (Local1)
                    }
                    Else
                    {
                        Increment (TCUN)
                        Return (TPTM)
                    }
                }
            }

            Method (_PSV, 0, NotSerialized)
            {
                Return (TPAS)
            }

            Name (_PSL, Package (0x01)
            {
                \_PR.CPU0
            })
            Name (_TC1, 0x02)
            Name (_TC2, 0x03)
            Method (_SCP, 1, NotSerialized)
            {
                Store ("------------------------------- _SCP", Debug)
                If (Arg0)
                {
                    Store (One, PLCY)
                }
                Else
                {
                    Store (Zero, PLCY)
                }

                Notify (\_TZ.THRM, 0x81)
            }
        }
    }

    Method (_PTS, 1, NotSerialized)
    {
        If (LEqual (Arg0, 0x01))
        {
            Store (0xA4, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
            Store (Zero, \_TZ.TCUN)
            Store (Zero, \_SB.BAT1.BCUT)
            Store (Zero, \_SB.BAT1.ACCH)
        }

        \_SB.PCI0.CRD0.TIEN (One)
        If (LEqual (Arg0, 0x03))
        {
            Store (0xA6, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
            Store (0x85, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
            Store (Zero, \_SB.PCI0.PWR.Z000)
            Store (Zero, \_TZ.TCUN)
            Store (Zero, \_SB.BAT1.BCUT)
            Store (Zero, \_SB.BAT1.ACCH)
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (0x01, \_SB.PCI0.PWR.LPOL)
            Store (Zero, \_TZ.TCUN)
            Store (Zero, \_SB.BAT1.BCUT)
            Store (Zero, \_SB.BAT1.ACCH)
        }

        If (LNot (LLess (Arg0, 0x02)))
        {
            Store (0x01, \_SB.PCI0.CRST)
        }
        Else
        {
            Store (0x00, \_SB.PCI0.CRST)
        }

        If (LEqual (Arg0, 0x05))
        {
            Store (0x8A, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
        }

        Return (0x00)
    }

    Method (_WAK, 1, NotSerialized)
    {
        Store ("==================================== _WAK", Debug)
        Store (0x01, \_SB.BAT1.BTCH)
        Store (0x00, \_SB.BAT1.BCMP)
        Store (One, \_SB.PCI0.PWR.Z000)
        If (LEqual (Arg0, 0x01))
        {
            Store (0xA5, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
            Store (0xA3, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
        }

        If (LEqual (Arg0, 0x03))
        {
            Store (0x01, \_SB.PCI0.PO22)
            Store (0x82, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
            \_SB.PCI0.ISA.EC0.CHAG ()
        }

        If (LEqual (Arg0, 0x04))
        {
            Store (Zero, \_SB.PCI0.PWR.Z001)
            Store (0xA3, \_SB.PCI0.ISA.BCMD)
            Store (0x00, \_SB.PCI0.ISA.SMIC)
        }
    }

    Scope (_SI)
    {
        Method (_SST, 1, NotSerialized)
        {
            If (LEqual (Arg0, 0x03))
            {
                Store ("===================================================", Debug)
                Store ("================== _SI SLEEP ======================", Debug)
                Store ("===================================================", Debug)
                Store (0xA3, \_SB.PCI0.ISA.BCMD)
                Store (0x00, \_SB.PCI0.ISA.SMIC)
            }

            If (LEqual (Arg0, 0x04))
            {
                Store ("===================================================", Debug)
                Store ("================== _SI S4    ======================", Debug)
                Store ("===================================================", Debug)
                Store (0xA2, \_SB.PCI0.ISA.BCMD)
                Store (0x00, \_SB.PCI0.ISA.SMIC)
            }
        }
    }

    Scope (_GPE)
    {
        Method (_L0B, 0, NotSerialized)
        {
            Not (\_SB.PCI0.PWR.LPOL, \_SB.PCI0.PWR.LPOL)
            Notify (\_SB.LID, 0x80)
        }

        Method (_L0C, 0, NotSerialized)
        {
            Store (And (\_SB.PCI0.CRD0.TIA5, 0xFE), \_SB.PCI0.CRD0.TIA5)
            Store (Or (\_SB.PCI0.CRD0.TIA5, 0x80), \_SB.PCI0.CRD0.TIA5)
            If (LEqual (And (\_SB.PCI0.CRD0.TIA4, 0x0F), Zero))
            {
                Notify (\_SB.PCI0.CRD0, 0x00)
            }
            Else
            {
                Store (And (\_SB.PCI0.CRD0.TIA4, 0xF0), \_SB.PCI0.CRD0.TIA4)
                Notify (\_SB.PCI0.CRD0, 0x00)
                Notify (\_SB.PCI0.CRD0, 0x02)
            }

            Notify (\_SB.PCI0.LAN, 0x00)
            Notify (\_SB.SBTN, 0x02)
        }

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

    Scope (_SB)
    {
        Name (MYOS, 0x00)
        Name (HCT, 0x00)
        Method (_INI, 0, NotSerialized)
        {
            If (LEqual (SCMP (\_OS, "Microsoft Windows NT"), Zero))
            {
                Store (Ones, MYOS)
            }
            Else
            {
                If (LEqual (SCMP (\_OS, "Microsoft Windows"), Zero))
                {
                    Store (0x00, MYOS)
                }
                Else
                {
                    If (LEqual (SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero))
                    {
                        Store (0x00, MYOS)
                    }
                    Else
                    {
                        Store (0x00, MYOS)
                        Store (0x01, HCT)
                    }
                }
            }
        }

        Method (MIN, 2, NotSerialized)
        {
            If (LLess (Arg0, Arg1))
            {
                Return (Arg0)
            }
            Else
            {
                Return (Arg1)
            }
        }

        Method (SLEN, 1, NotSerialized)
        {
            Return (SizeOf (Arg0))
        }

        Method (S2BF, 1, Serialized)
        {
            Add (SLEN (Arg0), One, Local0)
            Name (BUFF, Buffer (Local0) {})
            Store (Arg0, BUFF)
            Return (BUFF)
        }

        Method (SCMP, 2, NotSerialized)
        {
            Store (S2BF (Arg0), Local0)
            Store (S2BF (Arg1), Local1)
            Store (Zero, Local4)
            Store (SLEN (Arg0), Local5)
            Store (SLEN (Arg1), Local6)
            Store (MIN (Local5, Local6), Local7)
            While (LLess (Local4, Local7))
            {
                Store (DerefOf (Index (Local0, Local4)), Local2)
                Store (DerefOf (Index (Local1, Local4)), Local3)
                If (LGreater (Local2, Local3))
                {
                    Return (One)
                }
                Else
                {
                    If (LLess (Local2, Local3))
                    {
                        Return (Ones)
                    }

                    Increment (Local4)
                }
            }

            If (LLess (Local4, Local5))
            {
                Return (One)
            }
            Else
            {
                If (LLess (Local4, Local6))
                {
                    Return (Ones)
                }
                Else
                {
                    Return (Zero)
                }
            }
        }

        Name (OSTY, 0x00)
        Mutex (PSMX, 0x00)
        Device (PCI0)
        {
            Name (_HID, EisaId ("PNP0A03"))
            Name (_ADR, 0x00)
            Method (_BBN, 0, NotSerialized)
            {
                Return (0x00)
            }

            OperationRegion (REG0, PCI_Config, 0x40, 0xC0)
            Field (REG0, DWordAcc, NoLock, Preserve)
            {
                Offset (0x19), 
                PAM0,   8, 
                PAM1,   8, 
                PAM2,   8, 
                PAM3,   8, 
                PAM4,   8, 
                PAM5,   8, 
                PAM6,   8, 
                DRB0,   8, 
                DRB1,   8, 
                DRB2,   8, 
                DRB3,   8, 
                Offset (0x28), 
                    ,   6, 
                HEN,    2, 
                Offset (0x32), 
                    ,   3, 
                G_EN,   1, 
                Offset (0x33), 
                T_EN,   1, 
                T_SZ,   2, 
                    ,   4, 
                H_EN,   1, 
                Offset (0x3A), 
                CRST,   1, 
                    ,   5, 
                PO22,   1, 
                Offset (0x90), 
                BSP0,   8, 
                BSP1,   8, 
                BSP2,   8, 
                BSP3,   8, 
                BSP4,   8
            }

            Name (CRES, ResourceTemplate ()
            {
                WordBusNumber (ResourceProducer, MinNotFixed, MaxNotFixed, PosDecode,
                    0x0000,             // Address Space Granularity
                    0x0000,             // Address Range Minimum
                    0x00FF,             // Address Range Maximum
                    0x0000,             // Address Translation Offset
                    0x0100,             // Address Length
                    0x00,,)
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Address Space Granularity
                    0x0000,             // Address Range Minimum
                    0x0CF7,             // Address Range Maximum
                    0x0000,             // Address Translation Offset
                    0x0CF8,             // Address Length
                    ,,, TypeStatic)
                IO (Decode16,
                    0x0CF8,             // Address Range Minimum
                    0x0CF8,             // Address Range Maximum
                    0x01,               // Address Alignment
                    0x08,               // Address Length
                    )
                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
                    0x0000,             // Address Space Granularity
                    0x0D00,             // Address Range Minimum
                    0xFFFF,             // Address Range Maximum
                    0x0000,             // Address Translation Offset
                    0xF300,             // Address Length
                    ,,, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Address Space Granularity
                    0x000A0000,         // Address Range Minimum
                    0x000BFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00020000,         // Address Length
                    ,,, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Address Space Granularity
                    0x000CC000,         // Address Range Minimum
                    0x000DFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00014000,         // Address Length
                    ,,, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly,
                    0x00000000,         // Address Space Granularity
                    0xFFF80000,         // Address Range Minimum
                    0xFFFFFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00080000,         // Address Length
                    ,,, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Address Space Granularity
                    0x02000000,         // Address Range Minimum
                    0x100FFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00000000,         // Address Length
                    0x00,,, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Address Space Granularity
                    0x10100000,         // Address Range Minimum
                    0x0FFFFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00000000,         // Address Length
                    0x00,,, AddressRangeMemory, TypeStatic)
                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
                    0x00000000,         // Address Space Granularity
                    0x10000000,         // Address Range Minimum
                    0xFFDFFFFF,         // Address Range Maximum
                    0x00000000,         // Address Translation Offset
                    0x00000000,         // Address Length
                    0x00,,, AddressRangeMemory, TypeStatic)
            })
            Method (_CRS, 0, Serialized)
            {
                CreateDWordField (CRES, 0x9D, EM1R)
                If (LEqual (EM1R, 0x00))
                {
                    CreateDWordField (CRES, 0x91, EM1L)
                    CreateDWordField (CRES, 0x95, EM1H)
                    CreateDWordField (CRES, 0xAC, EM2L)
                    CreateDWordField (CRES, 0xB0, EM2H)
                    CreateDWordField (CRES, 0xB8, EM2R)
                    CreateDWordField (CRES, 0xC7, EM3L)
                    CreateDWordField (CRES, 0xCB, EM3H)
                    CreateDWordField (CRES, 0xD3, EM3R)
                    ShiftLeft (DRB3, 0x17, Local0)
                    If (LGreater (G_EN, 0x00))
                    {
                        If (LGreater (H_EN, 0x00))
                        {
                            Subtract (EM1H, 0x00060000, EM1H)
                        }

                        If (LGreater (T_EN, 0x00))
                        {
                            ShiftLeft (0x00020000, T_SZ, Local1)
                            Subtract (Local0, Local1, Local0)
                        }
                    }

                    Store (Local0, EM1L)
                    Subtract (EM1H, Local0, EM1R)
                    Increment (EM1R)
                    Add (EM2H, Local0, EM2H)
                    Subtract (EM2H, EM2L, EM2R)
                    Increment (EM2R)
                    Add (EM3L, Local0, EM3L)
                    Subtract (EM3H, EM3L, EM3R)
                    Increment (EM3R)
                }

                Return (CRES)
            }

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

            Method (_INI, 0, NotSerialized)
            {
                BreakPoint
                Store ("=============================================", Debug)
                Store ("==================================== PCI _INI", Debug)
                Store ("=============================================", Debug)
                Store (0x00, \_SB.BAT1.ACCH)
                If (LEqual (\_SB.SCMP (\_OS, "Microsoft WindowsME: Millennium Edition"), Zero))
                {
                    Store (0x01, \_SB.BAT1.BCMP)
                    Store (0x01, \_SB.OSTY)
                }
                Else
                {
                    If (LEqual (\_SB.SCMP (\_OS, "Microsoft Windows"), Zero))
                    {
                        Store (0x00, \_SB.BAT1.BCMP)
                        Store (0x00, \_SB.OSTY)
                    }
                    Else
                    {
                        If (LEqual (\_SB.SCMP (\_OS, "Microsoft Windows NT"), Zero))
                        {
                            Store (0x08, \_SB.BAT1.BCMP)
                            Store (0x02, \_SB.OSTY)
                        }
                    }
                }
            }

            Name (_PRT, Package (0x06)
            {
                Package (0x04)
                {
                    0xFFFF, 
                    0x01, 
                    \_SB.PCI0.ISA.LNKB, 
                    0x00
                }, 

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

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

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

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

                Package (0x04)
                {
                    0x000CFFFF, 
                    0x00, 
                    \_SB.PCI0.ISA.LNKD, 
                    0x00
                }
            })
            Device (USB0)
            {
                Name (_ADR, 0x00070002)
                OperationRegion (SB72, PCI_Config, 0x00, 0xC2)
                Field (SB72, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x3C), 
                    UIRR,   4, 
                    Offset (0xC0), 
                    LUSB,   16
                }

                Method (_INI, 0, NotSerialized)
                {
                    Store (0x1000, \_SB.PCI0.USB0.LUSB)
                }

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

            Device (ISA)
            {
                Name (_ADR, 0x00070000)
                OperationRegion (PIRX, PCI_Config, 0x60, 0x04)
                Field (PIRX, ByteAcc, NoLock, Preserve)
                {
                    PIRA,   8, 
                    PIRB,   8, 
                    PIRC,   8, 
                    PIRD,   8
                }

                Device (LNKA)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x01)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LNKA_DIS", Debug)
                        Or (PIRA, 0x80, PIRA)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Store ("LNKA_CRS", Debug)
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        If (LNot (And (PIRA, 0x80)))
                        {
                            And (PIRA, 0x0F, Local0)
                            ShiftLeft (0x01, Local0, IRQ0)
                        }

                        Store (RSRC, Debug)
                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        Store ("LNKA_SRS", Debug)
                        Store (Arg0, Debug)
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRA, 0x70), PIRA)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        Store ("LNKA_STA", Debug)
                        If (And (PIRA, 0x80))
                        {
                            Store (0x09, Debug)
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKB)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x02)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Store ("LNKB_DIS", Debug)
                        Or (PIRB, 0x80, PIRB)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        If (LNot (And (PIRB, 0x80)))
                        {
                            And (PIRB, 0x0F, Local0)
                            ShiftLeft (0x01, Local0, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRB, 0x70), PIRB)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRB, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKC)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x03)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRC, 0x80, PIRC)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        If (LNot (And (PIRC, 0x80)))
                        {
                            And (PIRC, 0x0F, Local0)
                            ShiftLeft (0x01, Local0, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRC, 0x70), PIRC)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRC, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (LNKD)
                {
                    Name (_HID, EisaId ("PNP0C0F"))
                    Name (_UID, 0x04)
                    Name (_PRS, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {3,4,5,6,7,10,11,14,15}
                    })
                    Name (RSRC, ResourceTemplate ()
                    {
                        IRQ (Level, ActiveLow, Shared)
                            {}
                    })
                    Method (_DIS, 0, NotSerialized)
                    {
                        Or (PIRD, 0x80, PIRD)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        CreateWordField (RSRC, 0x01, IRQ0)
                        Store (Zero, IRQ0)
                        If (LNot (And (PIRD, 0x80)))
                        {
                            And (PIRD, 0x0F, Local0)
                            ShiftLeft (0x01, Local0, IRQ0)
                        }

                        Return (RSRC)
                    }

                    Method (_SRS, 1, NotSerialized)
                    {
                        CreateWordField (Arg0, 0x01, IRQ0)
                        FindSetRightBit (IRQ0, Local0)
                        Decrement (Local0)
                        Or (Local0, And (PIRD, 0x70), PIRD)
                    }

                    Method (_STA, 0, NotSerialized)
                    {
                        If (And (PIRD, 0x80))
                        {
                            Return (0x09)
                        }
                        Else
                        {
                            Return (0x0B)
                        }
                    }
                }

                Device (DMAA)
                {
                    Name (_HID, EisaId ("PNP0200"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0000,             // Address Range Minimum
                            0x0000,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x10,               // Address Length
                            )
                        IO (Decode16,
                            0x0081,             // Address Range Minimum
                            0x0081,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x0F,               // Address Length
                            )
                        IO (Decode16,
                            0x00C0,             // Address Range Minimum
                            0x00C0,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x20,               // Address Length
                            )
                        DMA (Compatibility, NotBusMaster, Transfer16)
                            {4}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (RTC)
                {
                    Name (_HID, EisaId ("PNP0B00"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0070,             // Address Range Minimum
                            0x0070,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x02,               // Address Length
                            )
                        IRQNoFlags ()
                            {8}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

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

                Device (FPU)
                {
                    Name (_HID, EisaId ("PNP0C04"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x00F0,             // Address Range Minimum
                            0x00F0,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x0F,               // Address Length
                            )
                        IRQNoFlags ()
                            {13}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (TMR)
                {
                    Name (_HID, EisaId ("PNP0100"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0040,             // Address Range Minimum
                            0x0040,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x04,               // Address Length
                            )
                        IRQNoFlags ()
                            {0}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

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

                Device (MEM1)
                {
                    Name (_HID, EisaId ("PNP0C01"))
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }

                    Method (_CRS, 0, NotSerialized)
                    {
                        Name (SMEM, ResourceTemplate ()
                        {
                            Memory32Fixed (ReadWrite,
                                0x00000000,         // Address Base
                                0x0009FC00,         // Address Length
                                )
                            Memory32Fixed (ReadOnly,
                                0x000E0000,         // Address Base
                                0x00020000,         // Address Length
                                )
                            Memory32Fixed (ReadWrite,
                                0x00100000,         // Address Base
                                0x00F00000,         // Address Length
                                )
                            Memory32Fixed (ReadWrite,
                                0x000DC000,         // Address Base
                                0x00004000,         // Address Length
                                )
                            Memory32Fixed (ReadOnly,
                                0xFFF80000,         // Address Base
                                0x00080000,         // Address Length
                                )
                        })
                        CreateDWordField (SMEM, 0x20, MEMC)
                        Return (SMEM)
                    }
                }

                Device (MEM2)
                {
                    Name (_HID, EisaId ("PNP0C02"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x04D0,             // Address Range Minimum
                            0x04D0,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x02,               // Address Length
                            )
                        IO (Decode16,
                            0x8000,             // Address Range Minimum
                            0x8000,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x40,               // Address Length
                            )
                        IO (Decode16,
                            0x2180,             // Address Range Minimum
                            0x2180,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x10,               // Address Length
                            )
                        IO (Decode16,
                            0x0398,             // Address Range Minimum
                            0x0398,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x02,               // Address Length
                            )
                    })
                }

                Device (KBC)
                {
                    Name (_HID, EisaId ("PNP0303"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0060,             // Address Range Minimum
                            0x0060,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x01,               // Address Length
                            )
                        IO (Decode16,
                            0x0064,             // Address Range Minimum
                            0x0064,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x01,               // Address Length
                            )
                        IRQNoFlags ()
                            {1}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Return (0x0F)
                    }
                }

                Device (MOUE)
                {
                    Name (_HID, EisaId ("IBM3780"))
                    Name (_CID, 0x130FD041)
                    Name (_CRS, ResourceTemplate ()
                    {
                        IRQNoFlags ()
                            {12}
                    })
                    Method (_STA, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.ISA.SMI (0x93, 0x00, 0x00, 0x00, 0x00), Local0)
                        If (Local0)
                        {
                            Return (0x0F)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }
                }

                OperationRegion (SMI0, SystemIO, 0x0000FE00, 0x00000002)
                Field (SMI0, AnyAcc, NoLock, Preserve)
                {
                    SMIC,   8
                }

                OperationRegion (SMI1, SystemMemory, 0x0FFF3C49, 0x00000100)
                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    BCMD,   8, 
                    DID,    32, 
                    INFO,   2000
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    AccessAs (ByteAcc, 0x00), 
                    Offset (0x05), 
                    INF,    8
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x05), 
                    INF2,   1024
                }

                Field (SMI1, AnyAcc, NoLock, Preserve)
                {
                    Offset (0x05), 
                    PAR0,   32, 
                    PAR1,   32, 
                    PAR2,   32, 
                    PAR3,   32
                }

                OperationRegion (EBIO, SystemMemory, 0x04E0, 0x10)
                Field (EBIO, AnyAcc, NoLock, Preserve)
                {
                    EB1,    50, 
                    EB2,    50, 
                    EB3,    22
                }

                Mutex (MSMI, 0x07)
                Method (SMI, 5, NotSerialized)
                {
                    Acquire (MSMI, 0xFFFF)
                    Store (Arg0, BCMD)
                    Store (Arg1, PAR0)
                    Store (Arg2, PAR1)
                    Store (Arg3, PAR2)
                    Store (Arg4, PAR3)
                    Store (0x00, SMIC)
                    Store (PAR0, Local0)
                    Release (MSMI)
                    Return (Local0)
                }

                Mutex (PSMX, 0x00)
                Method (PCRS, 1, Serialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x00, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Return (INFO)
                    Release (PSMX)
                }

                Method (PSRS, 2, NotSerialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x01, BCMD)
                    Store (Arg0, DID)
                    Store (Arg1, INFO)
                    Store (Zero, SMIC)
                    Release (PSMX)
                }

                Method (PPRS, 1, Serialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x02, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Return (INFO)
                    Release (PSMX)
                }

                Method (PDIS, 1, NotSerialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x03, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Release (PSMX)
                }

                Method (PSTA, 1, Serialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (0x04, BCMD)
                    Store (Arg0, DID)
                    Store (Zero, SMIC)
                    Return (INF)
                    Release (PSMX)
                }

                Method (PHS, 1, Serialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (Arg0, BCMD)
                    Store (Zero, SMIC)
                    Store (Zero, BCMD)
                    Return (INF)
                    Release (PSMX)
                }

                Method (PHS2, 2, Serialized)
                {
                    Acquire (PSMX, 0xFFFF)
                    Store (Arg0, BCMD)
                    Store (Arg1, INF)
                    Store (Zero, DID)
                    Store (Zero, SMIC)
                    Store (Zero, BCMD)
                    Store (Zero, DID)
                    Store (INF2, Local0)
                    Release (PSMX)
                    Return (Local0)
                }

                Scope (_SB)
                {
                    Name (OKEC, 0x00)
                    Name (Q20F, 0x01)
                }

                Device (EC0)
                {
                    Name (_HID, EisaId ("PNP0C09"))
                    Name (_CRS, ResourceTemplate ()
                    {
                        IO (Decode16,
                            0x0062,             // Address Range Minimum
                            0x0062,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x01,               // Address Length
                            )
                        IO (Decode16,
                            0x0066,             // Address Range Minimum
                            0x0066,             // Address Range Maximum
                            0x01,               // Address Alignment
                            0x01,               // Address Length
                            )
                    })
                    Name (_GPE, 0x19)
                    Method (_REG, 2, NotSerialized)
                    {
                        If (LEqual (Arg0, 0x03))
                        {
                            Store (Arg1, \_SB.OKEC)
                        }
                    }

                    Name (VDHK, 0x00)
                    Method (GHKS, 0, NotSerialized)
                    {
                        Store (GHKY (), VDHK)
                    }

                    Method (GHKY, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.ISA.SMI (0x90, 0x00, 0x00, 0x00, 0x00), Local0)
                        Return (And (ShiftRight (Local0, 0x04), 0x01))
                    }

                    Device (HKEY)
                    {
                        Name (_HID, EisaId ("IBM0068"))
                        Method (_STA, 0, NotSerialized)
                        {
                            If (VDHK)
                            {
                                Return (0x0F)
                            }
                            Else
                            {
                                Return (0x00)
                            }
                        }

                        Name (DHKC, 0x00)
                        Name (DHKB, 0x01)
                        Mutex (XDHK, 0x07)
                        Name (DHKH, 0x00)
                        Name (DHKW, 0x00)
                        Name (DHKS, 0x00)
                        Name (DHKD, 0x00)
                        Method (MHKS, 0, NotSerialized)
                        {
                            Notify (\_SB.SBTN, 0x80)
                        }

                        Method (MHKC, 1, NotSerialized)
                        {
                            Store (Arg0, DHKC)
                        }

                        Method (MHKP, 0, NotSerialized)
                        {
                            Acquire (XDHK, 0xFFFF)
                            If (DHKW)
                            {
                                Store (DHKW, Local1)
                                Store (Zero, DHKW)
                            }
                            Else
                            {
                                If (DHKD)
                                {
                                    Store (DHKD, Local1)
                                    Store (Zero, DHKD)
                                }
                                Else
                                {
                                    If (DHKS)
                                    {
                                        Store (DHKS, Local1)
                                        Store (Zero, DHKS)
                                    }
                                    Else
                                    {
                                        Store (DHKH, Local1)
                                        Store (Zero, DHKH)
                                    }
                                }
                            }

                            Release (XDHK)
                            Return (Local1)
                        }

                        Method (MHKE, 1, NotSerialized)
                        {
                            Store (Arg0, DHKB)
                            Acquire (XDHK, 0xFFFF)
                            Store (Zero, DHKH)
                            Store (Zero, DHKW)
                            Store (Zero, DHKS)
                            Store (Zero, DHKD)
                            Release (XDHK)
                        }

                        Method (MHKQ, 1, NotSerialized)
                        {
                            If (DHKB)
                            {
                                If (DHKC)
                                {
                                    Acquire (XDHK, 0xFFFF)
                                    If (LLess (Arg0, 0x1000)) {}
                                    Else
                                    {
                                        If (LLess (Arg0, 0x2000))
                                        {
                                            Store (Arg0, DHKH)
                                        }
                                        Else
                                        {
                                            If (LLess (Arg0, 0x3000))
                                            {
                                                Store (Arg0, DHKW)
                                            }
                                            Else
                                            {
                                                If (LLess (Arg0, 0x4000))
                                                {
                                                    Store (Arg0, DHKS)
                                                }
                                                Else
                                                {
                                                    If (LLess (Arg0, 0x5000))
                                                    {
                                                        Store (Arg0, DHKD)
                                                    }
                                                    Else
                                                    {
                                                        If (LLess (Arg0, 0x6000))
                                                        {
                                                            Store (Arg0, DHKH)
                                                        }
                                                        Else
                                                        {
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    Release (XDHK)
                                    If (LEqual (DHKH, 0x1003)) {}
                                    Notify (HKEY, 0x80)
                                }
                                Else
                                {
                                    If (LEqual (Arg0, 0x1004))
                                    {
                                        Notify (\_SB.SBTN, 0x80)
                                    }
                                }
                            }
                        }
                    }

                    Name (ACIN, 0x00)
                    Name (BTIN, 0x00)
                    OperationRegion (ERAM, EmbeddedControl, 0x00, 0xFF)
                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x04), 
                        CMCM,   8, 
                        CMD1,   8, 
                        CMD2,   8, 
                        CMD3,   8, 
                        Offset (0x18), 
                        SMPR,   8, 
                        SMST,   8, 
                        SMAD,   8, 
                        SMCM,   8, 
                        SMD0,   264, 
                        SMAA,   8, 
                        BATD,   16, 
                        ACDF,   1, 
                        Offset (0x4C), 
                        MBTS,   1, 
                        MBTF,   1, 
                            ,   4, 
                        MBTD,   1, 
                        Offset (0x4D), 
                        SBTS,   1, 
                        SBTF,   1, 
                            ,   4, 
                        SBTC,   1, 
                        Offset (0x4F), 
                        MBTC,   1, 
                        Offset (0x53), 
                        TMSS,   2, 
                            ,   2, 
                        BANK,   4, 
                        Offset (0x56), 
                            ,   4, 
                        FANC,   1, 
                        S5S,    1, 
                        WOL,    1, 
                        S1ST,   1, 
                        Offset (0x6C), 
                        FANS,   16, 
                        Offset (0x80), 
                        CTMP,   8, 
                        Offset (0x96), 
                        MBVT,   16, 
                        Offset (0x9A), 
                        MBCT,   16, 
                        Offset (0xA1), 
                        PTIM,   8, 
                        Offset (0xA8), 
                        RGA8,   8, 
                        Offset (0xB9), 
                        ARMB,   2, 
                        Offset (0xC0), 
                        RGC0,   8, 
                        Offset (0xF6), 
                        RMCA,   16
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C), 
                        SMW0,   16
                    }

                    Field (ERAM, ByteAcc, NoLock, Preserve)
                    {
                        Offset (0x1C), 
                        SMB0,   8
                    }

                    Method (_INI, 0, NotSerialized)
                    {
                        GHKS ()
                    }

                    Mutex (MUT0, 0x00)
                    Mutex (MUT1, 0x00)
                    Method (BPOL, 1, NotSerialized)
                    {
                        Store (0x97, \_SB.PCI0.ISA.BCMD)
                        Store (Arg0, \_SB.PCI0.ISA.PAR0)
                        Store (0x00, \_SB.PCI0.ISA.SMIC)
                    }

                    Name (ACEV, 0x00)
                    Name (BATO, 0x00)
                    Name (BATN, 0x00)
                    Name (BATF, 0x01C1)
                    Method (_Q09, 0, NotSerialized)
                    {
                        Notify (\_SB.SBTN, 0x02)
                    }

                    Method (CHAG, 0, NotSerialized)
                    {
                        Acquire (MUT1, 0xFFFF)
                        SELE ()
                        If (And (0x40, BATF))
                        {
                            Store (0x01, \_SB.BAT1.BTCH)
                            Notify (\_SB.BAT1, 0x00)
                        }

                        If (And (0x02, BATF))
                        {
                            Store ("Notify acad 00 & bat1 80 ", Debug)
                            If (LEqual (\_SB.OSTY, 0x01))
                            {
                                Store (0x01, \_SB.BAT1.ACCH)
                            }

                            Notify (\_SB.ACAD, 0x00)
                            If (And (0x01, BATF))
                            {
                                Store (0x83, \_SB.PCI0.ISA.BCMD)
                                Store (0x00, \_SB.PCI0.ISA.SMIC)
                            }
                            Else
                            {
                                Store (0x84, \_SB.PCI0.ISA.BCMD)
                                Store (0x00, \_SB.PCI0.ISA.SMIC)
                            }
                        }

                        Release (MUT1)
                    }

                    Name (SMBT, 0x00)
                    Method (_Q20, 0, NotSerialized)
                    {
                        Store ("=====================================================", Debug)
                        Store ("================== SMB_QUERY ========================", Debug)
                        Store ("=====================================================", Debug)
                        Store (SMST, SMBT)
                        Store (0xA0, \_SB.PCI0.ISA.BCMD)
                        Store (0x00, \_SB.PCI0.ISA.SMIC)
                        And (SMST, 0xBF, SMST)
                        If (\_SB.HCT)
                        {
                            Store ("=====================================================", Debug)
                            Store ("================== SMB_QUERY  HCT ===================", Debug)
                            Store ("=====================================================", Debug)
                            And (SMST, 0xBF, SMST)
                            Store (SMAA, Local0)
                            If (LEqual (Local0, 0x14))
                            {
                                CHKS ()
                                If (And (0x40, BATF))
                                {
                                    Store (0x01E9, \_SB.BAT1.UBIF)
                                    Notify (\_SB.BAT1, 0x00)
                                    Notify (\_SB.BAT1, 0x81)
                                }

                                If (And (0x02, BATF))
                                {
                                    Store (0x01, ACEV)
                                    Notify (\_SB.ACAD, 0x00)
                                    Notify (\_SB.BAT1, 0x80)
                                }
                            }
                        }
                        Else
                        {
                            Store ("=====================================================", Debug)
                            Store ("================== SMB_QUERY AC/BAT =================", Debug)
                            Store ("=====================================================", Debug)
                            Acquire (MUT0, 0x1000)
                            If (And (SMBT, 0x40))
                            {
                                If (LNot (LLess (\_SB.BAT1.BCUT, \_SB.BAT1.BCMP)))
                                {
                                    Store (SMAA, Local0)
                                    Store (Local0, Debug)
                                    If (LEqual (Local0, 0x14))
                                    {
                                        CHAG ()
                                    }
                                    Else
                                    {
                                        If (LEqual (Local0, 0x16))
                                        {
                                            Store ("Alarm and notify BAT1 00", Debug)
                                            Notify (\_SB.BAT1, 0x00)
                                        }
                                    }
                                }
                            }

                            Release (MUT0)
                        }
                    }

                    Method (CHKS, 0, NotSerialized)
                    {
                        Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), BATN)
                        Store ("----------------Notify BATD", Debug)
                        Store (BATN, Debug)
                        Store (0x00, BATF)
                        If (And (0xC0, BATN))
                        {
                            Or (BATF, 0x01, BATF)
                        }

                        If (And (0x0C00, BATN))
                        {
                            Or (BATF, 0x04, BATF)
                        }

                        And (BATN, 0x01, Local0)
                        And (BATO, 0x01, Local1)
                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x40, BATF)
                        }

                        And (BATN, 0xC0, Local0)
                        And (BATO, 0xC0, Local1)
                        If (Not (LEqual (Local0, Local1)))
                        {
                            Or (BATF, 0x02, BATF)
                        }

                        If (And (0x04, BATF))
                        {
                            Or (BATF, 0x10, BATF)
                        }
                    }

                    Method (CHKA, 0, NotSerialized)
                    {
                        Store (0x00, BATF)
                        If (\_SB.OKEC)
                        {
                            Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), BATN)
                            Store (BATN, BATO)
                            If (And (0xC0, BATN))
                            {
                                Or (BATF, 0x01, BATF)
                            }
                            Else
                            {
                                And (BATF, 0xFFFE, BATF)
                            }
                        }
                    }

                    Method (CHKB, 0, NotSerialized)
                    {
                        And (BATN, 0x01, Local0)
                        If (Local0)
                        {
                            Or (BATF, 0x0100, BATF)
                        }
                        Else
                        {
                            And (BATF, 0xFEFF, BATF)
                        }
                    }

                    Method (SELE, 0, NotSerialized)
                    {
                        If (\_SB.OKEC)
                        {
                            Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), BATN)
                            Store (0x00, BATF)
                            If (And (0xC0, BATN))
                            {
                                Or (BATF, 0x01, BATF)
                            }

                            If (And (0x0300, BATN))
                            {
                                Or (BATF, 0x04, BATF)
                            }

                            And (BATN, 0x01, Local0)
                            And (BATO, 0x01, Local1)
                            If (Local0)
                            {
                                Or (BATF, 0x0100, BATF)
                            }
                            Else
                            {
                                And (BATF, 0xFEFF, BATF)
                            }

                            If (Not (LEqual (Local0, Local1)))
                            {
                                Or (BATF, 0x40, BATF)
                            }

                            And (BATN, 0xC0, Local0)
                            And (BATO, 0xC0, Local1)
                            If (Not (LEqual (Local0, Local1)))
                            {
                                Or (BATF, 0x02, BATF)
                            }

                            If (And (0x01, BATF))
                            {
                                If (And (0x04, BATF))
                                {
                                    If (And (BATN, 0x20))
                                    {
                                        Or (BATF, 0x10, BATF)
                                    }
                                }
                            }

                            Store (BATN, BATO)
                        }
                    }

                    Method (_Q01, 0, NotSerialized)
                    {
                        Store ("==== Fn+F3 hot key handler ====", Debug)
                        If (\_SB.PCI0.ISA.EC0.VDHK)
                        {
                            \_SB.PCI0.ISA.EC0.HKEY.MHKQ (0x1003)
                        }
                        Else
                        {
                            Store (0x8F, \_SB.PCI0.ISA.BCMD)
                            Store (0x00, \_SB.PCI0.ISA.SMIC)
                        }
                    }

                    Method (_Q02, 0, NotSerialized)
                    {
                        Store ("==== Fn+F7 hot key handler ====", Debug)
                        If (LEqual (\_SB.PCI0.VGA.SWIT, 0x00))
                        {
                            Store (0x9E, \_SB.PCI0.ISA.BCMD)
                            Store (0x00, \_SB.PCI0.ISA.SMIC)
                            Store (\_SB.PCI0.ISA.PAR0, Local0)
                            Store (\_SB.PCI0.ISA.PAR1, Local3)
                            If (LNot (LLess (Local0, 0x03)))
                            {
                                Store (0x01, Local0)
                            }
                            Else
                            {
                                Increment (Local0)
                            }

                            Store ("Current Display Device = ", Debug)
                            Store (Local0, Debug)
                            If (Local3)
                            {
                                Store (One, Local4)
                                Store (Zero, Local5)
                            }
                            Else
                            {
                                Store (Zero, Local4)
                                Store (One, Local5)
                            }

                            If (LEqual (Local0, 0x03))
                            {
                                Store ("Both", Debug)
                                Store (Local4, \_SB.PCI0.VGA.CRTA)
                                Store (One, \_SB.PCI0.VGA.LCDA)
                            }

                            If (LEqual (Local0, 0x01))
                            {
                                Store ("LCD", Debug)
                                Store (Zero, \_SB.PCI0.VGA.CRTA)
                                Store (One, \_SB.PCI0.VGA.LCDA)
                            }

                            If (LEqual (Local0, 0x02))
                            {
                                Store ("CRT", Debug)
                                Store (Local4, \_SB.PCI0.VGA.CRTA)
                                Store (Local5, \_SB.PCI0.VGA.LCDA)
                            }

                            Notify (\_SB.PCI0.VGA, 0x80)
                        }
                        Else
                        {
                            Store (0x9F, \_SB.PCI0.ISA.BCMD)
                            Store (0x00, \_SB.PCI0.ISA.SMIC)
                        }
                    }

                    Method (_Q0C, 0, NotSerialized)
                    {
                        \_SB.PCI0.ISA.EC0.HKEY.MHKQ (0x100C)
                    }

                    Method (_Q0B, 0, NotSerialized)
                    {
                        Store ("Sleep Button Query: Fn+F4", Debug)
                        If (\_SB.PCI0.ISA.EC0.VDHK)
                        {
                            \_SB.PCI0.ISA.EC0.HKEY.MHKQ (0x1004)
                        }
                        Else
                        {
                            Notify (\_SB.SBTN, 0x80)
                        }
                    }

                    Method (_Q80, 0, NotSerialized)
                    {
                        Store ("Temperature increasing: _Q80", Debug)
                        Notify (\_TZ.THRM, 0x80)
                    }

                    Method (_Q81, 0, NotSerialized)
                    {
                        Store ("Temperature decreasing: _Q81", Debug)
                        Notify (\_TZ.THRM, 0x80)
                    }
                }
            }

            Device (PWR)
            {
                Name (_ADR, 0x00070003)
                OperationRegion (GLBL, SystemIO, 0x8028, 0x04)
                Field (GLBL, ByteAcc, NoLock, Preserve)
                {
                        ,   2, 
                    TPOL,   1, 
                    Offset (0x03), 
                        ,   1, 
                    LPOL,   1
                }

                OperationRegion (GPIO, SystemIO, 0x8030, 0x08)
                Field (GPIO, ByteAcc, NoLock, Preserve)
                {
                    Offset (0x06), 
                        ,   4, 
                    Z000,   1
                }

                OperationRegion (Z002, SystemIO, 0x8010, 0x01)
                Field (Z002, ByteAcc, NoLock, Preserve)
                {
                        ,   4, 
                    Z001,   1
                }
            }

            Device (LAN)
            {
                Name (_ADR, 0x000C0000)
                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x04
                })
            }

            Device (VGA)
            {
                Name (_ADR, 0x00090000)
                Name (EDID, Package (0x08)
                {
                    "IBM0A2E", 
                    "IBM0A41", 
                    "IBM0A4B", 
                    "IBM0A50", 
                    "IBM0A55", 
                    "IBM254A", 
                    "IBM254C", 
                    "IBM254D"
                })
                Name (SWIT, 0x01)
                Name (CRTA, 0x01)
                Name (LCDA, 0x01)
                Method (_DOS, 1, NotSerialized)
                {
                    Store (Arg0, SWIT)
                }

                Name (_DOD, Package (0x02)
                {
                    0x00010100, 
                    0x00010110
                })
                Device (CRT)
                {
                    Name (_ADR, 0x0100)
                    Method (_DCS, 0, NotSerialized)
                    {
                        If (CRTA)
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x1D)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (CRTA)
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        Store ("CRT --_DSS", Debug)
                    }
                }

                Device (LCD)
                {
                    Name (_ADR, 0x0110)
                    Method (_DCS, 0, NotSerialized)
                    {
                        If (LCDA)
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x1D)
                        }
                    }

                    Method (_DGS, 0, NotSerialized)
                    {
                        If (LCDA)
                        {
                            Return (0x01)
                        }
                        Else
                        {
                            Return (0x00)
                        }
                    }

                    Method (_DSS, 1, NotSerialized)
                    {
                        Store ("LCD --_DSS", Debug)
                    }
                }
            }

            Device (CRD0)
            {
                Name (_ADR, 0x000A0000)
                Name (_PRW, Package (0x02)
                {
                    0x0C, 
                    0x03
                })
                OperationRegion (NPCC, PCI_Config, 0x00, 0xE0)
                Field (NPCC, DWordAcc, NoLock, Preserve)
                {
                    Offset (0x04), 
                    TI04,   8, 
                    Offset (0x0D), 
                    TI0D,   8, 
                    Offset (0x3E), 
                    TI3E,   16, 
                    Offset (0x44), 
                    TI44,   16, 
                    Offset (0x80), 
                    TI80,   8, 
                    Offset (0x8C), 
                    TI8C,   8, 
                    TI8D,   8, 
                    TI8E,   8, 
                    TI8F,   8, 
                    Offset (0x91), 
                    TI91,   8, 
                    Offset (0xA4), 
                    TIA4,   8, 
                    TIA5,   8
                }

                OperationRegion (TIIO, SystemIO, 0x03E0, 0x02)
                Field (TIIO, ByteAcc, NoLock, Preserve)
                {
                    TIID,   8, 
                    TIDA,   8
                }

                Method (_INI, 0, NotSerialized)
                {
                    Store (TIA4, Local0)
                    Store (And (0xF0, TIA4), TIA4)
                    Store (Zero, TI44)
                    Store (And (TI8E, 0xF0), TI8E)
                    Store (Or (TI80, 0x01), TI80)
                    Store (And (TI91, 0x7F), TI91)
                    Store (Local0, TIA4)
                }

                Name (TIWK, Zero)
                Method (_PSW, 1, NotSerialized)
                {
                    If (LEqual (Arg0, One))
                    {
                        Store (One, TIWK)
                    }
                    Else
                    {
                        Store (Zero, TIWK)
                    }
                }

                Method (_PS0, 0, NotSerialized)
                {
                    Store (And (0xF0, TIA4), TIA4)
                }

                Method (_PS1, 0, NotSerialized)
                {
                    Store (And (0xF0, TIA4), TIA4)
                }

                Method (_PS2, 0, NotSerialized)
                {
                    Store (And (0xF0, TIA4), TIA4)
                }

                Method (_PS3, 0, NotSerialized)
                {
                    Store (0x02, TIA4)
                }

                Name (EX03, Zero)
                Method (TIEN, 1, NotSerialized)
                {
                    If (TIWK)
                    {
                        If (LEqual (Arg0, One))
                        {
                            Store (TIA4, Local0)
                            Store (And (0xF0, TIA4), TIA4)
                            Store (TI04, Local1)
                            Store (Or (TI04, 0x01), TI04)
                            Store (0x03E1, TI44)
                            Store (0x03, TIID)
                            Store (TIDA, EX03)
                            Store (Or (EX03, 0x80), TIDA)
                            Store (Zero, TI44)
                            Store (Local1, TI04)
                            Store (Local0, TIA4)
                            Store (Or (TIA5, 0x01), TIA5)
                        }

                        If (LEqual (Arg0, Zero))
                        {
                            If (And (TIA5, 0x80))
                            {
                                Store (TIA5, Local0)
                                Store (Local0, TIA5)
                                Notify (\_SB.PCI0.CRD0, 0x00)
                            }
                        }
                    }
                }
            }

            Device (AUDO)
            {
                Name (_ADR, 0x01)
            }

            Device (MODM)
            {
                Name (_ADR, 0x02)
                Name (_PRW, Package (0x02)
                {
                    0x0D, 
                    0x04
                })
            }
        }

        Device (SBTN)
        {
            Name (_HID, EisaId ("PNP0C0E"))
        }

        Device (ACAD)
        {
            Name (_HID, "ACPI0003")
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (AFST, 0x00)
            Name (FST, 0x01)
            Method (_PSR, 0, NotSerialized)
            {
                And (\_SB.PCI0.ISA.EC0.BATF, 0x01, Local0)
                If (Local0)
                {
                    Return (One)
                }
                Else
                {
                    Return (Zero)
                }
            }

            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.HCT)
                {
                    Return (0x0F)
                }
                Else
                {
                    \_SB.PCI0.ISA.EC0.CHKA ()
                    Return (0x0F)
                }
            }
        }

        Device (BAT1)
        {
            Name (_HID, EisaId ("PNP0C0A"))
            Name (_PCL, Package (0x01)
            {
                \_SB
            })
            Name (BP, 0x01)
            Name (BCMP, 0x0D)
            Name (BCUT, 0x00)
            Name (BTCH, 0x01)
            Name (ACCH, 0x00)
            Name (BFST, 0x00)
            Name (PBIF, Package (0x0D)
            {
                0x00, 
                0xFFFFFFFF, 
                0xFFFFFFFF, 
                0x01, 
                0xFFFFFFFF, 
                0x96, 
                0x7E, 
                0x04, 
                0x04, 
                "BQ2040", 
                " ", 
                "LION ", 
                "SANYO "
            })
            Name (PBST, Package (0x04)
            {
                0x00, 
                0xFFFFFFFF, 
                0x04B0, 
                0x2710
            })
            Method (_STA, 0, NotSerialized)
            {
                If (\_SB.HCT)
                {
                    Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), Local1)
                    And (Local1, 0x01, Local0)
                    If (Local0)
                    {
                        Store (0x01, BP)
                    }
                    Else
                    {
                        Store (0x00, BP)
                    }

                    If (BP)
                    {
                        Return (0x1F)
                    }
                    Else
                    {
                        Return (0x0F)
                    }
                }
                Else
                {
                    If (LNot (LLess (BCUT, BCMP)))
                    {
                        \_SB.PCI0.ISA.EC0.CHKB ()
                        And (\_SB.PCI0.ISA.EC0.BATF, 0x0100, Local0)
                        If (Local0)
                        {
                            Return (0x1F)
                        }
                        Else
                        {
                            Return (0x0F)
                        }
                    }
                    Else
                    {
                        Increment (BCUT)
                        Return (0x0F)
                    }
                }
            }

            Method (_BIF, 0, NotSerialized)
            {
                Store ("=============================================", Debug)
                Store ("============================ BATTERY _BIF    ", Debug)
                Store ("=============================================", Debug)
                If (\_SB.HCT)
                {
                    If (BP)
                    {
                        HVBI ()
                    }
                    Else
                    {
                        IVBI ()
                    }
                }
                Else
                {
                    If (LNot (LLess (BCUT, BCMP)))
                    {
                        Acquire (\_SB.PCI0.ISA.EC0.MUT0, 0xFFFF)
                        If (And (\_SB.PCI0.ISA.EC0.BATF, 0x0100))
                        {
                            UPBI ()
                        }
                        Else
                        {
                            IVBI ()
                        }

                        Release (\_SB.PCI0.ISA.EC0.MUT0)
                    }
                    Else
                    {
                        HVBI ()
                    }
                }

                Return (PBIF)
            }

            Method (_BST, 0, NotSerialized)
            {
                Store ("=============================================", Debug)
                Store ("============================ BATTERY _BST    ", Debug)
                Store ("=============================================", Debug)
                If (\_SB.HCT)
                {
                    Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), Local1)
                    And (Local1, 0x01, Local0)
                    If (Local0)
                    {
                        HPBS ()
                    }
                    Else
                    {
                        IVBS ()
                    }
                }
                Else
                {
                    If (LNot (LLess (BCUT, BCMP)))
                    {
                        If (\_SB.OKEC)
                        {
                            Acquire (\_SB.PCI0.ISA.EC0.MUT0, 0xFFFF)
                            If (And (\_SB.PCI0.ISA.EC0.BATF, 0x0100))
                            {
                                UPBS ()
                            }
                            Else
                            {
                                IVBS ()
                            }

                            Release (\_SB.PCI0.ISA.EC0.MUT0)
                            Store (0x8E, \_SB.PCI0.ISA.BCMD)
                            Store (0x00, \_SB.PCI0.ISA.SMIC)
                        }
                    }
                    Else
                    {
                        IVBS ()
                    }
                }

                Return (PBST)
            }

            Name (UBIF, 0x01E9)
            Method (UPBI, 0, NotSerialized)
            {
                If (BTCH)
                {
                    Store (0x98, \_SB.PCI0.ISA.BCMD)
                    Store (0x00, \_SB.PCI0.ISA.SMIC)
                    Store (\_SB.PCI0.ISA.PAR0, Index (PBIF, 0x01))
                    Store (\_SB.PCI0.ISA.PAR1, Index (PBIF, 0x04))
                    Store (\_SB.PCI0.ISA.PAR2, Index (PBIF, 0x02))
                    Store (0x00, BTCH)
                }

                Return (One)
            }

            Method (HPBS, 0, NotSerialized)
            {
                Store (Zero, Local0)
                Store (\_SB.PCI0.ISA.EC0.BANK, Local1)
                Store (0x06, \_SB.PCI0.ISA.EC0.BANK)
                Store (\_SB.PCI0.ISA.EC0.MBCT, Local2)
                If (And (Local2, 0x8000))
                {
                    Or (Local2, 0xFFFF0000, Local2)
                    Add (Not (Local2), 0x01, Local2)
                }

                Store (\_SB.PCI0.ISA.EC0.MBVT, Local3)
                Store (0x04, \_SB.PCI0.ISA.EC0.BANK)
                Store (\_SB.PCI0.ISA.EC0.RMCA, Local5)
                Store (Local1, \_SB.PCI0.ISA.EC0.BANK)
                If (LNot (LEqual (Local2, DerefOf (Index (PBST, 0x01)))))
                {
                    Store (Local2, Index (PBST, 0x01))
                    Store (Ones, Local0)
                }

                If (LNot (LEqual (Local3, DerefOf (Index (PBST, 0x03)))))
                {
                    Store (Local3, Index (PBST, 0x03))
                    Store (Ones, Local0)
                }

                If (LNot (LEqual (Local5, DerefOf (Index (PBST, 0x02)))))
                {
                    Store (Local5, Index (PBST, 0x02))
                    Store (Ones, Local0)
                }

                Store (0x00, Local4)
                Store (\_SB.PCI0.ISA.SMI (0x99, 0x00, 0x00, 0x00, 0x00), Local1)
                If (And (Local1, 0x0C00))
                {
                    Store ("---Set Power State as charging", Debug)
                    Or (0x02, Local4, Local4)
                }
                Else
                {
                    Store ("---Set Power State as discharging", Debug)
                    Or (0x01, Local4, Local4)
                }

                If (LNot (LEqual (Local4, DerefOf (Index (PBST, 0x00)))))
                {
                    Store (Local4, Index (PBST, 0x00))
                    Store (Ones, Local0)
                }

                Return (Local0)
            }

            Method (UPBS, 0, NotSerialized)
            {
                Store (\_SB.PCI0.ISA.SMI (0x92, 0x00, 0x00, 0x00, 0x00), Local5)
                Store (\_SB.PCI0.ISA.PAR1, Local6)
                If (Local5)
                {
                    Store (Local5, Index (PBST, 0x02))
                }
                Else
                {
                    Store (0x0E10, Index (PBST, 0x02))
                }

                Store (" ============== BATTERY BST INDEX 2 =", Debug)
                Store (Local5, Debug)
                Store (" ============== BATTERY BST INDEX 1 =", Debug)
                Store (Local6, Debug)
                Subtract (0x00, Local6, Local0)
                Store (" ============== BATTERY LOCAL0  =", Debug)
                Store (Local0, Debug)
                And (0xFFFF, Local0, Local6)
                Store (" ============== BATTERY LOCAL6  =", Debug)
                Store (Local6, Debug)
                Increment (Local6)
                Store (0x00, Local0)
                If (ACCH)
                {
                    If (And (\_SB.PCI0.ISA.EC0.BATF, 0x01))
                    {
                        Store (0x02, Local0)
                    }
                    Else
                    {
                        Store (0x01, Local0)
                    }

                    Increment (ACCH)
                    If (LEqual (ACCH, 0x03))
                    {
                        Store (0x00, ACCH)
                    }
                }
                Else
                {
                    If (And (\_SB.PCI0.ISA.EC0.BATF, 0x01))
                    {
                        If (And (\_SB.PCI0.ISA.EC0.BATF, 0x10))
                        {
                            Store ("---NO ACEV Set Power State as charging", Debug)
                            Or (0x02, Local0, Local0)
                        }

                        Store (0xFFFFFFFF, Index (PBST, 0x01))
                    }
                    Else
                    {
                        Store ("---Set Power State as discharging", Debug)
                        Or (0x01, Local0, Local0)
                        Store (Local6, Index (PBST, 0x01))
                    }
                }

                Store ("BATTERY BIF INDEX 0 =", Debug)
                Store (Local0, Debug)
                Store (Local0, Index (PBST, 0x00))
            }

            Method (HVBI, 0, NotSerialized)
            {
                Store (0x05DC, Index (PBIF, 0x01))
                Store (0x05DC, Index (PBIF, 0x02))
                Store (0x3138, Index (PBIF, 0x04))
            }

            Method (IVBI, 0, NotSerialized)
            {
                Store (0xFFFFFFFF, Index (PBIF, 0x01))
                Store (0xFFFFFFFF, Index (PBIF, 0x02))
                Store (0xFFFFFFFF, Index (PBIF, 0x04))
            }

            Method (IVBS, 0, NotSerialized)
            {
                Store (0x00, Index (PBST, 0x00))
                Store (0xFFFFFFFF, Index (PBST, 0x01))
                Store (0x0E10, Index (PBST, 0x02))
                Store (0x2710, Index (PBST, 0x03))
            }
        }

        Device (LID)
        {
            Name (_HID, EisaId ("PNP0C0D"))
            Method (_LID, 0, NotSerialized)
            {
                Return (\_SB.PCI0.PWR.LPOL)
            }

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