Skip site navigation (1)Skip section navigation (2)
Date:      Sat, 30 Nov 2002 13:33:34 +0100
From:      Thomas Seck <tmseck-lists@netcologne.de>
To:        acpi-jp@jp.freebsd.org
Cc:        freebsd-current@freebsd.org, iwasaki@jp.freebsd.org
Subject:   Re: [acpi-jp 2004] ACPI errors w/ latest ACPI code on GA BX2000 based system
Message-ID:  <20021130123334.GA397@laurel.tmseck.homedns.org>
In-Reply-To: <20021130.125715.28771154.iwasaki@jp.FreeBSD.org>
References:  <20021129005056.GA770@laurel.tmseck.homedns.org> <20021130.125715.28771154.iwasaki@jp.FreeBSD.org>

next in thread | previous in thread | raw e-mail | index | archive | help

--y0ulUmNC+osPPQO6
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

* Mitsuru IWASAKI (iwasaki@jp.FreeBSD.org):

Iwasaki-san,
list members,

> > >     ACPI-0438: *** Error: Looking up [FAN_] in namespace, AE_NOT_FOUND
> > >     ACPI-1287: *** Error: Method execution failed, AE_NOT_FOUND
> 
> I think that this was caused by the following spec changes.
> From CHANGES.txt:
> ----
> 22 October 2002.  Summary of changes for version 20021022.
> 
> 1) ACPI CA Core Subsystem:
> 
> Implemented a restriction on the Scope operator that the
> target must already exist in the namespace at the time the
> operator is encountered (during table load or method
> execution).  In other words, forward references are not
> allowed and Scope() cannot create a new object. This changes
> the previous behavior where the interpreter would create the
> name if not found.  This new behavior correctly enables the
> search-to-root algorithm during namespace lookup of the target
> name.  Because of this upsearch, this fixes the known Compaq
> _SB_.OKEC problem and makes both the AML interpreter and iASL
> compiler compatible with other ACPI implementations.
> ----
> 
> Could you send your acpidump output to this acpi-jp ML?

Of course. And thank you very much for working on this. Please see the
attached file.

     --Thomas

--y0ulUmNC+osPPQO6
Content-Type: text/plain; charset=us-ascii
Content-Disposition: attachment; filename=acpidump

/*
RSD PTR: Checksum=226, OEMID=COMPAQ, RsdtAddress=0x0fff3000
 */
/*
RSDT: Length=40, Revision=1, Checksum=17,
	OEMID=COMPAQ, OEM Table ID=AWRDACPI, OEM Revision=0x42302e31,
	Creator ID=AWRD, Creator Revision=0x0
 */
/*
	Entries={ 0x0fff3040 }
 */
/*
	DSDT=0xfff30c0
	INT_MODEL=PIC
	SCI_INT=9
	SMI_CMD=0xb2, ACPI_ENABLE=0xa1, ACPI_DISABLE=0xa0, S4BIOS_REQ=0xa4
	PM1a_EVT_BLK=0x4000-0x4003
	PM1a_CNT_BLK=0x4004-0x4005
	PM2_TMR_BLK=0x4008-0x400b
	PM2_GPE0_BLK=0x400c-0x400f
	P_LVL2_LAT=90ms, P_LVL3_LAT=900ms
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=0
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	Flags={WBINVD,PROC_C1,SLP_BUTTON}
 */
/*
DSDT: Length=10553, Revision=1, Checksum=88,
	OEMID=COMPAQ, OEM Table ID=AWRDACPI, OEM Revision=0x1000,
	Creator ID=MSFT, Creator Revision=0x100000c
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "COMPAQ",		//OEMID
    "AWRDACPI",		//TABLE ID
    0x1000		//OEM Revision
)

{
Scope(\_PR_) {
    Processor(\_PR_.CPU0, 1, 0x4010, 0x6) {
    }
}
Name(\_S0_, Package(0x2) {
    0x5,
    0x5,
})
OperationRegion(CMOS, SystemIO, 0x70, 0x2)
Field(CMOS, ByteAcc, NoLock, Preserve) {
    INX_,	8,
    DTA_,	8
}
Store(0x8, Local0)
Store(0x54, INX_)
Store(DTA_, Local1)
And(Local1, Local0, Local1)
If(LEqual(Local1, 0x8)) {
    Name(\_S3_, Package(0x2) {
        0x1,
        0x1,
    })
}
Else {
    Name(\_S1_, Package(0x2) {
        0x4,
        0x4,
    })
}
Name(\_S4_, Package(0x2) {
    Zero,
    Zero,
})
Name(\_S5_, Package(0x2) {
    Zero,
    Zero,
})
OperationRegion(\DEBG, SystemIO, 0x80, 0x1)
Field(\DEBG, ByteAcc, NoLock, Preserve) {
    DBG1,	8
}
OperationRegion(\MUS1, SystemIO, 0x64, 0x1)
Field(\MUS1, ByteAcc, NoLock, Preserve) {
    MUSE,	8
}
OperationRegion(EXTM, SystemMemory, 0x000ff830, 0x10)
Field(EXTM, WordAcc, NoLock, Preserve) {
    ROM1,	16,
    RMS1,	16,
    ROM2,	16,
    RMS2,	16,
    ROM3,	16,
    RMS3,	16,
    AMEM,	32
}
OperationRegion(VGAM, SystemMemory, 0x000c0002, 0x1)
Field(VGAM, ByteAcc, NoLock, Preserve) {
    VGA1,	8
}
OperationRegion(\TRAP, SystemIO, 0x402f, 0x1)
Field(\TRAP, ByteAcc, NoLock, Preserve) {
    ,	1,
    TR13,	1
}
OperationRegion(PMES, SystemIO, 0x4015, 0x1)
Field(PMES, ByteAcc, NoLock, Preserve) {
    ,	1,
    PME_,	1
}
OperationRegion(\GBLE, SystemIO, 0x4021, 0x1)
Field(\GBLE, ByteAcc, NoLock, Preserve) {
    ESMI,	8
}
Name(CMDB, Buffer(0x8) { })
CreateByteField(CMDB, 0x0, BYT0)
CreateByteField(CMDB, 0x1, BYT1)
CreateByteField(CMDB, 0x2, BYT2)
CreateByteField(CMDB, 0x3, BYT3)
CreateByteField(CMDB, 0x4, BYT4)
CreateByteField(CMDB, 0x5, BYT5)
CreateByteField(CMDB, 0x6, BYT6)
CreateByteField(CMDB, 0x7, BYT7)
Name(IDEB, Buffer(0x38) { })
CreateField(IDEB, 0x0, 0x38, CMD0)
CreateField(IDEB, 0x38, 0x38, CMD1)
CreateField(IDEB, 0x70, 0x38, CMD2)
CreateField(IDEB, 0xa8, 0x38, CMD3)
CreateField(IDEB, 0xe0, 0x38, CMD4)
CreateField(IDEB, 0x0118, 0x38, CMD5)
CreateField(IDEB, 0x0150, 0x38, CMD6)
CreateField(IDEB, 0x0188, 0x38, CMD7)
OperationRegion(APMP, SystemIO, 0xb2, 0x2)
Field(APMP, ByteAcc, NoLock, Preserve) {
    APMC,	8,
    APMD,	8
}
OperationRegion(ELCR, SystemIO, 0x04d0, 0x2)
Field(ELCR, ByteAcc, NoLock, Preserve) {
    ELC1,	8,
    ELC2,	8
}
OperationRegion(GPOB, SystemIO, 0x4034, 0x4)
Field(GPOB, ByteAcc, NoLock, Preserve) {
    GP00,	1,
    GP01,	1,
    GP02,	1,
    GP03,	1,
    GP04,	1,
    GP05,	1,
    GP06,	1,
    GP07,	1,
    GP08,	1,
    GP09,	1,
    GP0A,	1,
    GP0B,	1,
    GP0C,	1,
    GP0D,	1,
    GP0E,	1,
    GP0F,	1,
    GP10,	1,
    GP11,	1,
    GP12,	1,
    GP13,	1,
    GP14,	1,
    GP15,	1,
    GP16,	1,
    GP17,	1,
    GP18,	1,
    GP19,	1,
    GP1A,	1,
    GP1B,	1,
    GP1C,	1,
    GP1D,	1,
    GP1E,	1,
    GP1F,	1
}
Name(OSFL, 0x1)
Method(STRC, 2) {
    If(LNot(LEqual(SizeOf(Arg0), SizeOf(Arg1)))) {
        Return(0x0)
    }
    Add(SizeOf(Arg0), 0x1, Local0)
    Name(BUF0, Buffer(Local0) { })
    Name(BUF1, Buffer(Local0) { })
    Store(Arg0, BUF0)
    Store(Arg1, BUF1)
    While(Local0) {
        Decrement(Local0)
        If(LNot(LEqual(DerefOf(Index(BUF0, Local0, )), DerefOf(Index(BUF1, Local0, ))))) {
            Return(Zero)
        }
    }
    Return(One)
}
OperationRegion(RTCM, SystemIO, 0x70, 0x2)
Field(RTCM, ByteAcc, NoLock, Preserve) {
    CMIN,	8,
    CMDA,	8
}
IndexField(CMIN, CMDA, ByteAcc, NoLock, Preserve) {
    Offset(0xf),
    SHUT,	8
}
OperationRegion(\GRAM, SystemMemory, 0x0400, 0x0100)
Field(\GRAM, ByteAcc, NoLock, Preserve) {
    Offset(0x10),
    FLG0,	8,
    Offset(0xba),
    SFLG,	8
}
OperationRegion(INFO, SystemMemory, 0x000ff840, 0x1)
Field(INFO, ByteAcc, NoLock, Preserve) {
    KBDI,	1,
    RTCW,	1
}
OperationRegion(BEEP, SystemIO, 0x61, 0x1)
Field(BEEP, ByteAcc, NoLock, Preserve) {
    S1B_,	8
}
OperationRegion(CONT, SystemIO, 0x40, 0x4)
Field(CONT, ByteAcc, NoLock, Preserve) {
    CNT0,	8,
    CNT1,	8,
    CNT2,	8,
    CTRL,	8
}
Method(SPKR, 1) {
    Store(S1B_, Local0)
    Store(0xb6, CTRL)
    Store(0x55, CNT2)
    Store(0x3, CNT2)
    Store(Arg0, Local2)
    While(LGreater(Local2, 0x0)) {
        Or(S1B_, 0x3, S1B_)
        Store(0x5fff, Local3)
        While(LGreater(Local3, 0x0)) {
            Decrement(Local3)
        }
        And(S1B_, 0xfc, S1B_)
        Store(0x0eff, Local3)
        While(LGreater(Local3, 0x0)) {
            Decrement(Local3)
        }
        Decrement(Local2)
    }
    Store(Local0, S1B_)
}
Method(\_PTS, 1) {
    If(LEqual(Arg0, 0x5)) {
        Or(Arg0, 0x50, Local0)
        Store(One, TR13)
    }
    If(LEqual(Arg0, 0x1)) {
        Store(One, TR13)
    }
    If(LEqual(Arg0, 0x2)) {
        Store(One, TR13)
    }
    If(LEqual(Arg0, 0x3)) {
        Store(One, TR13)
    }
    Or(Arg0, 0xf0, Local0)
    Store(Local0, DBG1)
    If(LEqual(Arg0, 0x4)) {
    }
    If(LEqual(Arg0, 0x5)) {
        Store(One, GP1B)
    }
}
Method(\_WAK, 1) {
    Store(0xff, DBG1)
    Store(0x0, PME_)
    Notify(\_SB_.PWRB, 0x2)
}
Scope(\_SI_) {
    Name(SF56, 0x0)
    Name(SF57, 0x0)
    Name(FLAG, 0x0)
    OperationRegion(SIFG, SystemMemory, 0x000ff81c, 0x1)
    Field(SIFG, ByteAcc, NoLock, Preserve) {
        SBIT,	2,
        Offset(0x1)
    }
    OperationRegion(ITE1, SystemIO, 0x03f0, 0x2)
    Field(ITE1, ByteAcc, NoLock, Preserve) {
        IND0,	8,
        DATA,	8
    }
    OperationRegion(ENG1, SystemIO, 0x0279, 0x1)
    Field(ENG1, ByteAcc, NoLock, Preserve) {
        CONG,	8
    }
    Method(ENFG) {
        Store(0x86, CONG)
        Store(0x80, CONG)
        Store(0x55, CONG)
        Store(0x55, CONG)
        Store(0x6a, IND0)
        Store(0xb5, IND0)
        Store(0xda, IND0)
        Store(0xed, IND0)
        Store(0xf6, IND0)
        Store(0xfb, IND0)
        Store(0x7d, IND0)
        Store(0xbe, IND0)
        Store(0xdf, IND0)
        Store(0x6f, IND0)
        Store(0x37, IND0)
        Store(0x1b, IND0)
        Store(0xd, IND0)
        Store(0x86, IND0)
        Store(0xc3, IND0)
        Store(0x61, IND0)
        Store(0xb0, IND0)
        Store(0x58, IND0)
        Store(0x2c, IND0)
        Store(0x16, IND0)
        Store(0x8b, IND0)
        Store(0x45, IND0)
        Store(0xa2, IND0)
        Store(0xd1, IND0)
        Store(0xe8, IND0)
        Store(0x74, IND0)
        Store(0x3a, IND0)
        Store(0x9d, IND0)
        Store(0xce, IND0)
        Store(0xe7, IND0)
        Store(0x73, IND0)
        Store(0x39, IND0)
    }
    Method(EXFG) {
        Store(0x2, IND0)
        Store(0x2, DATA)
    }
    Method(SPLD, 2) {
        ENFG()
        Store(0x7, IND0)
        Store(0x7, DATA)
        If(LEqual(Arg0, Zero)) {
            Store(0x0, Local0)
        }
        If(LEqual(Arg0, One)) {
            Store(0x2, Local0)
            And(Local0, 0x3f, Local0)
            Or(Local0, Arg1, Local0)
        }
        Store(0x71, IND0)
        Store(Local0, DATA)
        EXFG()
    }
    OperationRegion(\GPO0, SystemIO, 0x4034, 0x1)
    Field(\GPO0, ByteAcc, NoLock, Preserve) {
        GPO0,	8
    }
    OperationRegion(THRO, SystemIO, 0x4011, 0x1)
    Field(THRO, ByteAcc, NoLock, Preserve) {
        THRP,	8
    }
    Method(GREN, 1) {
        Store(THRP, Local0)
        If(LEqual(Arg0, Zero)) {
            Or(GPO0, 0x1, GPO0)
            And(Local0, 0xfd, Local0)
        }
        If(LEqual(Arg0, One)) {
            And(GPO0, 0xfe, GPO0)
            Or(Local0, 0x2, Local0)
        }
        Store(Local0, THRP)
    }
    Method(DELY, 1) {
        Store(Arg0, Local0)
        While(LGreater(Local0, 0x0)) {
            Decrement(Local0)
        }
    }
    Method(OFAN) {
        DELY(0x000186a0)
        If(LEqual(FLAG, 0x0)) {
            Store(GBYT(0x56), SF56)
            Store(GBYT(0x57), SF57)
        }
        Else {
            SBYT(0x56, SF56)
            SBYT(0x57, SF57)
        }
    }
    Method(CFAN) {
        Store(0x1, FLAG)
        And(GBYT(0x56), 0x3f, Local0)
        SBYT(0x56, Local0)
        And(GBYT(0x57), 0xf7, Local0)
        SBYT(0x57, Local0)
    }
    OperationRegion(IP__, SystemIO, 0x0295, 0x2)
    Field(IP__, ByteAcc, NoLock, Preserve) {
        INDX,	8,
        DAT0,	8
    }
    Method(SCFG, 1) {
        SBYT(0x40, Arg0)
    }
    Method(STOS, 3) {
        Store(GBYT(0x4e), Local0)
        Or(Local0, 0x1, Local1)
        SBYT(0x4e, Local1)
        SBYT(0x55, Arg1)
        SBYT(0x56, Arg0)
        SBYT(0x4e, Local0)
    }
    Method(STHY, 3) {
        Store(GBYT(0x4e), Local0)
        Or(Local0, 0x1, Local1)
        SBYT(0x4e, Local1)
        SBYT(0x53, Arg1)
        SBYT(0x54, Arg0)
        SBYT(0x4e, Local0)
    }
    Method(RTMP) {
        Store(GBYT(0x4e), Local0)
        Or(Local0, 0x1, Local1)
        SBYT(0x4e, Local1)
        Store(GBYT(0x50), Local1)
        Store(GBYT(0x51), Local2)
        ShiftLeft(Local1, 0x8, Local1)
        Or(Local1, Local2, Local3)
        ShiftRight(Local3, 0x7, Local3)
        ShiftLeft(Local3, 0x2, Local1)
        Add(Local3, Local1, Local3)
        Add(Local3, 0x0aac, Local3)
        SBYT(0x4e, Local0)
        Return(Local3)
    }
    Method(SBYT, 2) {
        Store(Arg0, INDX)
        Store(Arg1, DAT0)
    }
    Method(GBYT, 1) {
        Store(Arg0, INDX)
        Store(DAT0, Local7)
        Return(Local7)
    }
    Method(_MSG, 1) {
        Store(Local0, DBG1)
    }
    Method(_SST, 1) {
        If(LEqual(Arg0, Zero)) {
            If(LNot(LEqual(SBIT, 0x3))) {
                SPLD(0x1, 0x20)
            }
            Return(0x0)
        }
        If(LEqual(Arg0, One)) {
            SPLD(0x0, 0x0)
            GREN(0x0)
            Store(One, GP1B)
            Store(One, GP1C)
            Store(One, GP1E)
            OFAN()
            Return(0x0)
        }
        If(LEqual(Arg0, 0x2)) {
            GREN(0x1)
            Return(0x0)
        }
        If(LEqual(Arg0, 0x3)) {
            Store(0x1, Local0)
            Store(0x53, INX_)
            Store(DTA_, Local1)
            And(Local1, Local0, Local1)
            If(LEqual(Local1, 0x1)) {
                Store(Zero, GP1B)
                Store(Zero, GP1C)
                Store(Zero, GP1E)
            }
            CFAN()
            If(LEqual(SBIT, 0x0)) {
                SPLD(0x0, 0x0)
            }
            If(LEqual(SBIT, 0x1)) {
                SPLD(0x1, 0x20)
            }
            If(LEqual(SBIT, 0x2)) {
                SPLD(0x1, 0x80)
            }
            GREN(0x1)
            Return(0x0)
        }
        If(LEqual(Arg0, 0x4)) {
            If(LEqual(SBIT, 0x0)) {
                SPLD(0x0, 0x0)
            }
            If(LEqual(SBIT, 0x1)) {
                SPLD(0x1, 0x20)
            }
            If(LEqual(SBIT, 0x2)) {
                SPLD(0x1, 0x80)
            }
            GREN(0x0)
            Return(0x0)
        }
    }
}
OperationRegion(TEMM, SystemMemory, 0x000ff810, 0xc)
Field(TEMM, WordAcc, NoLock, Preserve) {
    TP1H,	16,
    TP1L,	16,
    TP2H,	16,
    TP2L,	16,
    TRPC,	16,
    SENF,	16
}
Name(TVAR, Buffer(0x5) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateByteField(TVAR, 0x0, PLCY)
CreateWordField(TVAR, 0x1, CTOS)
CreateWordField(TVAR, 0x3, CTHY)
Store(TP1H, CTOS)
Store(TP1L, CTHY)
Name(TBUF, Buffer(0x4) {0x0, 0x0, 0x0, 0x0 })
CreateByteField(TBUF, 0x0, DB00)
CreateByteField(TBUF, 0x1, DB01)
CreateWordField(TBUF, 0x0, DW00)
CreateWordField(TBUF, 0x2, DW01)
CreateDWordField(TBUF, 0x0, DATD)
OperationRegion(IP__, SystemIO, 0x0295, 0x2)
Field(IP__, ByteAcc, NoLock, Preserve) {
    INDX,	8,
    DAT0,	8
}
Method(SCFG, 1) {
    SBYT(0x40, Arg0)
}
Method(STOS, 3) {
    Store(GBYT(0x4e), Local0)
    Or(Local0, 0x1, Local1)
    SBYT(0x4e, Local1)
    SBYT(0x55, Arg1)
    SBYT(0x56, Arg0)
    SBYT(0x4e, Local0)
}
Method(STHY, 3) {
    Store(GBYT(0x4e), Local0)
    Or(Local0, 0x1, Local1)
    SBYT(0x4e, Local1)
    SBYT(0x53, Arg1)
    SBYT(0x54, Arg0)
    SBYT(0x4e, Local0)
}
Method(RTMP) {
    Store(GBYT(0x4e), Local0)
    Or(Local0, 0x1, Local1)
    SBYT(0x4e, Local1)
    Store(GBYT(0x50), Local1)
    Store(GBYT(0x51), Local2)
    ShiftLeft(Local1, 0x8, Local1)
    Or(Local1, Local2, Local3)
    ShiftRight(Local3, 0x7, Local3)
    ShiftLeft(Local3, 0x2, Local1)
    Add(Local3, Local1, Local3)
    Add(Local3, 0x0aac, Local3)
    SBYT(0x4e, Local0)
    Return(Local3)
}
Method(SBYT, 2) {
    Store(Arg0, INDX)
    Store(Arg1, DAT0)
}
Method(GBYT, 1) {
    Store(Arg0, INDX)
    Store(DAT0, Local7)
    Return(Local7)
}
Scope(\_TZ_) {
    ThermalZone(THRM) {
        Name(_AL0, Package(0x1) {
            FAN_,
        })
        Method(_AC0) {
            If(Or(PLCY, PLCY, Local7)) {
                Return(TP2H)
            }
            Else {
                Return(TP1H)
            }
        }
        Name(_PSL, Package(0x1) {
            \_PR_.CPU0,
        })
        Name(_TSP, 0x3c)
        Name(_TC1, 0x4)
        Name(_TC2, 0x3)
        Method(_PSV) {
            If(Or(PLCY, PLCY, Local7)) {
                Return(TP1H)
            }
            Else {
                Return(TP2H)
            }
        }
        Method(_CRT) {
            Return(TRPC)
        }
        Method(_TMP) {
            And(SENF, 0x5, Local6)
            If(LEqual(Local6, 0x5)) {
                Store(RTMP(), Local6)
                If(LNot(LLess(Local6, TRPC))) {
                    Store(TRPC, Local7)
                    Subtract(Local7, 0xa, Local7)
                    Return(Local7)
                }
                Else {
                    Return(Local6)
                }
            }
            And(SENF, 0x1, Local6)
            If(LEqual(Local6, 0x1)) {
                Return(RTMP())
            }
            Else {
                Return(0x0b86)
            }
        }
        Method(_SCP, 1) {
            If(Arg0) {
                Store(One, PLCY)
            }
            Else {
                Store(Zero, PLCY)
            }
            Notify(\_TZ_.THRM, 0x81)
        }
        Method(STMP, 2) {
            Store(Arg1, DW00)
            If(Arg0) {
                STHY(DB00, DB01, DW00)
            }
            Else {
                STOS(DB00, DB01, DW00)
            }
        }
    }
}
Scope(\_GPE) {
}
Scope(\_SB_) {
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Method(_STA) {
            Return(0xb)
        }
    }
    Device(MEM_) {
        Name(_HID, 0x010cd041)
        Method(_CRS) {
            Name(BUF0, Buffer(0x62) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xf, 0x0, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x40, 0xf, 0x0, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x80, 0xf, 0x0, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0xc0, 0xf, 0x0, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x1, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x79, 0x0 })
            CreateDWordField(BUF0, 0x34, ACMM)
            CreateDWordField(BUF0, 0x4, RMA1)
            CreateDWordField(BUF0, 0x8, RSS1)
            CreateDWordField(BUF0, 0x10, RMA2)
            CreateDWordField(BUF0, 0x14, RSS2)
            CreateDWordField(BUF0, 0x1c, RMA3)
            CreateDWordField(BUF0, 0x20, RSS3)
            CreateDWordField(BUF0, 0x28, RMA4)
            CreateDWordField(BUF0, 0x2c, RSS4)
            CreateDWordField(BUF0, 0x5c, EXTM)
            Subtract(AMEM, 0x00100000, EXTM)
            If(LNot(LEqual(ROM1, Zero))) {
                Store(RMA1, RMA2)
                ShiftLeft(ROM1, 0x8, Local0)
                Store(Local0, RMA1)
                ShiftLeft(RMS1, 0x8, Local0)
                Store(Local0, RSS1)
                Store(0x8000, RSS2)
            }
            If(LNot(LEqual(ROM2, Zero))) {
                Store(RMA2, RMA3)
                ShiftLeft(ROM2, 0x8, Local0)
                Store(Local0, RMA2)
                ShiftLeft(RMS2, 0x8, Local0)
                Store(Local0, RSS2)
                Store(0xc000, RSS3)
            }
            If(LNot(LEqual(ROM3, Zero))) {
                Store(RMA3, RMA4)
                ShiftLeft(ROM3, 0x8, Local0)
                Store(Local0, RMA3)
                ShiftLeft(RMS3, 0x8, Local0)
                Store(Local0, RSS3)
                Store(0x00010000, RSS4)
            }
            Store(AMEM, ACMM)
            Return(BUF0)
        }
    }
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Method(_STA) {
            Return(0xf)
        }
        Method(_S3D) {
            Return(0x1)
        }
        Method(_CRS) {
            Name(BUF0, Buffer(0x9e) {0x88, 0xd, 0x0, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0xf8, 0xc, 0xf8, 0xc, 0x1, 0x8, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0xd, 0xff, 0x3f, 0x0, 0x0, 0x0, 0x33, 0x47, 0x1, 0x0, 0x40, 0x0, 0x40, 0x1, 0x42, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x42, 0x40, 0xff, 0x4f, 0x0, 0x0, 0xbe, 0xf, 0x47, 0x1, 0x0, 0x50, 0x0, 0x50, 0x1, 0x10, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x10, 0x50, 0xff, 0xff, 0x0, 0x0, 0xf0, 0xaf, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x2, 0x0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0xff, 0xff, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xff, 0x79, 0x0 })
            CreateDWordField(BUF0, 0x76, VMAX)
            CreateDWordField(BUF0, 0x7e, VLEN)
            ShiftLeft(VGA1, 0x9, Local0)
            Add(Local0, 0x000bffff, VMAX)
            Add(Local0, 0x00020000, VLEN)
            CreateDWordField(BUF0, 0x8c, TCMM)
            CreateDWordField(BUF0, 0x98, TOMM)
            Add(AMEM, 0x00010000, TCMM)
            Subtract(0xfff00000, TCMM, TOMM)
            Return(BUF0)
        }
        Name(_PRT, Package(0x1c) {
            Package(0x4) {
                0x0008ffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x0,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x1,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x2,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x3,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x0,
                \_SB_.PCI0.ISA_.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x1,
                \_SB_.PCI0.ISA_.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x2,
                \_SB_.PCI0.ISA_.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x3,
                \_SB_.PCI0.ISA_.LNKD,
                0x0,
            },
        })
        Device(PX40) {
            Name(_ADR, 0x00070000)
            OperationRegion(PIRQ, PCI_Config, 0x60, 0x4)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.PIRQ, ByteAcc, NoLock, Preserve) {
                    PIRA,	8,
                    PIRB,	8,
                    PIRC,	8,
                    PIRD,	8
                }
            }
        }
        Device(USB0) {
            Name(_ADR, 0x00070002)
            Name(_PRW, Package(0x2) {
                0x8,
                0x4,
            })
        }
        Device(PX43) {
            Name(_ADR, 0x00070003)
        }
        Device(ISA_) {
            Name(_ADR, 0x00070000)
            Method(_STA) {
                Return(0xb)
            }
            Device(LNKA) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x1)
                Method(_STA) {
                    And(PIRA, 0x80, Local0)
                    If(LEqual(Local0, 0x80)) {
                        Return(0x9)
                    }
                    Else {
                        Return(0xb)
                    }
                }
                Method(_PRS) {
                    Name(BUFA, Buffer(0x6) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
                    Return(BUFA)
                }
                Method(_DIS) {
                    Store(0x1, Local3)
                    And(PIRA, 0xf, Local1)
                    Store(Local1, Local2)
                    If(LGreater(Local1, 0x8)) {
                        Subtract(Local1, 0x8, Local1)
                    }
                    ShiftLeft(Local3, Local1, Local3)
                    Not(Local3, Local3)
                    If(LGreater(Local2, 0x8)) {
                        And(ELC2, Local3, ELC2)
                    }
                    Else {
                        And(ELC1, Local3, ELC1)
                    }
                    Or(PIRA, 0x80, PIRA)
                }
                Method(_CRS) {
                    Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                    CreateByteField(BUFA, 0x1, IRA1)
                    CreateByteField(BUFA, 0x2, IRA2)
                    Store(0x0, Local3)
                    Store(0x0, Local4)
                    And(PIRA, 0x8f, Local1)
                    If(LLess(Local1, 0x80)) {
                        And(Local1, 0xf, Local1)
                        If(LGreater(Local1, 0x7)) {
                            Subtract(Local1, 0x8, Local2)
                            ShiftLeft(One, Local2, Local4)
                        }
                        Else {
                            If(LGreater(Local1, 0x0)) {
                                ShiftLeft(One, Local1, Local3)
                            }
                        }
                        Store(Local3, IRA1)
                        Store(Local4, IRA2)
                    }
                    Return(BUFA)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x1, IRA1)
                    CreateByteField(Arg0, 0x2, IRA2)
                    ShiftLeft(IRA2, 0x8, Local0)
                    Or(Local0, IRA1, Local0)
                    Store(0x0, Local1)
                    ShiftRight(Local0, 0x1, Local0)
                    While(LGreater(Local0, 0x0)) {
                        Increment(Local1)
                        ShiftRight(Local0, 0x1, Local0)
                    }
                    And(PIRA, 0x70, Local0)
                    Or(Local1, Local0, PIRA)
                }
            }
            Device(LNKB) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x2)
                Method(_STA) {
                    And(PIRB, 0x80, Local0)
                    If(LEqual(Local0, 0x80)) {
                        Return(0x9)
                    }
                    Else {
                        Return(0xb)
                    }
                }
                Method(_PRS) {
                    Name(BUFB, Buffer(0x6) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
                    Return(BUFB)
                }
                Method(_DIS) {
                    Store(0x1, Local3)
                    And(PIRB, 0xf, Local1)
                    Store(Local1, Local2)
                    If(LGreater(Local1, 0x8)) {
                        Subtract(Local1, 0x8, Local1)
                    }
                    ShiftLeft(Local3, Local1, Local3)
                    Not(Local3, Local3)
                    If(LGreater(Local2, 0x8)) {
                        And(ELC2, Local3, ELC2)
                    }
                    Else {
                        And(ELC1, Local3, ELC1)
                    }
                    Or(PIRB, 0x80, PIRB)
                }
                Method(_CRS) {
                    Name(BUFB, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                    CreateByteField(BUFB, 0x1, IRB1)
                    CreateByteField(BUFB, 0x2, IRB2)
                    Store(0x0, Local3)
                    Store(0x0, Local4)
                    And(PIRB, 0x8f, Local1)
                    If(LLess(Local1, 0x80)) {
                        And(Local1, 0xf, Local1)
                        If(LGreater(Local1, 0x7)) {
                            Subtract(Local1, 0x8, Local2)
                            ShiftLeft(One, Local2, Local4)
                        }
                        Else {
                            If(LGreater(Local1, 0x0)) {
                                ShiftLeft(One, Local1, Local3)
                            }
                        }
                        Store(Local3, IRB1)
                        Store(Local4, IRB2)
                    }
                    Return(BUFB)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x1, IRB1)
                    CreateByteField(Arg0, 0x2, IRB2)
                    ShiftLeft(IRB2, 0x8, Local0)
                    Or(Local0, IRB1, Local0)
                    Store(0x0, Local1)
                    ShiftRight(Local0, 0x1, Local0)
                    While(LGreater(Local0, 0x0)) {
                        Increment(Local1)
                        ShiftRight(Local0, 0x1, Local0)
                    }
                    And(PIRB, 0x70, Local0)
                    Or(Local1, Local0, PIRB)
                }
            }
            Device(LNKC) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x3)
                Method(_STA) {
                    And(PIRC, 0x80, Local0)
                    If(LEqual(Local0, 0x80)) {
                        Return(0x9)
                    }
                    Else {
                        Return(0xb)
                    }
                }
                Name(_PRS, Buffer(0x6) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Store(0x1, Local3)
                    And(PIRC, 0xf, Local1)
                    Store(Local1, Local2)
                    If(LGreater(Local1, 0x8)) {
                        Subtract(Local1, 0x8, Local1)
                    }
                    ShiftLeft(Local3, Local1, Local3)
                    Not(Local3, Local3)
                    If(LGreater(Local2, 0x8)) {
                        And(ELC2, Local3, ELC2)
                    }
                    Else {
                        And(ELC1, Local3, ELC1)
                    }
                    Or(PIRC, 0x80, PIRC)
                }
                Method(_CRS) {
                    Name(BUFC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                    CreateByteField(BUFC, 0x1, IRC1)
                    CreateByteField(BUFC, 0x2, IRC2)
                    Store(0x0, Local3)
                    Store(0x0, Local4)
                    And(PIRC, 0x8f, Local0)
                    If(LLess(Local0, 0x80)) {
                        And(Local0, 0xf, Local0)
                        If(LGreater(Local0, 0x7)) {
                            Subtract(Local0, 0x8, Local2)
                            ShiftLeft(One, Local2, Local4)
                        }
                        Else {
                            If(LGreater(Local0, 0x0)) {
                                ShiftLeft(One, Local0, Local3)
                            }
                        }
                        Store(Local3, IRC1)
                        Store(Local4, IRC2)
                    }
                    Return(BUFC)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x1, IRC1)
                    CreateByteField(Arg0, 0x2, IRC2)
                    ShiftLeft(IRC2, 0x8, Local0)
                    Or(Local0, IRC1, Local0)
                    Store(0x0, Local1)
                    ShiftRight(Local0, 0x1, Local0)
                    While(LGreater(Local0, 0x0)) {
                        Increment(Local1)
                        ShiftRight(Local0, 0x1, Local0)
                    }
                    And(PIRC, 0x70, Local0)
                    Or(Local1, Local0, PIRC)
                }
            }
            Device(LNKD) {
                Name(_HID, 0x0f0cd041)
                Name(_UID, 0x4)
                Method(_STA) {
                    And(PIRD, 0x80, Local0)
                    If(LEqual(Local0, 0x80)) {
                        Return(0x9)
                    }
                    Else {
                        Return(0xb)
                    }
                }
                Name(_PRS, Buffer(0x6) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
                Method(_DIS) {
                    Store(0x1, Local3)
                    And(PIRD, 0xf, Local1)
                    Store(Local1, Local2)
                    If(LGreater(Local1, 0x8)) {
                        Subtract(Local1, 0x8, Local1)
                    }
                    ShiftLeft(Local3, Local1, Local3)
                    Not(Local3, Local3)
                    If(LGreater(Local2, 0x8)) {
                        And(ELC2, Local3, ELC2)
                    }
                    Else {
                        And(ELC1, Local3, ELC1)
                    }
                    Or(PIRD, 0x80, PIRD)
                }
                Method(_CRS) {
                    Name(BUFD, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                    CreateByteField(BUFD, 0x1, IRD1)
                    CreateByteField(BUFD, 0x2, IRD2)
                    Store(0x0, Local3)
                    Store(0x0, Local4)
                    And(PIRD, 0x8f, Local0)
                    If(LLess(Local0, 0x80)) {
                        And(Local0, 0xf, Local0)
                        If(LGreater(Local0, 0x7)) {
                            Subtract(Local0, 0x8, Local2)
                            ShiftLeft(One, Local2, Local4)
                        }
                        Else {
                            If(LGreater(Local0, 0x0)) {
                                ShiftLeft(One, Local0, Local3)
                            }
                        }
                        Store(Local3, IRD1)
                        Store(Local4, IRD2)
                    }
                    Return(BUFD)
                }
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x1, IRD1)
                    CreateByteField(Arg0, 0x2, IRD2)
                    ShiftLeft(IRD2, 0x8, Local0)
                    Or(Local0, IRD1, Local0)
                    Store(0x0, Local1)
                    ShiftRight(Local0, 0x1, Local0)
                    While(LGreater(Local0, 0x0)) {
                        Increment(Local1)
                        ShiftRight(Local0, 0x1, Local0)
                    }
                    And(PIRD, 0x70, Local0)
                    Or(Local1, Local0, PIRD)
                }
            }
            Device(SYSR) {
                Name(_HID, 0x020cd041)
                Name(_UID, 0x1)
                Name(_CRS, Buffer(0x62) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x1, 0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x1, 0x1e, 0x47, 0x1, 0x44, 0x0, 0x44, 0x0, 0x1, 0x1c, 0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x1, 0x2, 0x47, 0x1, 0x65, 0x0, 0x65, 0x0, 0x1, 0xb, 0x47, 0x1, 0x74, 0x0, 0x74, 0x0, 0x1, 0xc, 0x47, 0x1, 0x91, 0x0, 0x91, 0x0, 0x1, 0x3, 0x47, 0x1, 0xa2, 0x0, 0xa2, 0x0, 0x1, 0x1e, 0x47, 0x1, 0xe0, 0x0, 0xe0, 0x0, 0x1, 0x10, 0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x1, 0x2, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0x94, 0x2, 0x94, 0x2, 0x1, 0x4, 0x79, 0x0 })
            }
            Device(PIC_) {
                Name(_HID, 0xd041)
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0, 0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x22, 0x4, 0x0, 0x79, 0x0 })
            }
            Device(DMA1) {
                Name(_HID, 0x0002d041)
                Name(_CRS, Buffer(0x25) {0x2a, 0x10, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x10, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x11, 0x47, 0x1, 0x94, 0x0, 0x94, 0x0, 0x1, 0xc, 0x47, 0x1, 0xc0, 0x0, 0xc0, 0x0, 0x1, 0x20, 0x79, 0x0 })
            }
            Device(TMR_) {
                Name(_HID, 0x0001d041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0, 0x1, 0x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
            }
            Device(RTC_) {
                Name(_HID, 0x000bd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x0, 0x4, 0x22, 0x0, 0x1, 0x79, 0x0 })
            }
            Device(SPKR) {
                Name(_HID, 0x0008d041)
                Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0x1, 0x79, 0x0 })
            }
            Device(COPR) {
                Name(_HID, 0x040cd041)
                Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 0x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
            }
            OperationRegion(ITE1, SystemIO, 0x03f0, 0x2)
            Field(ITE1, ByteAcc, NoLock, Preserve) {
                INDX,	8,
                DATA,	8
            }
            OperationRegion(ENG1, SystemIO, 0x0279, 0x1)
            Field(ENG1, ByteAcc, NoLock, Preserve) {
                CONG,	8
            }
            IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
                Offset(0x2),
                CFG_,	8,
                Offset(0x7),
                LDN_,	8,
                Offset(0x22),
                POWC,	8,
                Offset(0x30),
                ACTR,	8,
                Offset(0x60),
                IOAH,	8,
                IOAL,	8,
                Offset(0x70),
                INTR,	8,
                Offset(0x72),
                INT1,	8,
                Offset(0x74),
                DMCH,	8,
                Offset(0xc0),
                GP40,	8,
                Offset(0xf0),
                OPT1,	8,
                OPT2,	8,
                OPT3,	8
            }
            Method(ENFG) {
                Store(0x86, CONG)
                Store(0x80, CONG)
                Store(0x55, CONG)
                Store(0x55, CONG)
                Store(0x6a, INDX)
                Store(0xb5, INDX)
                Store(0xda, INDX)
                Store(0xed, INDX)
                Store(0xf6, INDX)
                Store(0xfb, INDX)
                Store(0x7d, INDX)
                Store(0xbe, INDX)
                Store(0xdf, INDX)
                Store(0x6f, INDX)
                Store(0x37, INDX)
                Store(0x1b, INDX)
                Store(0xd, INDX)
                Store(0x86, INDX)
                Store(0xc3, INDX)
                Store(0x61, INDX)
                Store(0xb0, INDX)
                Store(0x58, INDX)
                Store(0x2c, INDX)
                Store(0x16, INDX)
                Store(0x8b, INDX)
                Store(0x45, INDX)
                Store(0xa2, INDX)
                Store(0xd1, INDX)
                Store(0xe8, INDX)
                Store(0x74, INDX)
                Store(0x3a, INDX)
                Store(0x9d, INDX)
                Store(0xce, INDX)
                Store(0xe7, INDX)
                Store(0x73, INDX)
                Store(0x39, INDX)
            }
            Method(EXFG) {
                Store(0x2, CFG_)
            }
            Device(FDC0) {
                Name(_HID, 0x0007d041)
                Method(_STA) {
                    ENFG()
                    Store(Zero, LDN_)
                    If(ACTR) {
                        EXFG()
                        Return(0xf)
                    }
                    Else {
                        If(LOr(IOAH, IOAL)) {
                            EXFG()
                            Return(0xd)
                        }
                        Else {
                            EXFG()
                            Return(0x0)
                        }
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x0, LDN_)
                    Store(Zero, ACTR)
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF0, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF0, 0x2, IOLO)
                    CreateByteField(BUF0, 0x3, IOHI)
                    CreateByteField(BUF0, 0x4, IORL)
                    CreateByteField(BUF0, 0x5, IORH)
                    CreateByteField(BUF0, 0xa, ILO1)
                    CreateByteField(BUF0, 0xb, IHI1)
                    CreateByteField(BUF0, 0xc, IRL1)
                    CreateByteField(BUF0, 0xd, IRH1)
                    CreateByteField(BUF0, 0x11, IRQL)
                    CreateByteField(BUF0, 0x14, DMAV)
                    ENFG()
                    Store(Zero, LDN_)
                    Store(One, ACTR)
                    Add(IOAL, 0x2, Local2)
                    Store(Local2, IOLO)
                    Store(Local2, IORL)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    Add(IOAL, 0x7, Local2)
                    Store(Local2, ILO1)
                    Store(Local2, IRL1)
                    Store(IOAH, IHI1)
                    Store(IOAH, IRH1)
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    Store(One, Local0)
                    ShiftLeft(Local0, DMCH, DMAV)
                    EXFG()
                    Return(BUF0)
                }
                Name(_PRS, Buffer(0x1a) {0x30, 0x47, 0x1, 0xf2, 0x3, 0xf2, 0x3, 0x0, 0x4, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x0, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateWordField(Arg0, 0x11, IRQL)
                    CreateByteField(Arg0, 0x14, DMAV)
                    ENFG()
                    Store(Zero, LDN_)
                    Store(0xf0, IOAL)
                    Store(IOHI, IOAH)
                    FindSetRightBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    FindSetRightBit(DMAV, Local0)
                    Subtract(Local0, 0x1, DMCH)
                    Store(One, ACTR)
                    EXFG()
                }
            }
            Device(UAR1) {
                Name(_HID, 0x0105d041)
                Name(_UID, 0x1)
                Method(_STA) {
                    ENFG()
                    Store(0x1, LDN_)
                    If(ACTR) {
                        EXFG()
                        Return(0xf)
                    }
                    Else {
                        If(LOr(IOAH, IOAL)) {
                            EXFG()
                            Return(0xd)
                        }
                        Else {
                            EXFG()
                            Return(0x0)
                        }
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x1, LDN_)
                    Store(Zero, ACTR)
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF1, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF1, 0x2, IOLO)
                    CreateByteField(BUF1, 0x3, IOHI)
                    CreateByteField(BUF1, 0x4, IORL)
                    CreateByteField(BUF1, 0x5, IORH)
                    CreateByteField(BUF1, 0x9, IRQL)
                    ENFG()
                    Store(0x1, LDN_)
                    Store(One, ACTR)
                    Store(IOAL, IOLO)
                    Store(IOAL, IORL)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    EXFG()
                    Return(BUF1)
                }
                Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateByteField(Arg0, 0x9, IRQL)
                    ENFG()
                    Store(0x1, LDN_)
                    Store(IOLO, IOAL)
                    Store(IOHI, IOAH)
                    FindSetRightBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    Store(One, ACTR)
                    EXFG()
                }
            }
            Device(UAR2) {
                Name(_HID, 0x0105d041)
                Name(_UID, 0x2)
                Method(_STA) {
                    ENFG()
                    Store(0x2, LDN_)
                    And(OPT2, 0x7, Local0)
                    If(LEqual(Local0, 0x0)) {
                        If(ACTR) {
                            EXFG()
                            Return(0xf)
                        }
                        Else {
                            If(LOr(IOAH, IOAL)) {
                                EXFG()
                                Return(0xd)
                            }
                            Else {
                                EXFG()
                                Return(0x0)
                            }
                        }
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x2, LDN_)
                    And(OPT2, 0x7, Local0)
                    If(LEqual(Local0, 0x0)) {
                        Store(Zero, ACTR)
                    }
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF2, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF2, 0x2, IOLO)
                    CreateByteField(BUF2, 0x3, IOHI)
                    CreateByteField(BUF2, 0x4, IORL)
                    CreateByteField(BUF2, 0x5, IORH)
                    CreateByteField(BUF2, 0x9, IRQL)
                    ENFG()
                    Store(0x2, LDN_)
                    Store(One, ACTR)
                    Store(IOAL, IOLO)
                    Store(IOAL, IORL)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    EXFG()
                    Return(BUF2)
                }
                Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateByteField(Arg0, 0x9, IRQL)
                    ENFG()
                    Store(0x2, LDN_)
                    Store(One, ACTR)
                    Store(IOLO, IOAL)
                    Store(IOHI, IOAH)
                    FindSetRightBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    EXFG()
                }
            }
            Device(IRDA) {
                Name(_HID, 0x1005d041)
                Method(_STA) {
                    ENFG()
                    Store(0x2, LDN_)
                    And(OPT2, 0x7, Local0)
                    If(LEqual(Local0, 0x1)) {
                        If(ACTR) {
                            EXFG()
                            Return(0xf)
                        }
                        Else {
                            If(LOr(IOAH, IOAL)) {
                                EXFG()
                                Return(0xd)
                            }
                            Else {
                                EXFG()
                                Return(0x0)
                            }
                        }
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x2, LDN_)
                    And(OPT2, 0x7, Local0)
                    If(LNot(LEqual(Local0, 0x0))) {
                        Store(Zero, ACTR)
                    }
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF3, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF3, 0x2, IOLO)
                    CreateByteField(BUF3, 0x3, IOHI)
                    CreateByteField(BUF3, 0x4, IORL)
                    CreateByteField(BUF3, 0x5, IORH)
                    CreateByteField(BUF3, 0x9, IRQL)
                    ENFG()
                    Store(0x2, LDN_)
                    Store(One, ACTR)
                    Store(IOAL, IOLO)
                    Store(IOAL, IORL)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    EXFG()
                    Return(BUF3)
                }
                Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateByteField(Arg0, 0x9, IRQL)
                    ENFG()
                    Store(0x2, LDN_)
                    Store(One, ACTR)
                    Store(IOLO, IOAL)
                    Store(IOHI, IOAH)
                    FindSetRightBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    EXFG()
                }
            }
            Device(LPT_) {
                Name(_HID, 0x0004d041)
                Method(_STA) {
                    ENFG()
                    Store(0x3, LDN_)
                    And(OPT1, 0x2, Local0)
                    If(LEqual(Local0, 0x0)) {
                        If(ACTR) {
                            EXFG()
                            Return(0xf)
                        }
                        Else {
                            If(LOr(IOAH, IOAL)) {
                                EXFG()
                                Return(0xd)
                            }
                            Else {
                                EXFG()
                                Return(0x0)
                            }
                        }
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x3, LDN_)
                    Store(Zero, ACTR)
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF5, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x22, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF5, 0x2, IOLO)
                    CreateByteField(BUF5, 0x3, IOHI)
                    CreateByteField(BUF5, 0x4, IORL)
                    CreateByteField(BUF5, 0x5, IORH)
                    CreateByteField(BUF5, 0x7, IOLN)
                    CreateByteField(BUF5, 0x9, IRQL)
                    ENFG()
                    Store(0x3, LDN_)
                    Store(One, ACTR)
                    Store(IOAL, IOLO)
                    Store(IOAL, IORL)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    If(LEqual(IOLO, 0xbc)) {
                        Store(0x4, IOLN)
                    }
                    Else {
                        Store(0x8, IOLN)
                    }
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    EXFG()
                    Return(BUF5)
                }
                Name(_PRS, Buffer(0x27) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x0, 0x8, 0x22, 0xb8, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x0, 0x4, 0x22, 0xb8, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateByteField(Arg0, 0x4, IORL)
                    CreateByteField(Arg0, 0x5, IORH)
                    CreateByteField(Arg0, 0x9, IRQL)
                    ENFG()
                    Store(0x3, LDN_)
                    Store(IOLO, IOAL)
                    Store(IOHI, IOAH)
                    FindSetLeftBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    Store(One, ACTR)
                    EXFG()
                }
            }
            Device(ECP_) {
                Name(_HID, 0x0104d041)
                Method(_STA) {
                    ENFG()
                    Store(0x3, LDN_)
                    And(OPT1, 0x2, Local0)
                    If(LEqual(Local0, 0x2)) {
                        If(ACTR) {
                            EXFG()
                            Return(0xf)
                        }
                        Else {
                            If(LOr(IOAH, IOAL)) {
                                EXFG()
                                Return(0xd)
                            }
                            Else {
                                EXFG()
                                Return(0x0)
                            }
                        }
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
                Method(_DIS) {
                    ENFG()
                    Store(0x3, LDN_)
                    Store(Zero, ACTR)
                    EXFG()
                }
                Method(_CRS) {
                    Name(BUF6, Buffer(0x18) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x2a, 0x0, 0x0, 0x79, 0x0 })
                    CreateByteField(BUF6, 0x2, IOLO)
                    CreateByteField(BUF6, 0x3, IOHI)
                    CreateByteField(BUF6, 0x4, IORL)
                    CreateByteField(BUF6, 0x5, IORH)
                    CreateByteField(BUF6, 0x7, IOLN)
                    CreateByteField(BUF6, 0xa, IOEL)
                    CreateByteField(BUF6, 0xb, IOEH)
                    CreateByteField(BUF6, 0xc, IOML)
                    CreateByteField(BUF6, 0xd, IOMH)
                    CreateByteField(BUF6, 0xf, IOHN)
                    CreateByteField(BUF6, 0x11, IRQL)
                    CreateByteField(BUF6, 0x14, DMAC)
                    ENFG()
                    Store(0x3, LDN_)
                    Store(One, ACTR)
                    Store(IOAL, IOLO)
                    Store(IOAL, IORL)
                    Store(IOAL, IOEL)
                    Store(IOAL, IOML)
                    Store(IOAH, IOHI)
                    Store(IOAH, IORH)
                    Store(IOAH, Local3)
                    Or(Local3, 0x4, Local3)
                    Store(Local3, IOEH)
                    Store(Local3, IOMH)
                    If(LEqual(IOLO, 0xbc)) {
                        Store(0x4, IOLN)
                        Store(0x4, IOHN)
                    }
                    Else {
                        Store(0x8, IOLN)
                        Store(0x4, IOHN)
                    }
                    Store(One, Local0)
                    ShiftLeft(Local0, INTR, IRQL)
                    Store(One, Local0)
                    ShiftLeft(Local0, DMCH, DMAC)
                    EXFG()
                    Return(BUF6)
                }
                Name(_PRS, Buffer(0x48) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x0, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x0, 0x4, 0x22, 0xb8, 0x0, 0x2a, 0xb, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x0, 0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x0, 0x4, 0x22, 0xb8, 0x0, 0x2a, 0xb, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x0, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x0, 0x4, 0x22, 0xb8, 0x0, 0x2a, 0xb, 0x0, 0x38, 0x79, 0x0 })
                Method(_SRS, 1) {
                    CreateByteField(Arg0, 0x2, IOLO)
                    CreateByteField(Arg0, 0x3, IOHI)
                    CreateByteField(Arg0, 0x11, IRQL)
                    CreateByteField(Arg0, 0x14, DMAC)
                    ENFG()
                    Store(0x3, LDN_)
                    Store(One, ACTR)
                    Store(IOLO, IOAL)
                    Store(IOHI, IOAH)
                    FindSetLeftBit(IRQL, Local0)
                    Subtract(Local0, 0x1, INTR)
                    FindSetLeftBit(DMAC, Local1)
                    Subtract(Local1, 0x1, DMCH)
                    EXFG()
                }
            }
            Device(PS2M) {
                Name(_HID, 0x130fd041)
                Method(_STA) {
                    And(FLG0, 0x4, Local0)
                    If(LEqual(Local0, 0x4)) {
                        Return(0xf)
                    }
                    Else {
                        Return(0x0)
                    }
                }
                Name(_CRS, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
            }
            Device(PS2K) {
                Name(_HID, 0x0303d041)
                Method(_STA) {
                    If(LEqual(KBDI, 0x1)) {
                        Return(0x0)
                    }
                    Else {
                        Return(0xf)
                    }
                }
                Name(_CRS, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x2, 0x0, 0x79, 0x0 })
            }
        }
        Name(_PRW, Package(0x2) {
            0x9,
            0x1,
        })
    }
}

}

--y0ulUmNC+osPPQO6--

To Unsubscribe: send mail to majordomo@FreeBSD.org
with "unsubscribe freebsd-current" in the body of the message




Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20021130123334.GA397>