Attachment 51182 Details for Bug 77805 – rj-compaq_armada_110.asl

rj-compaq_armada_110.asl

rj-compaq_armada_110.asl (text/plain), 113.54 KB, created by RJ on 2005-02-22 04:49:49 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: RJ

Created: 2005-02-22 04:49:49 UTC

Size: 113.54 KB

patch

obsolete

>/*
>  RSD PTR: OEM=PTLTD, ACPI_Rev=1.0x (0)
>	RSDT=0x0b7fbdc2, cksum=48
> */
>/*
>  RSDT: Length=44, Revision=1, Checksum=209,
>	OEMID=PTLTD, OEM Table ID=  RSDT, OEM Revision=0x6040000,
>	Creator ID= LTP, Creator Revision=0x0
>	Entries={ 0x0b7ffb64, 0x0b7ffbd8 }
> */
>/*
>  FACP: Length=116, Revision=1, Checksum=47,
>	OEMID=COMPAQ, OEM Table ID=Borg, OEM Revision=0x6040000,
>	Creator ID=PTL_, Creator Revision=0xf4240
> 	FACS=0xb7fffc0, DSDT=0xb7fbdee
>	INT_MODEL=PIC
>	Preferred_PM_Profile=Unspecified (0)
>	SCI_INT=10
>	SMI_CMD=0x802f, ACPI_ENABLE=0xf0, ACPI_DISABLE=0xf1, S4BIOS_REQ=0xf2
>	PSTATE_CNT=0x0
>	PM1a_EVT_BLK=0x8000-0x8003
>	PM1a_CNT_BLK=0x8004-0x8005
>	PM_TMR_BLK=0x8008-0x800b
>	GPE0_BLK=0x8020-0x8023
>	P_LVL2_LAT=90 us, P_LVL3_LAT=900 us
>	FLUSH_SIZE=0, FLUSH_STRIDE=0
>	DUTY_OFFSET=0, DUTY_WIDTH=0
>	DAY_ALRM=13, MON_ALRM=0, CENTURY=50
>	IAPC_BOOT_ARCH=
>	Flags={WBINVD,PROC_C1,SLP_BUTTON,RESET_REG}
>	RESET_REG=0x00000028 (?), RESET_VALUE=0x4c
> */
>/*
>  FACS:	Length=64, HwSig=0x000009b0, Firm_Wake_Vec=0x00000000
>	Global_Lock=
>	Flags=
>	Version=0
> */
>/*
>  DSDT: Length=15734, Revision=1, Checksum=181,
>	OEMID=Compaq, OEM Table ID=Wrangler, OEM Revision=0x6040000,
>	Creator ID=MSFT, Creator Revision=0x100000d
> */
>/*
>  BOOT: Length=40, Revision=1, Checksum=164,
>	OEMID=PTLTD, OEM Table ID=$SBFTBL$, OEM Revision=0x6040000,
>	Creator ID= LTP, Creator Revision=0x1
> */
>/*
> * Intel ACPI Component Architecture
> * AML Disassembler version 20041119
> *
> * Disassembly of /tmp/acpidump.AWDt6x, Mon Feb 21 18:33:46 2005
> */
>DefinitionBlock ("DSDT.aml", "DSDT", 1, "Compaq", "Wrangler", 100925440)
>{
>    Scope (\_PR)
>    {
>        Processor (CPU0, 0x01, 0x00008010, 0x06) {}
>    }
>
>    Name (\_S0, Package (0x02)
>    {
>        0x00, 
>        0x00
>    })
>    Name (\_S1, Package (0x02)
>    {
>        0x04, 
>        0x04
>    })
>    Name (\_S4, Package (0x02)
>    {
>        0x02, 
>        0x02
>    })
>    Name (\_S5, Package (0x02)
>    {
>        0x02, 
>        0x02
>    })
>    Scope (\_GPE)
>    {
>        Name (LIF1, 0x00)
>        Name (LIF2, 0x00)
>        Method (_L0B, 0, NotSerialized)
>        {
>            \_SB.Z000 (0x85)
>            If (LNot (LEqual (\_SB.PCI0.SDCS, 0x02)))
>            {
>                If (\_SB.PCI0.PM.LIDI)
>                {
>                    Store (0x01, \_SB.PCI0.PM.DISP)
>                }
>                Else
>                {
>                    Store (0x00, \_SB.PCI0.PM.DISP)
>                }
>            }
>
>            If (LEqual (\_GPE.LIF1, 0x01))
>            {
>                If (\_SB.PCI0.PM.LIDI)
>                {
>                    Store (0x01, \_SB.PCI0.PM.LPOL)
>                }
>                Else
>                {
>                    Store (0x00, \_SB.PCI0.PM.LPOL)
>                }
>
>                Store (0x00, \_GPE.LIF1)
>                If (LEqual (\_SB.PCI0.MYOS, 0x01))
>                {
>                    \_SB.PCI0.AGP.VGA.DRUU (0xFF)
>                }
>                Else
>                {
>                    \_SB.Z000 (0x84)
>                }
>            }
>            Else
>            {
>                If (LEqual (\_GPE.LIF2, 0x01))
>                {
>                    If (\_SB.PCI0.PM.LIDI)
>                    {
>                        Store (0x01, \_SB.PCI0.PM.LPOL)
>                    }
>                    Else
>                    {
>                        Store (0x00, \_SB.PCI0.PM.LPOL)
>                    }
>
>                    Store (0x00, \_GPE.LIF2)
>                    Notify (\_SB.LID, 0x80)
>                }
>                Else
>                {
>                    If (LEqual (\_SB.PCI0.CRTS, 0x01))
>                    {
>                        If (\_SB.PCI0.PM.LIDI)
>                        {
>                            Store (0x01, \_SB.PCI0.PM.LPOL)
>                        }
>                        Else
>                        {
>                            Store (0x00, \_SB.PCI0.PM.LPOL)
>                        }
>
>                        If (LEqual (\_SB.PCI0.PM.LPOL, 0x01))
>                        {
>                            If (LEqual (\_SB.PCI0.MYOS, 0x01))
>                            {
>                                \_SB.PCI0.AGP.VGA.DRUU (0xFF)
>                            }
>                            Else
>                            {
>                                \_SB.Z000 (0x84)
>                            }
>                        }
>                        Else
>                        {
>                            Store (0x01, \_GPE.LIF1)
>                            If (LEqual (\_SB.PCI0.MYOS, 0x01))
>                            {
>                                \_SB.PCI0.AGP.VGA.DRUU (0x00)
>                            }
>                            Else
>                            {
>                                \_SB.Z000 (0x83)
>                            }
>                        }
>                    }
>                    Else
>                    {
>                        Store (" GPE_L0B - LID CLOSED ", Debug)
>                        If (\_SB.PCI0.PM.LIDI)
>                        {
>                            Store (0x01, \_SB.PCI0.PM.LPOL)
>                        }
>                        Else
>                        {
>                            Store (0x00, \_SB.PCI0.PM.LPOL)
>                        }
>
>                        Store (0x01, \_GPE.LIF2)
>                        Notify (\_SB.LID, 0x80)
>                    }
>                }
>            }
>        }
>
>        Method (_L0D, 0, NotSerialized)
>        {
>            Store (" GPE_L0D - AC97 WAKEUP ", Debug)
>            Notify (\_SB.PCI0.MODM, 0x02)
>        }
>
>        Method (_L09, 0, NotSerialized)
>        {
>            Store ("_GPE._L09 - USB", Debug)
>            Notify (\_SB.PCI0.USB0, 0x02)
>        }
>
>        Method (_L05, 0, NotSerialized)
>        {
>            Notify (\_SB.PCI0, 0x02)
>        }
>
>        Name (HKFG, 0x00)
>        Method (_L00, 0, NotSerialized)
>        {
>            If (LEqual (\_GPE.HKFG, 0x00))
>            {
>                \_SB.Z000 (0x82)
>            }
>            Else
>            {
>                Store (0x00, \_GPE.HKFG)
>                Notify (\_SB.PWRB, 0x02)
>            }
>        }
>    }
>
>    OperationRegion (CMOS, SystemIO, 0x72, 0x02)
>    Field (CMOS, ByteAcc, NoLock, Preserve)
>    {
>        CINX,   8, 
>        CDAT,   8
>    }
>
>    IndexField (CINX, CDAT, ByteAcc, NoLock, Preserve)
>    {
>        Offset (0xA0), 
>        BCRN,   16, 
>        MFCC,   16, 
>        Offset (0xA6), 
>        MBRM,   16, 
>        Offset (0xAA), 
>        MBVT,   16, 
>        Offset (0xAE), 
>        Offset (0xB0), 
>        MBTS,   1, 
>            ,   1, 
>            ,   2, 
>        MBTD,   1, 
>            ,   1, 
>        MBTC,   1, 
>        Offset (0xB1), 
>        ACDF,   1, 
>            ,   1, 
>            ,   2, 
>            ,   1, 
>        Offset (0xB2), 
>        CTMP,   8
>    }
>
>    Method (\_PTS, 1, NotSerialized)
>    {
>        If (LNot (LLess (Arg0, 0x04)))
>        {
>            Store (0x01, \_SB.PCI0.PM.MUTE)
>            Sleep (0x64)
>        }
>
>        If (LEqual (Arg0, 0x01))
>        {
>            Store ("------------- System S0 to S1 mode -------------", Debug)
>            \_SB.Z000 (0x80)
>            Store (0x01, \_GPE.HKFG)
>            Store (0x00, \_SB.PCI0.PM.LPOL)
>        }
>    }
>
>    Method (\_WAK, 1, NotSerialized)
>    {
>        Store (0x00, \_SB.ACAD.AFST)
>        Store (0x00, \_SB.BAT1.BFST)
>        Store (0x01, \_SB.MFLG)
>        Store (0x01, \_SB.FACD)
>        Store (0x00, \_GPE.LIF1)
>        Store (0x00, \_GPE.LIF2)
>        \_SB.PCI0.AGP.VGA._INI ()
>        Store (0x01, \_SB.PCI0.PM.LPOL)
>        If (LEqual (Arg0, 0x04))
>        {
>            Store ("------------- System S0 to S4 mode -------------", Debug)
>            \_SB.Z000 (0x88)
>        }
>
>        If (LEqual (Arg0, 0x01))
>        {
>            Store ("------------- System S1 to S0 mode -------------", Debug)
>            \_SB.Z000 (0x81)
>            If (LEqual (\_SB.PCI0.MYOS, 0x01))
>            {
>                Notify (\_SB.PCI0.AGP.VGA, 0x00)
>                Return (0x00)
>            }
>        }
>        Else
>        {
>            \_SB.BAT1.SEBI ()
>            \_SB.PCI0.PIB.EC0.SELE ()
>        }
>
>        Notify (\_SB.PWRB, 0x02)
>    }
>
>    Scope (\_TZ)
>    {
>        Name (TPL, 0x0D9A)
>        Name (TACT, 0x0DFE)
>        Name (TPAS, 0x0E62)
>        Name (TPC, 0x0E94)
>        Name (TPTM, 0x0CA0)
>        Name (TBSE, 0x0AAC)
>        Name (PLCY, 0x00)
>        ThermalZone (THRM)
>        {
>            Name (_TSP, 0x28)
>            Method (_CRT, 0, NotSerialized)
>            {
>                Return (TPC)
>            }
>
>            Name (INBT, 0x00)
>            Method (_TMP, 0, NotSerialized)
>            {
>                If (\_SB.OKEC)
>                {
>                    If (LEqual (INBT, 0x00))
>                    {
>                        Store (0x01, INBT)
>                        \_SB.BAT1.SEBI ()
>                        Notify (\_SB.ACAD, 0x00)
>                        Notify (\_SB.BAT1, 0x81)
>                        Notify (\_SB.BAT1, 0x80)
>                    }
>
>                    Return (TPTM)
>                    Store ("Current Temperature C is ----------- ", Debug)
>                    Store (Local0, Debug)
>                    If (LGreater (Local0, 0x56))
>                    {
>                        Store (0x56, Local0)
>                    }
>
>                    Store (Local0, Local2)
>                    Multiply (Local0, 0x0A, Local1)
>                    Add (Local1, TBSE, Local0)
>                    Store ("Current Temperature K is ----------- ", Debug)
>                    Store (Local0, Debug)
>                    CHTR (Local2)
>                    Return (Local0)
>                }
>                Else
>                {
>                    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 (Arg0, PLCY)
>            }
>
>            Name (TRP2, 0x00)
>            Method (CHTR, 1, NotSerialized)
>            {
>                If (LNot (LGreater (Arg0, 0x4D)))
>                {
>                    Store (0x00, \_SB.PCI0.PM.TREN)
>                    Store (0x00, TRP2)
>                }
>                Else
>                {
>                    If (LEqual (TRP2, 0x00))
>                    {
>                        If (LAnd (LNot (LLess (Arg0, 0x51)), LLess (Arg0, 0x55)))
>                        {
>                            Store (0x0C, \_SB.PCI0.PM.TRDC)
>                            Store (0x01, \_SB.PCI0.PM.TREN)
>                        }
>                        Else
>                        {
>                            If (LNot (LLess (Arg0, 0x55)))
>                            {
>                                Store (0x01, TRP2)
>                                Store (0x07, \_SB.PCI0.PM.TRDC)
>                                Store (0x01, \_SB.PCI0.PM.TREN)
>                            }
>                        }
>                    }
>                    Else
>                    {
>                        If (LNot (LGreater (Arg0, 0x51)))
>                        {
>                            Store (0x00, TRP2)
>                            Store (0x0C, \_SB.PCI0.PM.TRDC)
>                            Store (0x01, \_SB.PCI0.PM.TREN)
>                        }
>                    }
>                }
>            }
>        }
>    }
>
>    Scope (_SB)
>    {
>        Name (MFLG, 0x01)
>        Name (MBT0, 0x01)
>        Name (ACD0, 0x01)
>        Name (FACD, 0x01)
>        Name (THGO, 0x00)
>        Name (FMST, 0x01)
>        Mutex (VSMX, 0x00)
>        Method (Z000, 1, Serialized)
>        {
>            Store ("--------- VIA SOFTWARE SMI PMIO 2Fh ------------", Debug)
>            Acquire (VSMX, 0xFFFF)
>            Store (Arg0, \_SB.PCI0.PM.BCMD)
>            Release (VSMX)
>        }
>
>        Device (PWRB)
>        {
>            Name (_HID, EisaId ("PNP0C0C"))
>            Name (_PRW, Package (0x02)
>            {
>                0x00, 
>                0x01
>            })
>        }
>
>        Device (SLPB)
>        {
>            Name (_HID, EisaId ("PNP0C0E"))
>        }
>
>        Device (ACAD)
>        {
>            Name (_HID, "ACPI0003")
>            Name (_PCL, Package (0x01)
>            {
>                \_SB
>            })
>            Name (AFST, 0x00)
>            Name (ALST, 0x00)
>            Name (FST, 0x01)
>            Method (_PSR, 0, NotSerialized)
>            {
>                If (\_SB.OKEC)
>                {
>                    If (FST)
>                    {
>                        \_SB.Z000 (0x8C)
>                        If (ACDF)
>                        {
>                            Store (0x01, \_SB.PCI0.PIB.EC0.ACIN)
>                            Store (\_SB.PCI0.PIB.EC0.ACIN, \_SB.PCI0.PIB.EC0.ACFK)
>                        }
>                        Else
>                        {
>                            Store (0x00, \_SB.PCI0.PIB.EC0.ACIN)
>                            Store (\_SB.PCI0.PIB.EC0.ACIN, \_SB.PCI0.PIB.EC0.ACFK)
>                        }
>
>                        Store (0x00, FST)
>                    }
>
>                    If (LNot (AFST))
>                    {
>                        Store ("INIT BATO in acad.psr", Debug)
>                        Store ("INIT BATO in acad.psr", Debug)
>                        Store (0x01, AFST)
>                        And (\_SB.PCI0.PIB.EC0.BATO, 0x3F, \_SB.PCI0.PIB.EC0.BATO)
>                        If (\_SB.PCI0.PIB.EC0.ACIN)
>                        {
>                            Or (\_SB.PCI0.PIB.EC0.BATO, 0xC0, \_SB.PCI0.PIB.EC0.BATO)
>                        }
>
>                        Store (0x01, AFST)
>                    }
>                }
>
>                Store (\_SB.PCI0.PIB.EC0.ACFK, Local0)
>                If (LNot (LEqual (\_SB.PCI0.PIB.EC0.ACFK, \_SB.PCI0.PIB.EC0.ACIN)))
>                {
>                    Store (\_SB.PCI0.PIB.EC0.ACIN, \_SB.PCI0.PIB.EC0.ACFK)
>                    Notify (\_SB.ACAD, 0x00)
>                }
>
>                Store (\_SB.PCI0.PIB.EC0.ACIN, Local0)
>                Return (Local0)
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0B)
>            }
>        }
>
>        Method (VTOB, 1, NotSerialized)
>        {
>            Store (0x01, Local0)
>            ShiftLeft (Local0, Arg0, Local0)
>            Return (Local0)
>        }
>
>        Method (BTOV, 1, NotSerialized)
>        {
>            ShiftRight (Arg0, 0x01, Local0)
>            Store (0x00, Local1)
>            While (Local0)
>            {
>                Increment (Local1)
>                ShiftRight (Local0, 0x01, Local0)
>            }
>
>            Return (Local1)
>        }
>
>        Method (MKWD, 2, NotSerialized)
>        {
>            If (And (Arg1, 0x80))
>            {
>                Store (0xFFFF0000, Local0)
>            }
>            Else
>            {
>                Store (Zero, Local0)
>            }
>
>            Or (Local0, Arg0, Local0)
>            Or (Local0, ShiftLeft (Arg1, 0x08), Local0)
>            Return (Local0)
>        }
>
>        Method (GBFE, 3, NotSerialized)
>        {
>            CreateByteField (Arg0, Arg1, TIDX)
>            Store (TIDX, Arg2)
>        }
>
>        Method (PBFE, 3, NotSerialized)
>        {
>            CreateByteField (Arg0, Arg1, TIDX)
>            Store (Arg2, TIDX)
>        }
>
>        Name (CHAR, Package (0x10)
>        {
>            "0", 
>            "1", 
>            "2", 
>            "3", 
>            "4", 
>            "5", 
>            "6", 
>            "7", 
>            "8", 
>            "9", 
>            "A", 
>            "B", 
>            "C", 
>            "D", 
>            "E", 
>            "F"
>        })
>        Method (ITOS, 2, NotSerialized)
>        {
>            Store ("", Local0)
>            Store (Arg1, Local1)
>            While (Local1)
>            {
>                Decrement (Local1)
>                And (ShiftRight (Arg0, ShiftLeft (Local1, 0x02)), 0x0F, Local4)
>                Store (DerefOf (Index (CHAR, Local4)), Local2)
>                Concatenate (Local0, Local2, Local5)
>                Store (Local5, Local0)
>            }
>
>            Return (Local0)
>        }
>
>        Device (BAT1)
>        {
>            Name (_HID, EisaId ("PNP0C0A"))
>            Name (_PCL, Package (0x01)
>            {
>                \_SB
>            })
>            Name (BFST, 0x00)
>            Name (PBIF, Package (0x0D)
>            {
>                0x00, 
>                0x1194, 
>                0x1194, 
>                0x01, 
>                0x2580, 
>                0x0154, 
>                0xAA, 
>                0x04, 
>                0x04, 
>                "4500", 
>                "00000000", 
>                "NIMH", 
>                " COMPAQ "
>            })
>            Name (PBST, Package (0x04)
>            {
>                0x00, 
>                0xFFFFFFFF, 
>                0x07D0, 
>                0x2710
>            })
>            Name (B1ST, 0x01)
>            Method (_STA, 0, NotSerialized)
>            {
>                If (\_SB.OKEC)
>                {
>                    If (B1ST)
>                    {
>                        Store (0x00, B1ST)
>                        \_SB.Z000 (0x8B)
>                        If (MBTS)
>                        {
>                            Store (0x1F, \_SB.PCI0.PIB.EC0.BTIN)
>                        }
>                        Else
>                        {
>                            Store (0x0F, \_SB.PCI0.PIB.EC0.BTIN)
>                        }
>                    }
>
>                    If (LNot (BFST))
>                    {
>                        Store ("INIT BATO at BAT1._STA", Debug)
>                        Store (0x01, BFST)
>                        And (\_SB.PCI0.PIB.EC0.BATO, 0xFE, \_SB.PCI0.PIB.EC0.BATO)
>                        If (LEqual (\_SB.PCI0.PIB.EC0.BTIN, 0x1F))
>                        {
>                            Or (\_SB.PCI0.PIB.EC0.BATO, 0x01, \_SB.PCI0.PIB.EC0.BATO)
>                        }
>                    }
>                }
>
>                Return (\_SB.PCI0.PIB.EC0.BTIN)
>            }
>
>            Method (_BIF, 0, NotSerialized)
>            {
>                Return (PBIF)
>            }
>
>            Method (_BST, 0, NotSerialized)
>            {
>                If (\_SB.OKEC)
>                {
>                    If (MBTS)
>                    {
>                        If (LEqual (SMUP, 0x01))
>                        {
>                            Store (0x00, SMUP)
>                        }
>                        Else
>                        {
>                            \_SB.Z000 (0x8A)
>                            SEBS ()
>                        }
>                    }
>                    Else
>                    {
>                        IVBS ()
>                    }
>                }
>
>                Store (0xFFFFFFFF, Index (PBST, 0x01))
>                Return (PBST)
>            }
>
>            Name (UBIF, 0x01E9)
>            Method (UPBI, 0, NotSerialized)
>            {
>                Store ("========= BAT1 UPBI =========", Debug)
>                Store (Zero, Local0)
>                Store (0x0C, Local1)
>                Store (Buffer (0x0D)
>                    {
>                        0x00, 0x18, 0x10, 0x00, 0x19, 0x00, 0x00, 0x00, 
>                        0x00, 0x00, 0x1C, 0x22, 0x00
>                    }, Local2)
>                While (LGreater (Local1, 0x0A))
>                {
>                    If (LNot (And (UBIF, VTOB (Local1))))
>                    {
>                        GBFE (Local2, Local1, RefOf (Local3))
>                        If (Local3)
>                        {
>                            If (LNot (\_SB.PCI0.PIB.EC0.SMRD (0x0B, 0x16, Local3, RefOf (Local4))))
>                            {
>                                GBFE (Local4, 0x20, RefOf (Local5))
>                                PBFE (Local4, Local5, 0x00)
>                                Store (Local4, Index (PBIF, Local1))
>                                Or (UBIF, VTOB (Local1), UBIF)
>                                Store (Ones, Local0)
>                            }
>                        }
>                    }
>
>                    Decrement (Local1)
>                }
>
>                If (LEqual (Local1, 0x0A))
>                {
>                    If (LNot (And (UBIF, VTOB (Local1))))
>                    {
>                        GBFE (Local2, Local1, RefOf (Local3))
>                        If (Local3)
>                        {
>                            If (LNot (\_SB.PCI0.PIB.EC0.SMRD (0x09, 0x16, Local3, RefOf (Local5))))
>                            {
>                                Store (ITOS (ToBCD (Local5), 0x08), Index (PBIF, Local1))
>                                Or (UBIF, VTOB (Local1), UBIF)
>                                Store (Ones, Local0)
>                            }
>                        }
>                    }
>
>                    Decrement (Local1)
>                    Decrement (Local1)
>                }
>
>                While (LGreater (Local1, 0x00))
>                {
>                    If (LNot (And (UBIF, VTOB (Local1))))
>                    {
>                        GBFE (Local2, Local1, RefOf (Local3))
>                        If (Local3)
>                        {
>                            If (LNot (\_SB.PCI0.PIB.EC0.SMRD (0x09, 0x16, Local3, RefOf (Local5))))
>                            {
>                                Store (Local5, Index (PBIF, Local1))
>                                If (LEqual (Local1, 0x01))
>                                {
>                                    Store (ITOS (ToBCD (Local5), 0x04), Index (PBIF, 0x09))
>                                }
>
>                                If (LEqual (Local1, 0x02))
>                                {
>                                    Multiply (Local5, 0x0A, Local6)
>                                    Divide (Local6, 0x64, Local6, Local7)
>                                    Store (Local7, Index (PBIF, 0x05))
>                                    Multiply (Local5, 0x04, Local6)
>                                    Divide (Local6, 0x64, Local6, Local7)
>                                    Store (Local7, Index (PBIF, 0x06))
>                                }
>
>                                Or (UBIF, VTOB (Local1), UBIF)
>                                Store (Ones, Local0)
>                            }
>                        }
>                    }
>
>                    Decrement (Local1)
>                }
>
>                Store (" COMPAQ ", Index (PBIF, 0x0C))
>                Return (Local0)
>            }
>
>            Method (UPBS, 0, NotSerialized)
>            {
>                Store (Zero, Local0)
>                Store (0x03, Local1)
>                Store (Buffer (0x04)
>                    {
>                        0x00, 0x0A, 0x0F, 0x09
>                    }, Local2)
>                Store (Buffer (0x04)
>                    {
>                        0x01, 0x04, 0x04, 0x04
>                    }, Local7)
>                While (Local1)
>                {
>                    GBFE (Local2, Local1, RefOf (Local3))
>                    If (Local3)
>                    {
>                        If (LNot (\_SB.PCI0.PIB.EC0.SMRD (0x09, 0x16, Local3, RefOf (Local5))))
>                        {
>                            Store (Local5, Index (PBST, Local1))
>                        }
>                    }
>
>                    Decrement (Local1)
>                }
>
>                Store (0x00, Local0)
>                If (ACDF)
>                {
>                    If (LEqual (\_SB.PCI0.PIB.EC0.ACEV, 0x01))
>                    {
>                        Store ("---ACEV Set Power State as charging", Debug)
>                        Or (0x02, Local0, Local0)
>                        Store (0x00, \_SB.PCI0.PIB.EC0.ACEV)
>                    }
>                    Else
>                    {
>                        Store ("---NO ACEV check charging/discharge ", Debug)
>                        If (LEqual (MBTC, 0x01))
>                        {
>                            Store ("---NO ACEV Set Power State as charging", Debug)
>                            Or (0x02, Local0, Local0)
>                        }
>
>                        If (LEqual (MBTD, 0x01))
>                        {
>                            Store ("---NO ACEV Set Power State as discharging", Debug)
>                            Or (0x01, Local0, Local0)
>                        }
>                    }
>                }
>                Else
>                {
>                    Store ("---Set Power State as discharging", Debug)
>                    Or (0x01, Local0, Local0)
>                }
>
>                Store (Local0, Index (PBST, 0x00))
>            }
>
>            Method (IVBI, 0, NotSerialized)
>            {
>                Name (UBIF, 0x01E9)
>                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 (0xFFFFFFFF, Index (PBST, 0x02))
>                Store (0x2710, Index (PBST, 0x03))
>            }
>
>            Method (SEBS, 0, NotSerialized)
>            {
>                Store (0x00, Local0)
>                If (ACDF)
>                {
>                    If (LEqual (MBTC, 0x01))
>                    {
>                        Or (0x02, Local0, Local0)
>                    }
>
>                    If (LEqual (MBTD, 0x01))
>                    {
>                        Or (0x01, Local0, Local0)
>                    }
>                }
>                Else
>                {
>                    Or (0x01, Local0, Local0)
>                }
>
>                Store (Local0, Index (PBST, 0x00))
>                Store (MBRM, Index (PBST, 0x02))
>                Store (0x2AF8, Index (PBST, 0x03))
>                Store (0xFFFFFFFF, Index (PBST, 0x01))
>            }
>
>            Name (SMUP, 0x00)
>            Method (SEBI, 0, NotSerialized)
>            {
>                If (MBTS)
>                {
>                    UPBI ()
>                    UPBS ()
>                    Store (0x01, SMUP)
>                }
>                Else
>                {
>                    IVBI ()
>                    IVBS ()
>                }
>            }
>        }
>
>        Device (LID)
>        {
>            Name (_HID, EisaId ("PNP0C0D"))
>            Method (_LID, 0, NotSerialized)
>            {
>                If (LNot (LEqual (\_SB.PCI0.MYOS, 0x02)))
>                {
>                    If (\_SB.PCI0.PM.LIDI)
>                    {
>                        Store (0x01, \_SB.PCI0.PM.DISP)
>                    }
>                    Else
>                    {
>                        Store (0x00, \_SB.PCI0.PM.DISP)
>                    }
>                }
>
>                Return (\_SB.PCI0.PM.LIDI)
>            }
>
>            Name (_PRW, Package (0x02)
>            {
>                0x0B, 
>                0x01
>            })
>        }
>
>        Device (PCI0)
>        {
>            Name (MYOS, 0x02)
>            Method (_INI, 0, NotSerialized)
>            {
>                Store (0x02, MYOS)
>                If (LEqual (SizeOf (\_OS), 0x14))
>                {
>                    Store (0x01, MYOS)
>                }
>
>                If (LEqual (SizeOf (\_OS), 0x11))
>                {
>                    Store (0x00, MYOS)
>                }
>
>                If (LEqual (SizeOf (\_OS), 0x27))
>                {
>                    Store (0x03, MYOS)
>                }
>            }
>
>            Name (_HID, EisaId ("PNP0A03"))
>            Name (_ADR, 0x00)
>            Name (_BBN, 0x00)
>            Name (_PRW, Package (0x02)
>            {
>                0x05, 
>                0x01
>            })
>            OperationRegion (NB00, PCI_Config, 0x00, 0x0100)
>            Field (NB00, ByteAcc, NoLock, Preserve)
>            {
>                Offset (0x5F), 
>                EADD,   8, 
>                Offset (0xF1), 
>                SDCS,   8, 
>                CRTS,   1
>            }
>
>            Method (_STA, 0, NotSerialized)
>            {
>                Return (0x0F)
>            }
>
>            Name (CRES, ResourceTemplate ()
>            {
>                WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
>                    0x0000,
>                    0x0000,
>                    0x00FF,
>                    0x0000,
>                    0x0100)
>                IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
>                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x0000,
>                    0x0000,
>                    0x0CF7,
>                    0x0000,
>                    0x0CF8)
>                WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
>                    0x0000,
>                    0x0D00,
>                    0xFFFF,
>                    0x0000,
>                    0xF300)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000,
>                    0x000A0000,
>                    0x000BFFFF,
>                    0x00000000,
>                    0x00020000)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
>                    0x00000000,
>                    0x000C8000,
>                    0x000DFFFF,
>                    0x00000000,
>                    0x00018000)
>                DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
>                    0x00000000,
>                    0x02000000,
>                    0xFFDFFFFF,
>                    0x00000000,
>                    0xFDE00000)
>            })
>            Method (_CRS, 0, NotSerialized)
>            {
>                CreateDWordField (CRES, 0x76, RAMT)
>                CreateDWordField (CRES, 0x82, RAMR)
>                Multiply (\_SB.PCI0.EADD, 0x00800000, Local0)
>                Store (Local0, RAMT)
>                Subtract (0xFFE00000, RAMT, RAMR)
>                Return (CRES)
>            }
>
>            Name (_PRT, Package (0x08)
>            {
>                Package (0x04)
>                {
>                    0x0001FFFF, 
>                    0x00, 
>                    \_SB.PCI0.PIB.LNKA, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0007FFFF, 
>                    0x00, 
>                    \_SB.PCI0.PIB.LNKA, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0007FFFF, 
>                    0x01, 
>                    \_SB.PCI0.PIB.LNKB, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0007FFFF, 
>                    0x02, 
>                    \_SB.PCI0.PIB.LNKC, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0007FFFF, 
>                    0x03, 
>                    \_SB.PCI0.PIB.LNKD, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x000AFFFF, 
>                    0x00, 
>                    \_SB.PCI0.PIB.LNKD, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0009FFFF, 
>                    0x00, 
>                    \_SB.PCI0.PIB.LNKB, 
>                    0x00
>                }, 
>
>                Package (0x04)
>                {
>                    0x0009FFFF, 
>                    0x01, 
>                    \_SB.PCI0.PIB.LNKC, 
>                    0x00
>                }
>            })
>            Device (AGP)
>            {
>                Name (_ADR, 0x00010000)
>                Device (VGA)
>                {
>                    Name (_ADR, 0x00)
>                    Name (DOSA, 0x01)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Method (_INI, 0, NotSerialized)
>                    {
>                        \_SB.Z000 (0x85)
>                        \_SB.Z000 (0x86)
>                        Store (\_SB.PCI0.SDCS, Local0)
>                        Store (Local0, Local1)
>                        And (Local1, 0x01, Local1)
>                        ShiftLeft (Local1, 0x01, Local1)
>                        And (^LCD._DCS, 0xFFFFFFFD, ^LCD._DCS)
>                        Or (^LCD._DCS, Local1, ^LCD._DCS)
>                        Store (Local0, Local1)
>                        And (Local1, 0x02, Local1)
>                        And (^CRT._DCS, 0xFFFFFFFD, ^CRT._DCS)
>                        Or (^CRT._DCS, Local1, ^CRT._DCS)
>                        EDGS ()
>                    }
>
>                    Method (_DOS, 1, NotSerialized)
>                    {
>                        Store (Arg0, DOSA)
>                    }
>
>                    Name (LDCS, 0x00)
>                    Name (CDCS, 0x00)
>                    Method (DRUU, 1, NotSerialized)
>                    {
>                        If (LEqual (Arg0, 0x00))
>                        {
>                            \_SB.Z000 (0x86)
>                            Store (0x00, ^LCD._DGS)
>                            Store (0x01, ^CRT._DGS)
>                            Notify (VGA, 0x80)
>                        }
>                        Else
>                        {
>                            Store (\_SB.PCI0.SDCS, Local0)
>                            Store (Local0, Local1)
>                            And (Local1, 0x01, Local1)
>                            And (^LCD._DGS, 0xFFFFFFFE, ^LCD._DGS)
>                            Or (^LCD._DGS, Local1, ^LCD._DGS)
>                            ShiftLeft (Local1, 0x01, Local1)
>                            And (^LCD._DCS, 0xFFFFFFFD, ^LCD._DCS)
>                            Or (^LCD._DCS, Local1, ^LCD._DCS)
>                            Store (Local0, Local1)
>                            And (Local1, 0x02, Local1)
>                            And (^CRT._DCS, 0xFFFFFFFD, ^CRT._DCS)
>                            Or (^CRT._DCS, Local1, ^CRT._DCS)
>                            ShiftRight (Local1, 0x01, Local1)
>                            And (^CRT._DGS, 0xFFFFFFFE, ^CRT._DGS)
>                            Or (^CRT._DGS, Local1, ^CRT._DGS)
>                            Notify (VGA, 0x80)
>                        }
>                    }
>
>                    Method (EDGS, 0, NotSerialized)
>                    {
>                        If (And (^LCD._DCS, 0x02))
>                        {
>                            If (And (^CRT._DCS, 0x02))
>                            {
>                                Store (0x00, ^LCD._DGS)
>                                Store (0x01, ^CRT._DGS)
>                            }
>                            Else
>                            {
>                                Store (0x01, ^LCD._DGS)
>                                Store (0x01, ^CRT._DGS)
>                            }
>                        }
>                        Else
>                        {
>                            Store (0x01, ^LCD._DGS)
>                            Store (0x00, ^CRT._DGS)
>                        }
>                    }
>
>                    Method (USTS, 0, NotSerialized)
>                    {
>                        And (^LCD._DCS, 0xFFFFFFFD, ^LCD._DCS)
>                        Or (^LCD._DCS, ShiftLeft (LDCS, 0x01), ^LCD._DCS)
>                        And (^CRT._DCS, 0xFFFFFFFD, ^CRT._DCS)
>                        If (And (CDCS, 0x01))
>                        {
>                            If (LEqual (\_SB.PCI0.CRTS, 0x01))
>                            {
>                                Or (^CRT._DCS, 0x02, ^CRT._DCS)
>                            }
>                        }
>
>                        EDGS ()
>                    }
>
>                    Method (SWIT, 0, NotSerialized)
>                    {
>                        USTS ()
>                    }
>
>                    Method (_DOD, 0, NotSerialized)
>                    {
>                        Return (Package (0x02)
>                        {
>                            0x00010100, 
>                            0x00010110
>                        })
>                    }
>
>                    Device (LCD)
>                    {
>                        Name (_ADR, 0x0110)
>                        Name (_DCS, 0x1F)
>                        Name (_DGS, 0x00)
>                        Method (_DSS, 1, NotSerialized)
>                        {
>                            If (And (Arg0, 0x40000000))
>                            {
>                                And (Arg0, 0x01, LDCS)
>                                If (And (Arg0, 0x80000000))
>                                {
>                                    ^^USTS ()
>                                }
>                            }
>                            Else
>                            {
>                                And (Arg0, 0x01, LDCS)
>                                If (And (Arg0, 0x80000000))
>                                {
>                                    ^^SWIT ()
>                                }
>                            }
>                        }
>                    }
>
>                    Device (CRT)
>                    {
>                        Name (_ADR, 0x0100)
>                        Name (_DGS, 0x00)
>                        Name (_DCS, 0x0F)
>                        Method (_DSS, 1, NotSerialized)
>                        {
>                            If (And (Arg0, 0x40000000))
>                            {
>                                And (Arg0, 0x01, CDCS)
>                                If (And (Arg0, 0x80000000))
>                                {
>                                    ^^USTS ()
>                                }
>                            }
>                            Else
>                            {
>                                And (Arg0, 0x01, CDCS)
>                                If (And (Arg0, 0x80000000))
>                                {
>                                    ^^SWIT ()
>                                }
>                            }
>                        }
>                    }
>                }
>            }
>
>            Device (PIB)
>            {
>                Name (_ADR, 0x00070000)
>                OperationRegion (IRQR, PCI_Config, 0x00, 0x88)
>                Field (IRQR, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x48), 
>                        ,   2, 
>                    EUSB,   1, 
>                    Offset (0x50), 
>                    FDDA,   2, 
>                    LPDA,   2, 
>                    Offset (0x51), 
>                    FDIQ,   4, 
>                    LPIQ,   4, 
>                    SAIQ,   4, 
>                    SBIQ,   4, 
>                    Offset (0x55), 
>                        ,   4, 
>                    PIRA,   4, 
>                    PIRB,   4, 
>                    PIRC,   4, 
>                        ,   4, 
>                    PIRD,   4, 
>                    Offset (0x81), 
>                    PDC1,   8, 
>                    PDC2,   8, 
>                    PDC3,   8, 
>                    PDC4,   8, 
>                    EXFE,   8
>                }
>
>                Device (DMA1)
>                {
>                    Name (_HID, EisaId ("PNP0200"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        DMA (Compatibility, BusMaster, Transfer8) {4}
>                        IO (Decode16, 0x0000, 0x0000, 0x01, 0x10)
>                        IO (Decode16, 0x0081, 0x0081, 0x01, 0x0F)
>                        IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20)
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>                }
>
>                Device (RTC)
>                {
>                    Name (_HID, EisaId ("PNP0B00"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode10, 0x0070, 0x0070, 0x01, 0x06)
>                        IRQNoFlags () {8}
>                    })
>                }
>
>                Device (PIC)
>                {
>                    Name (_HID, EisaId ("PNP0000"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0020, 0x0020, 0x01, 0x02)
>                        IO (Decode16, 0x00A0, 0x00A0, 0x01, 0x02)
>                        IRQNoFlags () {2}
>                    })
>                }
>
>                Device (COPR)
>                {
>                    Name (_HID, EisaId ("PNP0C04"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x00F0, 0x00F0, 0x01, 0x10)
>                        IRQNoFlags () {13}
>                    })
>                }
>
>                Device (TMR)
>                {
>                    Name (_HID, EisaId ("PNP0100"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0040, 0x0040, 0x01, 0x04)
>                        IRQNoFlags () {0}
>                    })
>                }
>
>                Device (SPKR)
>                {
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_HID, EisaId ("PNP0800"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0061, 0x0061, 0x01, 0x01)
>                    })
>                }
>
>                Device (MEM)
>                {
>                    Name (_HID, EisaId ("PNP0C01"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (SMEM, ResourceTemplate ()
>                        {
>                            Memory32Fixed (ReadWrite, 0x00000000, 0x000A0000)
>                            Memory32Fixed (ReadOnly, 0x000DC000, 0x00004000)
>                            Memory32Fixed (ReadOnly, 0x000E0000, 0x00020000)
>                            Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
>                        })
>                        Return (SMEM)
>                    }
>                }
>
>                Device (SYSR)
>                {
>                    Name (_HID, EisaId ("PNP0C02"))
>                    Name (_UID, 0x01)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
>                        IO (Decode16, 0x0080, 0x0080, 0x01, 0x01)
>                        IO (Decode16, 0x0092, 0x0092, 0x01, 0x01)
>                        IO (Decode16, 0x00A8, 0x00A8, 0x01, 0x02)
>                        IO (Decode16, 0x0220, 0x0220, 0x01, 0x10)
>                        IO (Decode16, 0x0388, 0x0388, 0x01, 0x04)
>                        IO (Decode16, 0x8000, 0x8000, 0x01, 0x90)
>                        IO (Decode16, 0x9050, 0x9050, 0x01, 0x02)
>                        IO (Decode16, 0x6800, 0x6800, 0x01, 0x80)
>                        IO (Decode16, 0x0370, 0x0370, 0x01, 0x02)
>                    })
>                }
>
>                Device (PS2M)
>                {
>                    Name (_HID, EisaId ("PNP0F13"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IRQNoFlags () {12}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>                }
>
>                Device (PS2K)
>                {
>                    Name (_HID, EisaId ("PNP0303"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0060, 0x0060, 0x01, 0x01)
>                        IO (Decode16, 0x0064, 0x0064, 0x01, 0x01)
>                        IRQNoFlags () {1}
>                    })
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x0F)
>                    }
>                }
>
>                Device (LNKA)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x01)
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {9,11,12}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (Zero, \_SB.PCI0.PIB.PIRA)
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.PIB.PIRA, 0x00))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUFA, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateByteField (BUFA, 0x01, IRA1)
>                        CreateByteField (BUFA, 0x02, IRA2)
>                        Store (\_SB.PCI0.PIB.PIRA, Local0)
>                        If (LGreater (Local0, 0x00))
>                        {
>                            If (LGreater (Local0, 0x07))
>                            {
>                                Subtract (Local0, 0x08, Local0)
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRA2)
>                            }
>                            Else
>                            {
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRA1)
>                            }
>                        }
>
>                        Return (BUFA)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x01, IRA1)
>                        CreateByteField (Arg0, 0x02, IRA2)
>                        If (LGreater (IRA2, Zero))
>                        {
>                            FindSetLeftBit (IRA2, Local0)
>                            Decrement (Local0)
>                            Add (Local0, 0x08, Local0)
>                        }
>                        Else
>                        {
>                            FindSetLeftBit (IRA1, Local0)
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, \_SB.PCI0.PIB.PIRA)
>                    }
>                }
>
>                Device (LNKB)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x02)
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {9,11,12}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (Zero, \_SB.PCI0.PIB.PIRB)
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.PIB.PIRB, 0x00))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUFB, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateByteField (BUFB, 0x01, IRB1)
>                        CreateByteField (BUFB, 0x02, IRB2)
>                        Store (\_SB.PCI0.PIB.PIRB, Local0)
>                        If (LGreater (Local0, 0x00))
>                        {
>                            If (LGreater (Local0, 0x07))
>                            {
>                                Subtract (Local0, 0x08, Local0)
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRB2)
>                            }
>                            Else
>                            {
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRB1)
>                            }
>                        }
>
>                        Return (BUFB)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x01, IRB1)
>                        CreateByteField (Arg0, 0x02, IRB2)
>                        If (LGreater (IRB2, Zero))
>                        {
>                            FindSetLeftBit (IRB2, Local0)
>                            Decrement (Local0)
>                            Add (Local0, 0x08, Local0)
>                        }
>                        Else
>                        {
>                            FindSetLeftBit (IRB1, Local0)
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, \_SB.PCI0.PIB.PIRB)
>                    }
>                }
>
>                Device (LNKC)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x03)
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {9,11,12}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (Zero, \_SB.PCI0.PIB.PIRC)
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.PIB.PIRC, 0x00))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUFC, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateByteField (BUFC, 0x01, IRC1)
>                        CreateByteField (BUFC, 0x02, IRC2)
>                        Store (\_SB.PCI0.PIB.PIRC, Local0)
>                        If (LGreater (Local0, 0x00))
>                        {
>                            If (LGreater (Local0, 0x07))
>                            {
>                                Subtract (Local0, 0x08, Local0)
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRC2)
>                            }
>                            Else
>                            {
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, IRC1)
>                            }
>                        }
>
>                        Return (BUFC)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x01, IRC1)
>                        CreateByteField (Arg0, 0x02, IRC2)
>                        If (LGreater (IRC2, Zero))
>                        {
>                            FindSetLeftBit (IRC2, Local0)
>                            Decrement (Local0)
>                            Add (Local0, 0x08, Local0)
>                        }
>                        Else
>                        {
>                            FindSetLeftBit (IRC1, Local0)
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, \_SB.PCI0.PIB.PIRC)
>                    }
>                }
>
>                Device (LNKD)
>                {
>                    Name (_HID, EisaId ("PNP0C0F"))
>                    Name (_UID, 0x04)
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        IRQ (Level, ActiveLow, Shared) {9,11,12}
>                    })
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        Store (Zero, \_SB.PCI0.PIB.PIRD)
>                    }
>
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.PIB.PIRD, 0x00))
>                        {
>                            Return (0x09)
>                        }
>                        Else
>                        {
>                            Return (0x0B)
>                        }
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUFD, ResourceTemplate ()
>                        {
>                            IRQ (Level, ActiveLow, Shared) {}
>                        })
>                        CreateByteField (BUFD, 0x01, IRD1)
>                        CreateByteField (BUFD, 0x02, IRD2)
>                        Store (\_SB.PCI0.PIB.PIRD, Local0)
>                        If (LGreater (Local0, 0x00))
>                        {
>                            If (LGreater (Local0, 0x07))
>                            {
>                                Subtract (Local0, 0x08, Local2)
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local2, Local3)
>                                Store (Local3, IRD2)
>                            }
>                            Else
>                            {
>                                Store (0x01, Local1)
>                                ShiftLeft (Local1, Local0, Local2)
>                                Store (Local2, IRD1)
>                            }
>                        }
>
>                        Return (BUFD)
>                    }
>
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x01, IRD1)
>                        CreateByteField (Arg0, 0x02, IRD2)
>                        If (LGreater (IRD2, Zero))
>                        {
>                            FindSetLeftBit (IRD2, Local0)
>                            Decrement (Local0)
>                            Add (Local0, 0x08, Local0)
>                        }
>                        Else
>                        {
>                            FindSetLeftBit (IRD1, Local0)
>                            Decrement (Local0)
>                        }
>
>                        Store (Local0, \_SB.PCI0.PIB.PIRD)
>                    }
>                }
>
>                OperationRegion (VSIO, SystemIO, 0x03F0, 0x02)
>                Field (VSIO, ByteAcc, NoLock, Preserve)
>                {
>                    INDV,   8, 
>                    DATV,   8
>                }
>
>                IndexField (INDV, DATV, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0xE2), 
>                    CRE2,   8, 
>                    CRE3,   8, 
>                    Offset (0xE6), 
>                    CRE6,   8, 
>                    CRE7,   8, 
>                    CRE8,   8, 
>                    Offset (0xEE), 
>                    CREE,   8
>                }
>
>                Method (ENCG, 0, NotSerialized)
>                {
>                    Store (\_SB.PCI0.PIB.EXFE, Local0)
>                    Or (Local0, 0x02, Local0)
>                    Store (Local0, \_SB.PCI0.PIB.EXFE)
>                }
>
>                Method (EXCG, 0, NotSerialized)
>                {
>                    Store (\_SB.PCI0.PIB.EXFE, Local0)
>                    And (Local0, 0xFD, Local0)
>                    Store (Local0, \_SB.PCI0.PIB.EXFE)
>                }
>
>                Name (PIOM, Buffer (0x01)
>                {
>                    0x00
>                })
>                CreateByteField (PIOM, 0x00, LPTM)
>                Device (FDC0)
>                {
>                    Name (_HID, EisaId ("PNP0700"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Store (\_SB.PCI0.PIB.EXFE, Local1)
>                        And (Local1, 0x01, Local1)
>                        If (Local1)
>                        {
>                            ENCG ()
>                            Store (CRE2, Local0)
>                            EXCG ()
>                            And (Local0, 0x10, Local0)
>                            If (LEqual (Local0, 0x00))
>                            {
>                                Return (0x0D)
>                            }
>                            Else
>                            {
>                                Return (0x0F)
>                            }
>                        }
>                        Else
>                        {
>                            Return (0x00)
>                        }
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENCG ()
>                        Store (Zero, CRE3)
>                        Store (CRE2, Local0)
>                        And (Local0, 0xEF, Local0)
>                        Store (Local0, CRE2)
>                        EXCG ()
>                        Store (Zero, \_SB.PCI0.PIB.FDIQ)
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (RSRC, ResourceTemplate ()
>                        {
>                            IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x00)
>                            IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x00)
>                            IRQNoFlags () {6}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                        })
>                        If (LEqual (_STA (), 0x0F))
>                        {
>                            CreateByteField (RSRC, 0x02, IOLO)
>                            CreateByteField (RSRC, 0x03, IOHI)
>                            CreateByteField (RSRC, 0x04, IORL)
>                            CreateByteField (RSRC, 0x05, IORH)
>                            CreateByteField (RSRC, 0x07, IOLN)
>                            CreateByteField (RSRC, 0x0A, DALO)
>                            CreateByteField (RSRC, 0x0B, DAHI)
>                            CreateByteField (RSRC, 0x0C, DRLO)
>                            CreateByteField (RSRC, 0x0D, DRHI)
>                            CreateByteField (RSRC, 0x0F, DRLN)
>                            CreateByteField (RSRC, 0x11, IRQL)
>                            CreateByteField (RSRC, 0x14, DMAV)
>                            ENCG ()
>                            Store (CRE3, Local1)
>                            EXCG ()
>                            If (LEqual (Local1, 0xDC))
>                            {
>                                Store (0x70, IOLO)
>                                Store (0x03, IOHI)
>                                Store (IOLO, IORL)
>                                Store (IOHI, IORH)
>                                Store (0x77, DALO)
>                                Store (0x03, DAHI)
>                                Store (DALO, DRLO)
>                                Store (DAHI, DRHI)
>                            }
>
>                            Store (0x06, IOLN)
>                            Store (0x01, DRLN)
>                            Store (\_SB.PCI0.PIB.FDIQ, Local0)
>                            Store (0x01, Local1)
>                            ShiftLeft (Local1, Local0, Local2)
>                            And (Local2, 0xFE, Local2)
>                            Store (Local2, IRQL)
>                            Store (\_SB.PCI0.PIB.FDDA, Local0)
>                            Store (0x01, Local1)
>                            ShiftLeft (Local1, Local0, DMAV)
>                        }
>
>                        Return (RSRC)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06)
>                            IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01)
>                            IRQNoFlags () {6}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0370, 0x0370, 0x01, 0x06)
>                            IO (Decode16, 0x0377, 0x0377, 0x01, 0x01)
>                            IRQNoFlags () {6}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {2}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x02, IOLO)
>                        CreateByteField (Arg0, 0x03, IOHI)
>                        CreateWordField (Arg0, 0x11, IRQL)
>                        CreateByteField (Arg0, 0x14, DMAV)
>                        ENCG ()
>                        Store (CRE2, Local1)
>                        And (Local1, 0xEF, Local1)
>                        Store (Local1, CRE2)
>                        If (LEqual (IOLO, 0xF0))
>                        {
>                            Store (0xF0, Local0)
>                        }
>                        Else
>                        {
>                            Store (0x70, Local0)
>                        }
>
>                        ShiftRight (Local0, 0x02, Local0)
>                        And (Local0, 0xFC, Local0)
>                        Store (IOHI, Local1)
>                        ShiftLeft (Local1, 0x06, Local1)
>                        Or (Local0, Local1, Local0)
>                        Store (Local0, CRE3)
>                        FindSetRightBit (IRQL, Local0)
>                        If (LEqual (Local0, 0x00))
>                        {
>                            Store (0x07, Local0)
>                            Store (0x07, IRQL)
>                        }
>
>                        Decrement (Local0)
>                        Store (Local0, \_SB.PCI0.PIB.FDIQ)
>                        FindSetRightBit (DMAV, Local0)
>                        If (LEqual (Local0, 0x00))
>                        {
>                            Store (0x03, Local0)
>                            Store (0x03, DMAV)
>                        }
>
>                        Decrement (Local0)
>                        Store (Local0, \_SB.PCI0.PIB.FDDA)
>                        Store (CRE2, Local1)
>                        Or (Local1, 0x10, Local1)
>                        Store (Local1, CRE2)
>                        EXCG ()
>                    }
>                }
>
>                OperationRegion (SMC1, SystemIO, 0x0370, 0x02)
>                Field (SMC1, ByteAcc, NoLock, Preserve)
>                {
>                    INDX,   8, 
>                    DATA,   8
>                }
>
>                Method (ENFG, 0, NotSerialized)
>                {
>                    Store (0x55, INDX)
>                }
>
>                Method (EXFG, 0, NotSerialized)
>                {
>                    Store (0xAA, INDX)
>                }
>
>                Device (UAR1)
>                {
>                    Name (_HID, EisaId ("PNP0501"))
>                    Name (_UID, 0x01)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x24, INDX)
>                        Store (DATA, Local0)
>                        Store (0x28, INDX)
>                        Store (DATA, Local1)
>                        And (Local1, 0xF0, Local1)
>                        If (LNot (LEqual (Local1, 0x00)))
>                        {
>                            If (LNot (LEqual (Local0, 0x00)))
>                            {
>                                EXFG ()
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                EXFG ()
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            EXFG ()
>                            Return (0x00)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x24, INDX)
>                        Store (DATA, Local0)
>                        Store (0x24, INDX)
>                        And (Local0, 0x00, DATA)
>                        EXFG ()
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUF1, ResourceTemplate ()
>                        {
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x08)
>                            IRQNoFlags () {}
>                        })
>                        CreateByteField (BUF1, 0x02, IOLO)
>                        CreateByteField (BUF1, 0x03, IOHI)
>                        CreateByteField (BUF1, 0x04, IORL)
>                        CreateByteField (BUF1, 0x05, IORH)
>                        CreateWordField (BUF1, 0x09, IRQL)
>                        ENFG ()
>                        Store (0x24, INDX)
>                        Store (DATA, Local0)
>                        If (LEqual (Local0, 0xFE))
>                        {
>                            Store (0xF8, IOLO)
>                            Store (0xF8, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                        }
>
>                        If (LEqual (Local0, 0xBE))
>                        {
>                            Store (0xF8, IOLO)
>                            Store (0xF8, IORL)
>                            Store (0x02, IOHI)
>                            Store (0x02, IORH)
>                        }
>
>                        If (LEqual (Local0, 0xFA))
>                        {
>                            Store (0xE8, IOLO)
>                            Store (0xE8, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                        }
>
>                        If (LEqual (Local0, 0xBA))
>                        {
>                            Store (0xE8, IOLO)
>                            Store (0xE8, IORL)
>                            Store (0x02, IOHI)
>                            Store (0x02, IORH)
>                        }
>
>                        Store (0x28, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        ShiftRight (Local0, 0x04, Local0)
>                        Store (0x01, IRQL)
>                        ShiftLeft (IRQL, Local0, IRQL)
>                        EXFG ()
>                        Return (BUF1)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
>                            IRQNoFlags () {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x00, 0x08)
>                            IRQNoFlags () {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x00, 0x08)
>                            IRQNoFlags () {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x00, 0x08)
>                            IRQNoFlags () {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x02, IOLO)
>                        CreateByteField (Arg0, 0x03, IOHI)
>                        CreateWordField (Arg0, 0x09, IRQL)
>                        ENFG ()
>                        If (LEqual (IOLO, 0xF8))
>                        {
>                            If (LEqual (IOHI, 0x03))
>                            {
>                                Store (0xFE, Local0)
>                            }
>                            Else
>                            {
>                                Store (0xBE, Local0)
>                            }
>                        }
>                        Else
>                        {
>                            If (LEqual (IOHI, 0x03))
>                            {
>                                Store (0xFA, Local0)
>                            }
>                            Else
>                            {
>                                Store (0xBA, Local0)
>                            }
>                        }
>
>                        Store (0x24, INDX)
>                        Store (Local0, DATA)
>                        Store (0x28, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        If (LEqual (IRQL, 0x00))
>                        {
>                            Store (0x00, Local1)
>                        }
>                        Else
>                        {
>                            FindSetRightBit (IRQL, Local1)
>                            Subtract (Local1, 0x01, Local1)
>                        }
>
>                        ShiftLeft (Local1, 0x04, Local1)
>                        Or (Local1, Local0, Local0)
>                        Store (0x28, INDX)
>                        Store (Local0, DATA)
>                        EXFG ()
>                    }
>                }
>
>                Device (FRIO)
>                {
>                    Name (_HID, EisaId ("PNP0C02"))
>                    Name (_UID, 0x02)
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x02, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x80, Local0)
>                        Store (0x2B, INDX)
>                        Store (DATA, Local1)
>                        Store (0x2C, INDX)
>                        And (DATA, 0x0F, Local2)
>                        If (LEqual (Local0, 0x80))
>                        {
>                            If (LNot (LEqual (Local2, 0x0F)))
>                            {
>                                If (LNot (LEqual (Local1, 0x00)))
>                                {
>                                    EXFG ()
>                                    Return (0x0F)
>                                }
>                                Else
>                                {
>                                    EXFG ()
>                                    Return (0x00)
>                                }
>                            }
>                            Else
>                            {
>                                EXFG ()
>                                Return (0x00)
>                            }
>                        }
>                        Else
>                        {
>                            EXFG ()
>                            Return (0x00)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0958, 0x0958, 0x01, 0x18)
>                    })
>                }
>
>                Device (FIR)
>                {
>                    Name (_HID, EisaId ("SMCF010"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x0C, INDX)
>                        Store (0x0E, DATA)
>                        Store (0x0A, INDX)
>                        Store (0x40, DATA)
>                        Store (0x02, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x80, Local0)
>                        Store (0x2C, INDX)
>                        Store (DATA, Local1)
>                        And (Local1, 0x0F, Local1)
>                        Store (0x25, INDX)
>                        Store (DATA, Local3)
>                        If (LEqual (Local0, 0x80))
>                        {
>                            If (LNot (LEqual (Local1, 0x0F)))
>                            {
>                                If (LNot (LEqual (Local3, 0x00)))
>                                {
>                                    EXFG ()
>                                    Return (0x0F)
>                                }
>                                Else
>                                {
>                                    EXFG ()
>                                    Return (0x0D)
>                                }
>                            }
>                            Else
>                            {
>                                EXFG ()
>                                Return (0x00)
>                            }
>                        }
>                        Else
>                        {
>                            EXFG ()
>                            Return (0x00)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUF2, ResourceTemplate ()
>                        {
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x08)
>                            IRQNoFlags () {}
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x08)
>                            DMA (Compatibility, NotBusMaster, Transfer8) {}
>                        })
>                        CreateByteField (BUF2, 0x02, IOLL)
>                        CreateByteField (BUF2, 0x03, IOLH)
>                        CreateByteField (BUF2, 0x04, IOHL)
>                        CreateByteField (BUF2, 0x05, IOHH)
>                        CreateByteField (BUF2, 0x0D, IRC1)
>                        CreateByteField (BUF2, 0x0E, IRC2)
>                        CreateByteField (BUF2, 0x0F, IRC3)
>                        CreateByteField (BUF2, 0x10, IRC4)
>                        CreateWordField (BUF2, 0x09, IRQL)
>                        CreateByteField (BUF2, 0x14, DMAC)
>                        ENFG ()
>                        Store (0x25, INDX)
>                        Store (DATA, Local0)
>                        ShiftLeft (Local0, 0x02, Local0)
>                        Store (Local0, Local1)
>                        And (Local0, 0xFF, Local0)
>                        ShiftRight (Local1, 0x08, Local1)
>                        Store (Local0, IOLL)
>                        Store (Local0, IOHL)
>                        Store (Local1, IOLH)
>                        Store (Local1, IOHH)
>                        Store (0x2B, INDX)
>                        Store (DATA, Local0)
>                        If (LEqual (Local0, 0x2B))
>                        {
>                            Store (0x58, IRC1)
>                            Store (0x58, IRC3)
>                            Store (0x01, IRC2)
>                            Store (0x01, IRC4)
>                        }
>
>                        If (LEqual (Local0, 0x2C))
>                        {
>                            Store (0x60, IRC1)
>                            Store (0x60, IRC3)
>                            Store (0x01, IRC2)
>                            Store (0x01, IRC4)
>                        }
>
>                        If (LEqual (Local0, 0x2D))
>                        {
>                            Store (0x68, IRC1)
>                            Store (0x68, IRC3)
>                            Store (0x01, IRC2)
>                            Store (0x01, IRC4)
>                        }
>
>                        Store (0x2C, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        If (LEqual (Local0, 0x00))
>                        {
>                            Store (0x02, DMAC)
>                        }
>
>                        If (LEqual (Local0, 0x02))
>                        {
>                            Store (0x08, DMAC)
>                        }
>
>                        If (LEqual (Local0, 0x03))
>                        {
>                            Store (0x01, DMAC)
>                        }
>
>                        Store (0x28, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        Store (0x01, IRQL)
>                        ShiftLeft (IRQL, Local0, IRQL)
>                        EXFG ()
>                        Return (BUF2)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03F8, 0x03F8, 0x00, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02F8, 0x02F8, 0x00, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03E8, 0x03E8, 0x00, 0x08)
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x02E8, 0x02E8, 0x00, 0x08)
>                        }
>                        EndDependentFn ()
>                        IRQNoFlags () {3,4}
>                        IO (Decode16, 0x0158, 0x016F, 0x08, 0x08)
>                        DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3}
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateWordField (Arg0, 0x02, IOLP)
>                        CreateWordField (Arg0, 0x0D, IRPO)
>                        CreateWordField (Arg0, 0x09, IRQL)
>                        CreateByteField (Arg0, 0x14, DMAC)
>                        ENFG ()
>                        Store (0x02, INDX)
>                        Store (DATA, Local0)
>                        Store (0x02, INDX)
>                        Or (Local0, 0x80, DATA)
>                        Store (0x25, INDX)
>                        ShiftRight (IOLP, 0x02, DATA)
>                        Store (0x2B, INDX)
>                        ShiftRight (IRPO, 0x03, DATA)
>                        Store (0x2C, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        If (LEqual (DMAC, 0x01))
>                        {
>                            Or (Local0, 0x03, Local0)
>                        }
>
>                        If (LEqual (DMAC, 0x02))
>                        {
>                            Or (Local0, 0x00, Local0)
>                        }
>
>                        If (LEqual (DMAC, 0x08))
>                        {
>                            Or (Local0, 0x02, Local0)
>                        }
>
>                        Store (0x2C, INDX)
>                        Store (Local0, DATA)
>                        Store (0x28, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        FindSetRightBit (IRQL, Local1)
>                        Subtract (Local1, 0x01, Local1)
>                        Or (Local1, Local0, Local0)
>                        Store (0x28, INDX)
>                        Store (Local0, DATA)
>                        EXFG ()
>                    }
>                }
>
>                Device (LPT1)
>                {
>                    Name (_HID, EisaId ("PNP0400"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x04, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x02, Local0)
>                        If (LEqual (Local0, 0x00))
>                        {
>                            Store (0x23, INDX)
>                            Store (DATA, Local0)
>                            Store (0x01, INDX)
>                            Store (DATA, Local1)
>                            And (Local1, 0x04, Local1)
>                            If (LNot (LEqual (Local1, 0x00)))
>                            {
>                                If (LNot (LEqual (Local0, 0x00)))
>                                {
>                                    EXFG ()
>                                    Return (0x0F)
>                                }
>                                Else
>                                {
>                                    EXFG ()
>                                    Return (0x0D)
>                                }
>                            }
>                            Else
>                            {
>                                EXFG ()
>                                Return (0x00)
>                            }
>                        }
>                        Else
>                        {
>                            EXFG ()
>                            Return (0x00)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x23, INDX)
>                        Store (0x00, DATA)
>                        EXFG ()
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUF4, ResourceTemplate ()
>                        {
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x08)
>                            IRQNoFlags () {}
>                        })
>                        CreateByteField (BUF4, 0x02, IOLO)
>                        CreateByteField (BUF4, 0x03, IOHI)
>                        CreateByteField (BUF4, 0x04, IORL)
>                        CreateByteField (BUF4, 0x05, IORH)
>                        CreateByteField (BUF4, 0x07, IOLN)
>                        CreateWordField (BUF4, 0x09, IRQL)
>                        ENFG ()
>                        Store (0x23, INDX)
>                        Store (DATA, Local0)
>                        If (LEqual (Local0, 0xDE))
>                        {
>                            Store (0x78, IOLO)
>                            Store (0x78, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                            Store (0x08, IOLN)
>                        }
>
>                        If (LEqual (Local0, 0x9E))
>                        {
>                            Store (0x78, IOLO)
>                            Store (0x78, IORL)
>                            Store (0x02, IOHI)
>                            Store (0x02, IORH)
>                            Store (0x08, IOLN)
>                        }
>
>                        If (LEqual (Local0, 0xEF))
>                        {
>                            Store (0xBC, IOLO)
>                            Store (0xBC, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                            Store (0x04, IOLN)
>                        }
>
>                        Store (0x27, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        If (LNot (LEqual (Local0, 0x00)))
>                        {
>                            Store (0x01, IRQL)
>                            ShiftLeft (IRQL, Local0, IRQL)
>                        }
>                        Else
>                        {
>                            Store (Local0, IRQL)
>                        }
>
>                        EXFG ()
>                        Return (BUF4)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x00, 0x08)
>                            IRQNoFlags () {5,7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x00, 0x08)
>                            IRQNoFlags () {5,7}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x00, 0x04)
>                            IRQNoFlags () {5,7}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x02, IOLO)
>                        CreateByteField (Arg0, 0x03, IOHI)
>                        CreateWordField (Arg0, 0x09, IRQL)
>                        ENFG ()
>                        If (LEqual (IOLO, 0xBC))
>                        {
>                            Store (0xEF, Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (IOHI, 0x03))
>                            {
>                                Store (0xDE, Local0)
>                            }
>                            Else
>                            {
>                                If (LEqual (IOHI, 0x02))
>                                {
>                                    Store (0x9E, Local0)
>                                }
>                                Else
>                                {
>                                    Store (0x00, Local0)
>                                }
>                            }
>                        }
>
>                        If (LNot (LEqual (Local0, 0x00)))
>                        {
>                            Store (0x23, INDX)
>                            Store (Local0, DATA)
>                        }
>
>                        Store (0x27, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        If (LEqual (IRQL, 0x00))
>                        {
>                            Store (0x00, Local1)
>                        }
>                        Else
>                        {
>                            FindSetRightBit (IRQL, Local1)
>                            Subtract (Local1, 0x01, Local1)
>                        }
>
>                        Or (Local1, Local0, Local0)
>                        Store (0x27, INDX)
>                        Store (Local0, DATA)
>                        EXFG ()
>                    }
>                }
>
>                Device (ECP1)
>                {
>                    Name (_HID, EisaId ("PNP0401"))
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x04, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x02, Local0)
>                        If (LEqual (Local0, 0x02))
>                        {
>                            Store (0x23, INDX)
>                            Store (DATA, Local0)
>                            If (LNot (LEqual (Local0, 0x00)))
>                            {
>                                EXFG ()
>                                Return (0x0F)
>                            }
>                            Else
>                            {
>                                EXFG ()
>                                Return (0x0D)
>                            }
>                        }
>                        Else
>                        {
>                            EXFG ()
>                            Return (0x00)
>                        }
>
>                        EXFG ()
>                    }
>
>                    Method (_DIS, 0, NotSerialized)
>                    {
>                        ENFG ()
>                        Store (0x23, INDX)
>                        Store (0x00, DATA)
>                        EXFG ()
>                    }
>
>                    Method (_CRS, 0, NotSerialized)
>                    {
>                        Name (BUF6, ResourceTemplate ()
>                        {
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x08)
>                            IO (Decode16, 0x0000, 0x0000, 0x00, 0x04)
>                            IRQNoFlags () {}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {}
>                        })
>                        CreateByteField (BUF6, 0x02, IOLO)
>                        CreateByteField (BUF6, 0x03, IOHI)
>                        CreateByteField (BUF6, 0x04, IORL)
>                        CreateByteField (BUF6, 0x05, IORH)
>                        CreateByteField (BUF6, 0x07, IOLN)
>                        CreateByteField (BUF6, 0x0A, IOEL)
>                        CreateByteField (BUF6, 0x0B, IOEH)
>                        CreateByteField (BUF6, 0x0C, IOML)
>                        CreateByteField (BUF6, 0x0D, IOMH)
>                        CreateByteField (BUF6, 0x0F, IOHN)
>                        CreateWordField (BUF6, 0x11, IRQL)
>                        CreateByteField (BUF6, 0x14, DMAC)
>                        ENFG ()
>                        Store (0x23, INDX)
>                        Store (DATA, Local0)
>                        If (LEqual (Local0, 0xDE))
>                        {
>                            Store (0x78, IOLO)
>                            Store (0x78, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                            Store (0x08, IOLN)
>                        }
>
>                        If (LEqual (Local0, 0x9E))
>                        {
>                            Store (0x78, IOLO)
>                            Store (0x78, IORL)
>                            Store (0x02, IOHI)
>                            Store (0x02, IORH)
>                            Store (0x08, IOLN)
>                        }
>
>                        If (LEqual (Local0, 0xEF))
>                        {
>                            Store (0xBC, IOLO)
>                            Store (0xBC, IORL)
>                            Store (0x03, IOHI)
>                            Store (0x03, IORH)
>                            Store (0x04, IOLN)
>                        }
>
>                        Store (IOLO, IOEL)
>                        Store (IOLO, IOML)
>                        Or (IOHI, 0x04, IOEH)
>                        Or (IOHI, 0x04, IOMH)
>                        Store (0x27, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        Store (0x01, IRQL)
>                        ShiftLeft (IRQL, Local0, IRQL)
>                        Store (0x26, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0x0F, Local0)
>                        If (LEqual (Local0, 0x00))
>                        {
>                            Store (0x02, DMAC)
>                        }
>
>                        If (LEqual (Local0, 0x02))
>                        {
>                            Store (0x08, DMAC)
>                        }
>
>                        If (LEqual (Local0, 0x03))
>                        {
>                            Store (0x01, DMAC)
>                        }
>
>                        EXFG ()
>                        Return (BUF6)
>                    }
>
>                    Name (_PRS, ResourceTemplate ()
>                    {
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0378, 0x0378, 0x00, 0x08)
>                            IO (Decode16, 0x0778, 0x0778, 0x00, 0x04)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x0278, 0x0278, 0x00, 0x08)
>                            IO (Decode16, 0x0678, 0x0678, 0x00, 0x04)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3}
>                        }
>                        StartDependentFnNoPri ()
>                        {
>                            IO (Decode16, 0x03BC, 0x03BC, 0x00, 0x04)
>                            IO (Decode16, 0x07BC, 0x07BC, 0x00, 0x04)
>                            IRQNoFlags () {5,7}
>                            DMA (Compatibility, NotBusMaster, Transfer8) {0,1,3}
>                        }
>                        EndDependentFn ()
>                    })
>                    Method (_SRS, 1, NotSerialized)
>                    {
>                        CreateByteField (Arg0, 0x02, IOLO)
>                        CreateByteField (Arg0, 0x03, IOHI)
>                        CreateByteField (Arg0, 0x14, DMAC)
>                        CreateWordField (Arg0, 0x11, IRQL)
>                        ENFG ()
>                        If (LEqual (IOLO, 0xBC))
>                        {
>                            Store (0xEF, Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (IOHI, 0x03))
>                            {
>                                Store (0xDE, Local0)
>                            }
>                            Else
>                            {
>                                Store (0x9E, Local0)
>                            }
>                        }
>
>                        Store (0x23, INDX)
>                        Store (Local0, DATA)
>                        Store (0x27, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        If (LEqual (IRQL, 0x00))
>                        {
>                            Store (0x00, Local1)
>                        }
>                        Else
>                        {
>                            FindSetRightBit (IRQL, Local1)
>                            Subtract (Local1, 0x01, Local1)
>                        }
>
>                        Or (Local1, Local0, Local0)
>                        Store (0x27, INDX)
>                        Store (Local0, DATA)
>                        Store (0x26, INDX)
>                        Store (DATA, Local0)
>                        And (Local0, 0xF0, Local0)
>                        If (LEqual (DMAC, 0x01))
>                        {
>                            Or (Local0, 0x03, Local0)
>                        }
>
>                        If (LEqual (DMAC, 0x02))
>                        {
>                            Or (Local0, 0x00, Local0)
>                        }
>
>                        If (LEqual (DMAC, 0x08))
>                        {
>                            Or (Local0, 0x02, Local0)
>                        }
>
>                        Store (0x26, INDX)
>                        Store (Local0, DATA)
>                        EXFG ()
>                    }
>                }
>
>                Scope (_SB)
>                {
>                    Name (OKEC, 0x00)
>                }
>
>                Device (EC0)
>                {
>                    Name (_HID, EisaId ("PNP0C09"))
>                    Name (_CRS, ResourceTemplate ()
>                    {
>                        IO (Decode16, 0x0062, 0x0062, 0x01, 0x01)
>                        IO (Decode16, 0x0066, 0x0066, 0x01, 0x01)
>                    })
>                    Name (_GPE, 0x01)
>                    Name (ECFL, 0x06)
>                    Method (_REG, 2, NotSerialized)
>                    {
>                        If (LEqual (Arg0, 0x03))
>                        {
>                            Store (Arg1, \_SB.OKEC)
>                        }
>                    }
>
>                    Name (ACIN, 0x00)
>                    Name (ACFK, 0x00)
>                    Name (BTIN, 0x0F)
>                    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, 
>                        Offset (0x53), 
>                        TMSS,   2, 
>                            ,   2, 
>                        BANK,   4, 
>                        Offset (0x67), 
>                        WEVN,   8, 
>                        TMP,    8, 
>                        Offset (0xA1), 
>                        PTIM,   8, 
>                        Offset (0xA8), 
>                        RGA8,   8, 
>                        Offset (0xC0), 
>                        RGC0,   8
>                    }
>
>                    Field (ERAM, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x1C), 
>                        SMW0,   16
>                    }
>
>                    Field (ERAM, ByteAcc, NoLock, Preserve)
>                    {
>                        Offset (0x1C), 
>                        SMB0,   8
>                    }
>
>                    Mutex (MUT0, 0x00)
>                    Method (SMRD, 4, NotSerialized)
>                    {
>                        If (LNot (LEqual (Arg0, 0x07)))
>                        {
>                            If (LNot (LEqual (Arg0, 0x09)))
>                            {
>                                If (LNot (LEqual (Arg0, 0x0B)))
>                                {
>                                    Return (0x19)
>                                }
>                            }
>                        }
>
>                        Acquire (MUT0, 0xFFFF)
>                        Store (0x04, Local0)
>                        While (LGreater (Local0, 0x01))
>                        {
>                            And (SMST, 0x40, SMST)
>                            Store (Arg2, SMCM)
>                            Store (Arg1, SMAD)
>                            Store (Arg0, SMPR)
>                            While (LNot (And (SMST, 0xBF, Local1)))
>                            {
>                                Sleep (0x02)
>                            }
>
>                            If (LEqual (Local1, 0x80))
>                            {
>                                Store (0x00, Local0)
>                            }
>                            Else
>                            {
>                                Decrement (Local0)
>                            }
>                        }
>
>                        If (Local0)
>                        {
>                            Store (And (Local1, 0x1F), Local0)
>                        }
>                        Else
>                        {
>                            If (LEqual (Arg0, 0x07))
>                            {
>                                Store (SMB0, Arg3)
>                            }
>
>                            If (LEqual (Arg0, 0x09))
>                            {
>                                Store (SMW0, Arg3)
>                            }
>
>                            If (LEqual (Arg0, 0x0B))
>                            {
>                                Store (SMD0, Arg3)
>                            }
>                        }
>
>                        Release (MUT0)
>                        Return (Local0)
>                    }
>
>                    Method (SMWR, 4, NotSerialized)
>                    {
>                        If (LNot (LEqual (Arg0, 0x06)))
>                        {
>                            If (LNot (LEqual (Arg0, 0x08)))
>                            {
>                                If (LNot (LEqual (Arg0, 0x0A)))
>                                {
>                                    Return (0x19)
>                                }
>                            }
>                        }
>
>                        Acquire (MUT0, 0xFFFF)
>                        Store (0x04, Local0)
>                        While (LGreater (Local0, 0x01))
>                        {
>                            If (LEqual (Arg0, 0x06))
>                            {
>                                Store (Arg3, SMB0)
>                            }
>
>                            If (LEqual (Arg0, 0x08))
>                            {
>                                Store (Arg3, SMW0)
>                            }
>
>                            If (LEqual (Arg0, 0x0A))
>                            {
>                                Store (Arg3, SMD0)
>                            }
>
>                            And (SMST, 0x40, SMST)
>                            Store (Arg2, SMCM)
>                            Store (Arg1, SMAD)
>                            Store (Arg0, SMPR)
>                            While (LNot (And (SMST, 0xBF, Local1)))
>                            {
>                                Sleep (0x02)
>                            }
>
>                            If (LEqual (Local1, 0x80))
>                            {
>                                Store (0x00, Local0)
>                            }
>                            Else
>                            {
>                                Decrement (Local0)
>                            }
>                        }
>
>                        If (Local0)
>                        {
>                            Store (And (Local1, 0x1F), Local0)
>                        }
>
>                        Release (MUT0)
>                        Return (Local0)
>                    }
>
>                    Method (BPOL, 1, NotSerialized)
>                    {
>                        Store (BANK, Local0)
>                        Store (0x01, BANK)
>                        Store (Arg0, PTIM)
>                        Store (Local0, BANK)
>                    }
>
>                    Name (ACEV, 0x00)
>                    Name (BATO, 0x00)
>                    Name (BATN, 0x00)
>                    Method (_Q09, 0, NotSerialized)
>                    {
>                        Acquire (MUT0, 0xFFFF)
>                        Store ("XXXXXX Q09 XXXXXX", Debug)
>                        BPOL (0x00)
>                        Release (MUT0)
>                        Notify (\_SB.ACAD, 0x00)
>                        Notify (\_SB.BAT1, 0x81)
>                        Notify (\_SB.BAT1, 0x80)
>                    }
>
>                    Method (_Q20, 0, NotSerialized)
>                    {
>                        If (And (SMST, 0x40))
>                        {
>                            And (SMST, 0xBF, SMST)
>                            Store (SMAA, Local0)
>                            Store (Local0, Debug)
>                            If (LEqual (Local0, 0x14))
>                            {
>                                Acquire (MUT0, 0xFFFF)
>                                BPOL (0x04)
>                                Release (MUT0)
>                                SELE ()
>                                \_SB.BAT1.SEBI ()
>                                XOr (ACIN, 0x01, ACFK)
>                                Notify (\_SB.ACAD, 0x00)
>                                Sleep (0x05)
>                                Notify (\_SB.BAT1, 0x81)
>                                Notify (\_SB.BAT1, XOr (Local0, 0x01))
>                                Notify (\_SB.BAT1, 0x80)
>                            }
>                        }
>                    }
>
>                    Method (SELE, 0, NotSerialized)
>                    {
>                        Acquire (MUT0, 0xFFFF)
>                        Store (BATD, BATN)
>                        Release (MUT0)
>                        Store ("BATD=", Debug)
>                        Store (BATN, Debug)
>                        Store ("BATO=", Debug)
>                        Store (BATO, Debug)
>                        And (BATN, 0xC0, Local0)
>                        If (Local0)
>                        {
>                            Store (0x01, ACIN)
>                            Store (ACIN, ACFK)
>                        }
>                        Else
>                        {
>                            Store (0x00, ACIN)
>                            Store (ACIN, ACFK)
>                        }
>
>                        And (BATN, 0x01, Local0)
>                        If (Local0)
>                        {
>                            Store (0x1F, BTIN)
>                        }
>                        Else
>                        {
>                            Store (0x0F, BTIN)
>                        }
>
>                        And (BATO, 0x01, Local1)
>                        If (Not (LEqual (Local0, Local1)))
>                        {
>                            Store (0x01, ACEV)
>                            Store ("Notify Bat1 00", Debug)
>                            Store (0x06, ECFL)
>                            Store (0x01E9, \_SB.BAT1.UBIF)
>                        }
>                        Else
>                        {
>                            And (BATN, 0xC0, Local0)
>                            And (BATO, 0xC0, Local1)
>                            If (Not (LEqual (Local0, Local1)))
>                            {
>                                Store (0x01, ACEV)
>                                Store ("Notify acad 00 & bat1 80 ", Debug)
>                            }
>                            Else
>                            {
>                                Store ("charge/discharge Notify bat1 80 ", Debug)
>                            }
>                        }
>
>                        If (LNot (\_SB.BAT1.BFST))
>                        {
>                            Store ("Skip init BATO", Debug)
>                            Store (0x01, \_SB.BAT1.BFST)
>                        }
>
>                        If (LNot (\_SB.ACAD.AFST))
>                        {
>                            Store ("Skip init BATO", Debug)
>                            Store (0x01, \_SB.BAT1.BFST)
>                            Store (0x01, \_SB.ACAD.AFST)
>                        }
>
>                        Store (BATN, BATO)
>                    }
>
>                    Method (_Q82, 0, NotSerialized)
>                    {
>                        Store (0x00, \_SB.PCI0.PM.TREN)
>                    }
>
>                    Method (_Q81, 0, NotSerialized)
>                    {
>                        Store (0x0C, \_SB.PCI0.PM.TRDC)
>                        Store (0x01, \_SB.PCI0.PM.TREN)
>                    }
>
>                    Method (_Q83, 0, NotSerialized)
>                    {
>                        Store (0x07, \_SB.PCI0.PM.TRDC)
>                        Store (0x01, \_SB.PCI0.PM.TREN)
>                    }
>
>                    Method (_Q84, 0, NotSerialized)
>                    {
>                        Store (0x0C, \_SB.PCI0.PM.TRDC)
>                        Store (0x01, \_SB.PCI0.PM.TREN)
>                    }
>
>                    Method (_Q0C, 0, NotSerialized)
>                    {
>                        If (LEqual (\_SB.PCI0.MYOS, 0x01))
>                        {
>                            If (LEqual (\_SB.PCI0.AGP.VGA.DOSA, 0x00))
>                            {
>                                \_SB.Z000 (0x85)
>                                Notify (\_SB.PCI0.AGP.VGA, 0x80)
>                            }
>                        }
>                        Else
>                        {
>                            \_SB.Z000 (0x87)
>                        }
>                    }
>
>                    Method (_Q0D, 0, NotSerialized)
>                    {
>                        Notify (\_SB.SLPB, 0x80)
>                    }
>                }
>            }
>
>            Device (USB0)
>            {
>                Name (_ADR, 0x00070002)
>                Name (_PRW, Package (0x02)
>                {
>                    0x09, 
>                    0x01
>                })
>                OperationRegion (SB72, PCI_Config, 0x00, 0xC2)
>                Field (SB72, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x3C), 
>                    UIRR,   4
>                }
>
>                Method (_STA, 0, NotSerialized)
>                {
>                    If (\_SB.PCI0.PIB.EUSB)
>                    {
>                        Return (0x00)
>                    }
>                    Else
>                    {
>                        Return (0x0F)
>                    }
>                }
>            }
>
>            Device (PM)
>            {
>                Name (_ADR, 0x00070004)
>                OperationRegion (SB74, PCI_Config, 0x00, 0x0100)
>                Field (SB74, DWordAcc, NoLock, Preserve)
>                {
>                    Offset (0x44), 
>                    PIR0,   8, 
>                    PIR8,   8
>                }
>
>                OperationRegion (PMIO, SystemIO, 0x8000, 0x50)
>                Field (PMIO, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x10), 
>                    TRDC,   4, 
>                    TREN,   1, 
>                    Offset (0x28), 
>                        ,   7, 
>                    PIRS,   1, 
>                    Offset (0x2A), 
>                        ,   7, 
>                    PIEN,   1, 
>                    Offset (0x2C), 
>                        ,   7, 
>                    LPOL,   1, 
>                    Offset (0x2F), 
>                    BCMD,   8, 
>                    Offset (0x44), 
>                        ,   6, 
>                    CRTP,   1, 
>                    Offset (0x48), 
>                    EXMI,   1, 
>                        ,   2, 
>                    LIDI,   1, 
>                    Offset (0x4C), 
>                    MUTE,   1, 
>                    Offset (0x4D), 
>                        ,   4, 
>                    DISP,   1
>                }
>
>                OperationRegion (SMIO, SystemIO, 0x8080, 0x07)
>                Field (SMIO, ByteAcc, NoLock, Preserve)
>                {
>                    HSTS,   8, 
>                    SSTS,   8, 
>                    CTLR,   8, 
>                    CMDR,   8, 
>                    ADDR,   8, 
>                    DAT0,   8, 
>                    DAT1,   8
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store ("$$$$$$$$$$$$$$$$$$$$$", Debug)
>                    Stall (0x05)
>                }
>
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store ("######################", Debug)
>                    Store (0x00, \_GPE.HKFG)
>                }
>
>                Name (_PR0, Package (0x01)
>                {
>                    PLPC
>                })
>                PowerResource (PLPC, 0x00, 0x0000)
>                {
>                    Method (_STA, 0, NotSerialized)
>                    {
>                        Return (0x01)
>                    }
>
>                    Method (_ON, 0, NotSerialized)
>                    {
>                        Stall (0x05)
>                    }
>
>                    Method (_OFF, 0, NotSerialized)
>                    {
>                        Stall (0x05)
>                    }
>                }
>            }
>
>            Device (AUDI)
>            {
>                Name (_ADR, 0x00070005)
>                OperationRegion (SB75, PCI_Config, 0x00, 0x85)
>                Field (SB75, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x3C), 
>                    MIRR,   8
>                }
>
>                Method (_STA, 0, NotSerialized)
>                {
>                    Store (\_SB.PCI0.PIB.EXFE, Local0)
>                    And (Local0, 0x04, Local0)
>                    If (Local0)
>                    {
>                        Return (0x00)
>                    }
>                    Else
>                    {
>                        Return (0x0F)
>                    }
>                }
>            }
>
>            Device (MODM)
>            {
>                Name (_ADR, 0x00070006)
>                Name (_PRW, Package (0x02)
>                {
>                    0x0D, 
>                    0x01
>                })
>                OperationRegion (SB76, PCI_Config, 0x00, 0x85)
>                Field (SB76, ByteAcc, NoLock, Preserve)
>                {
>                    Offset (0x3C), 
>                    MIRL,   8
>                }
>
>                Method (_STA, 0, NotSerialized)
>                {
>                    Store (\_SB.PCI0.PIB.EXFE, Local0)
>                    And (Local0, 0x08, Local0)
>                    If (Local0)
>                    {
>                        Return (0x09)
>                    }
>                    Else
>                    {
>                        Return (0x0F)
>                    }
>                }
>            }
>
>            Device (PMOD)
>            {
>                Name (_ADR, 0x00090000)
>                Name (_PRW, Package (0x02)
>                {
>                    0x00, 
>                    0x01
>                })
>            }
>
>            Device (CRD0)
>            {
>                Name (_ADR, 0x000A0000)
>                Name (_PRW, Package (0x02)
>                {
>                    0x00, 
>                    0x01
>                })
>                Method (_INI, 0, NotSerialized)
>                {
>                    Or (PMEE, 0x01, PMEE)
>                }
>
>                Method (_PSC, 0, NotSerialized)
>                {
>                    Store (PWST, Local0)
>                    Return (Local0)
>                }
>
>                Method (_PS0, 0, NotSerialized)
>                {
>                    Store (0x01, PMST)
>                }
>
>                Method (_PS2, 0, NotSerialized)
>                {
>                    Store (0x01, PMST)
>                }
>
>                Method (_PS3, 0, NotSerialized)
>                {
>                    Store (0x01, PMST)
>                }
>
>                OperationRegion (CCRD, PCI_Config, 0x00, 0xA7)
>                Field (CCRD, DWordAcc, Lock, Preserve)
>                {
>                    Offset (0x80), 
>                    PMEE,   1, 
>                    Offset (0x81), 
>                    Offset (0xA4), 
>                    PWST,   2, 
>                    Offset (0xA5), 
>                        ,   7, 
>                    PMST,   1
>                }
>            }
>        }
>    }
>}

Actions: View

Attachments on bug 77805: 51180 | 51181 | 51182