From owner-acpi-jp@jp.FreeBSD.org Fri Feb 28 19:02:59 2003
Received: (from daemon@localhost)
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) id h1SA2xj17526;
	Fri, 28 Feb 2003 19:02:59 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from web11406.mail.yahoo.com (web11406.mail.yahoo.com [216.136.131.236])
	by castle.jp.FreeBSD.org (8.11.6+3.4W/8.11.3) with SMTP/inet id h1SA2vi17521
	for <acpi-jp@jp.FreeBSD.org>; Fri, 28 Feb 2003 19:02:57 +0900 (JST)
	(envelope-from shizukakudo_99@yahoo.com)
Message-ID: <20030228100256.53626.qmail@web11406.mail.yahoo.com>
Received: from [219.76.96.9] by web11406.mail.yahoo.com via HTTP; Fri, 28 Feb 2003 02:02:56 PST
From: Shizuka Kudo <shizukakudo_99@yahoo.com>
To: acpi-jp@jp.FreeBSD.org
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Reply-To: acpi-jp@jp.FreeBSD.org
Precedence: list
Date: Fri, 28 Feb 2003 02:02:56 -0800
X-Sequence: acpi-jp 2097
Subject: [acpi-jp 2097] psm0 / lpt0 problem with -current ACPI
Errors-To: owner-acpi-jp@jp.FreeBSD.org
Sender: owner-acpi-jp@jp.FreeBSD.org
X-Originator: shizukakudo_99@yahoo.com
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+030107

I recently plugged my ps/2 mouse to a freebsd-current box and observed the following problem:

The system seems to lost tracking of the cursor when I was moving the mouse.  Running "moused -d
-f -p /dev/psm0" confirmed this as the rate of printing the mouse movement is much less than in
normal case. If I did not load acpi.ko, the mouse is working fine.  A parallel printer attached to
this box was also not working OK.  By printing a test page from CUPS, the printer is receiving
data, but it seems never finish and the normal "stray irq 7" message doesn't come out.

Since I was able to use my mouse on this box last year with ACPI enabled, I had started a binary
search of the breaking point and finally found that this issue is related to a commit on 31 Oct
2002.

  Don't examine ACPI_STA_ENABLE bit of device's_STA object on initial
  state.  Instead, use ACPI_STA_PRESENT and ACPI_STA_FUNCTIONAL for it.
  In some ACPI BIOS implementations, boot disabled devices don't have
  ACPI_STA_ENABLE bit in _STA object.
  Also it is not fatal if getting current IRQ of boot disabled devices
  is failed in initial state.

If I reverted to test ACPI_STA_ENABLE, my mouse and printer started working normally.  Is this
unique to my motherboard, which is an i815EP with 256M RAM?

Anything I need to provide to help trouble-shooting?

Regards,

Here's the output of acpidump & dmesg before I reverted back to ACPI_STA_ENABLE.


/*
RSD PTR: Checksum=85, OEMID=IntelR, RsdtAddress=0x0fff3000
 */
/*
RSDT: Length=40, Revision=1, Checksum=149,
	OEMID=IntelR, OEM Table ID=AWRDACPI, OEM Revision=0x30302e32,
	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=0x0
	PM1a_EVT_BLK=0x4000-0x4003
	PM1a_CNT_BLK=0x4004-0x4005
	PM2_TMR_BLK=0x4008-0x400b
	PM2_GPE0_BLK=0x402c-0x402f
	PM2_GPE1_BLK=0x4028-0x402b, GPE1_BASE=16
	P_LVL2_LAT=90ms, P_LVL3_LAT=900ms
	FLUSH_SIZE=0, FLUSH_STRIDE=0
	DUTY_OFFSET=1, DUTY_WIDTH=1
	DAY_ALRM=13, MON_ALRM=0, CENTURY=0
	Flags={WBINVD,PROC_C1,SLP_BUTTON}
 */
/*
DSDT: Length=15430, Revision=1, Checksum=153,
	OEMID=INTELR, OEM Table ID=AWRDACPI, OEM Revision=0x1000,
	Creator ID=MSFT, Creator Revision=0x100000c
 */
DefinitionBlock (
    "acpi_dsdt.aml",	//Output filename
    "DSDT",		//Signature
    0x1,		//DSDT Revision
    "INTELR",		//OEMID
    "AWRDACPI",		//TABLE ID
    0x1000		//OEM Revision
)

{
Scope(\_PR_) {
    Processor(\_PR_.CPU0, 1, 0x4010, 0x6) {
    }
}
OperationRegion(CM72, SystemIO, 0x72, 0x2)
Field(CM72, ByteAcc, NoLock, Preserve) {
    CI72,	8,
    CO73,	8
}
IndexField(CI72, CO73, ByteAcc, NoLock, Preserve) {
    Offset(0x50),
    SUSF,	8
}
Name(FLAG, 0x0)
Name(STAT, 0x0)
Name(\_S0_, Package(0x4) {
    0x0,
    0x0,
    0x0,
    0x0,
})
OperationRegion(CMOS, SystemIO, 0x70, 0x2)
Field(CMOS, ByteAcc, NoLock, Preserve) {
    INX_,	8,
    DTA_,	8
}
And(SUSF, 0x2, STAT)
Name(\_S1_, Package(0x4) {
    0x1,
    0x0,
    0x0,
    0x0,
})
Name(\_S4_, Package(0x4) {
    0x6,
    0x0,
    0x0,
    0x0,
})
Name(\_S5_, Package(0x4) {
    0x7,
    0x0,
    0x0,
    0x0,
})
OperationRegion(\DEBG, SystemIO, 0x80, 0x1)
Field(\DEBG, ByteAcc, NoLock, Preserve) {
    DBG1,	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(\SMIC, SystemIO, 0xb2, 0x1)
Field(\SMIC, ByteAcc, NoLock, Preserve) {
    SCP_,	8
}
OperationRegion(\PM1S, SystemIO, 0x4000, 0x4)
Field(\PM1S, ByteAcc, NoLock, Preserve) {
    PM00,	8,
    PM01,	8,
    PM02,	8,
    PM03,	8
}
OperationRegion(\SPEN, SystemIO, 0x4030, 0x1)
Field(\SPEN, ByteAcc, NoLock, Preserve) {
    ,	4,
    TRAP,	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(\GPO_, SystemIO, 0x408e, 0x2)
Field(\GPO_, ByteAcc, NoLock, Preserve) {
    GO10,	1,
    GO11,	1,
    GO12,	1,
    GO13,	1,
    GO14,	1,
    GO15,	1,
    GO16,	1,
    GO17,	1,
    GO18,	1,
    GO19,	1,
    GO1A,	1,
    GO1B,	1,
    GO1C,	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,
    PS2F,	1,
    IRFL,	2,
    DISE,	1,
    SSHU,	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_)
}
Scope(\) {
    Name(PICF, 0x0)
}
Method(\_PTS, 1) {
    Or(Arg0, 0xf0, Local0)
    Store(Local0, DBG1)
    If(LEqual(Arg0, 0x1)) {
        Store(Arg0, Local0)
        SALD(Local0)
        SFAN(Zero)
    }
    If(LEqual(Arg0, 0x2)) {
    }
    If(LEqual(Arg0, 0x3)) {
        Store(Arg0, Local0)
        SALD(Local0)
    }
    If(LEqual(Arg0, 0x5)) {
        Store(ESMI, Local0)
        And(Local0, 0xfb, Local0)
        Store(Local0, ESMI)
        Store(Arg0, Local0)
        SALD(Local0)
    }
    If(LEqual(Arg0, 0x4)) {
        If(LNot(PICF)) {
            Sleep(0x64)
        }
    }
}
Method(\_WAK, 1) {
    Store(0xff, DBG1)
    SALD(0x0)
    SFAN(0xff)
    Notify(\_SB_.PCI0.UAR1, 0x0)
    If(OSFL) {
        Notify(\_SB_.PWRB, 0x2)
    }
    Else {
        If(LEqual(RTCW, 0x0)) {
            Notify(\_SB_.PWRB, 0x2)
        }
    }
}
Scope(\_SI_) {
    Method(_MSG, 1) {
        Store(Local0, Local0)
    }
    Method(_SST, 1) {
        Store(Local0, Local0)
    }
}
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)
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,
    DATS,	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)
    If(LGreater(Local3, 0x0e8a)) {
        Store(0x0aac, Local3)
    }
    SBYT(0x4e, Local0)
    Return(Local3)
}
Method(SBYT, 2) {
    Store(Arg0, INDX)
    Store(Arg1, DATS)
}
Method(GBYT, 1) {
    Store(Arg0, INDX)
    Store(DATS, Local7)
    Return(Local7)
}
Method(SFAN, 1) {
    SBYT(0x5a, Arg0)
}
Scope(\_TZ_) {
    Device(FAN_) {
        Name(_HID, 0x0b0cd041)
        Method(_INI) {
            Store(TP1H, CTOS)
            Store(TP1L, CTHY)
        }
    }
    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, 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) {
    Method(_L13) {
        Notify(\_SB_.PCI0.USB0, 0x2)
    }
    Method(_L14) {
        Notify(\_SB_.PCI0.USB1, 0x2)
    }
    Method(_L1B) {
        Notify(\_SB_.PCI0, 0x2)
    }
    Method(_L18) {
        Notify(\_SB_.PCI0.UAR1, 0x2)
    }
}
Scope(\_SB_) {
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Method(_STA) {
            Return(0xb)
        }
    }
    Device(MEM_) {
        Name(_HID, 0x010cd041)
        Method(_CRS) {
            Name(BUF0, Buffer(0x86) {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, 0x0,
0x0, 0x0, 0x0, 0xa, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9,
0x0, 0x1, 0x0, 0x0, 0xe0, 0xfe, 0x0, 0x10, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xb0, 0xff,
0x0, 0x0, 0x8, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xf0, 0xff, 0x0, 0x0, 0x10, 0x0, 0x86, 0x9,
0x0, 0x1, 0x0, 0x0, 0xe, 0x0, 0x0, 0x0, 0x1, 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, 0x50, 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)
        Name(_UID, 0x1)
        Name(_BBN, 0x0)
        Method(SS3D) {
            If(LEqual(OSFL, 0x2)) {
                Return(0x2)
            }
            Else {
                Return(0x3)
            }
        }
        Method(_STA) {
            Return(0xf)
        }
        Method(_CRS) {
            Name(BUF0, Buffer(0xb0) {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, 0xf8, 0x88, 0xd, 0x0, 0x1,
0xc, 0x3, 0x0, 0x0, 0xf8, 0x40, 0xff, 0x4f, 0x0, 0x0, 0x8, 0xf, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3,
0x0, 0x0, 0x0, 0x50, 0xff, 0xff, 0x0, 0x0, 0x0, 0xb0, 0x87, 0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x87,
0x17, 0x0, 0x0, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 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, 0x9e, TCMM)
            CreateDWordField(BUF0, 0xaa, TOMM)
            Add(AMEM, 0x00010000, TCMM)
            Subtract(0xfff00000, TCMM, TOMM)
            Return(BUF0)
        }
        Name(_PRT, Package(0x10) {
            Package(0x4) {
                0x001effff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x001effff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x001effff,
                0x2,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x001effff,
                0x3,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x2,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0002ffff,
                0x3,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x2,
                \_SB_.PCI0.LNK1,
                0x0,
            },
            Package(0x4) {
                0x001fffff,
                0x3,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x2,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0001ffff,
                0x3,
                \_SB_.PCI0.LNKD,
                0x0,
            },
        })
        Device(HUB0) {
            Name(_ADR, 0x001e0000)
            Method(_STA) {
                Return(0xf)
            }
            Name(_PRT, Package(0x1c) {
                Package(0x4) {
                    0x0008ffff,
                    0x0,
                    \_SB_.PCI0.LNKE,
                    0x0,
                },
                Package(0x4) {
                    0x0008ffff,
                    0x1,
                    \_SB_.PCI0.LNKF,
                    0x0,
                },
                Package(0x4) {
                    0x0008ffff,
                    0x2,
                    \_SB_.PCI0.LNK0,
                    0x0,
                },
                Package(0x4) {
                    0x0008ffff,
                    0x3,
                    \_SB_.PCI0.LNK1,
                    0x0,
                },
                Package(0x4) {
                    0x0001ffff,
                    0x0,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x0001ffff,
                    0x1,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0001ffff,
                    0x2,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0001ffff,
                    0x3,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
                Package(0x4) {
                    0xffff,
                    0x0,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
                Package(0x4) {
                    0xffff,
                    0x1,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0xffff,
                    0x2,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0xffff,
                    0x3,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0003ffff,
                    0x0,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0003ffff,
                    0x1,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x0003ffff,
                    0x2,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x0003ffff,
                    0x3,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x0,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x1,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x2,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x0002ffff,
                    0x3,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x0004ffff,
                    0x0,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
                Package(0x4) {
                    0x0004ffff,
                    0x1,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x0004ffff,
                    0x2,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0004ffff,
                    0x3,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0005ffff,
                    0x0,
                    \_SB_.PCI0.LNKB,
                    0x0,
                },
                Package(0x4) {
                    0x0005ffff,
                    0x1,
                    \_SB_.PCI0.LNKC,
                    0x0,
                },
                Package(0x4) {
                    0x0005ffff,
                    0x2,
                    \_SB_.PCI0.LNKD,
                    0x0,
                },
                Package(0x4) {
                    0x0005ffff,
                    0x3,
                    \_SB_.PCI0.LNKA,
                    0x0,
                },
            })
            Method(_PRW) {
                Return(Package(0x2) {
                    0x1b,
                    0x5,
                })
            }
        }
        Device(PX40) {
            Name(_ADR, 0x001f0000)
            OperationRegion(PREV, PCI_Config, 0x8, 0x1)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.PREV, ByteAcc, NoLock, Preserve) {
                    REV0,	8
                }
            }
            OperationRegion(PIRQ, PCI_Config, 0x60, 0x4)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.PIRQ, ByteAcc, NoLock, Preserve) {
                    PIRA,	8,
                    PIRB,	8,
                    PIRC,	8,
                    PIRD,	8
                }
            }
            OperationRegion(PIR2, PCI_Config, 0x68, 0x4)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.PIR2, ByteAcc, NoLock, Preserve) {
                    PIRE,	8,
                    PIRF,	8,
                    PIRG,	8,
                    PIRH,	8
                }
            }
            OperationRegion(LPIO, PCI_Config, 0xe0, 0xe)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.LPIO, ByteAcc, NoLock, Preserve) {
                    UAIO,	8,
                    PRIO,	8,
                    SNDD,	8,
                    FWHD,	8,
                    GN1L,	8,
                    GN1H,	8,
                    LPE1,	8,
                    LPE2,	8,
                    Offset(0xc),
                    GN2L,	8,
                    GN2H,	8
                }
                Method(DISD, 1) {
                    If(LEqual(Arg0, 0x0)) {
                        And(LPE1, 0xfe, LPE1)
                    }
                    If(LEqual(Arg0, 0x1)) {
                        And(LPE1, 0xfd, LPE1)
                    }
                    If(LEqual(Arg0, 0x2)) {
                        And(LPE1, 0xfb, LPE1)
                    }
                    If(LEqual(Arg0, 0x3)) {
                        And(LPE1, 0xf7, LPE1)
                    }
                    If(LEqual(Arg0, 0x4)) {
                        And(LPE2, 0xfc, LPE2)
                    }
                    If(LEqual(Arg0, 0x5)) {
                        And(LPE1, 0xdf, LPE1)
                    }
                    If(LEqual(Arg0, 0x6)) {
                        And(GN2L, 0xfe, GN2L)
                    }
                }
                Method(CKIO, 2) {
                    If(LEqual(Arg1, 0x0)) {
                        Or(LPE1, 0x1, LPE1)
                        And(UAIO, 0xf0, Local0)
                        If(LEqual(Arg0, 0x03f8)) {
                            Or(Local0, 0x0, UAIO)
                        }
                        If(LEqual(Arg0, 0x02f8)) {
                            Or(Local0, 0x1, UAIO)
                        }
                        If(LEqual(Arg0, 0x02e8)) {
                            Or(Local0, 0x5, UAIO)
                        }
                        If(LEqual(Arg0, 0x03e8)) {
                            Or(Local0, 0x7, UAIO)
                        }
                    }
                    If(LEqual(Arg1, 0x1)) {
                        Or(LPE1, 0x2, LPE1)
                        And(UAIO, 0xf, Local0)
                        If(LEqual(Arg0, 0x03f8)) {
                            Or(Local0, 0x0, UAIO)
                        }
                        If(LEqual(Arg0, 0x02f8)) {
                            Or(Local0, 0x10, UAIO)
                        }
                        If(LEqual(Arg0, 0x02e8)) {
                            Or(Local0, 0x50, UAIO)
                        }
                        If(LEqual(Arg0, 0x03e8)) {
                            Or(Local0, 0x70, UAIO)
                        }
                    }
                    If(LEqual(Arg1, 0x2)) {
                        Or(LPE1, 0x4, LPE1)
                        And(PRIO, 0xfc, Local0)
                        If(LEqual(Arg0, 0x0378)) {
                            Or(Local0, 0x0, PRIO)
                        }
                        If(LEqual(Arg0, 0x0278)) {
                            Or(Local0, 0x1, PRIO)
                        }
                        If(LEqual(Arg0, 0x03bc)) {
                            Or(Local0, 0x2, PRIO)
                        }
                    }
                    If(LEqual(Arg1, 0x3)) {
                        Or(LPE1, 0x8, LPE1)
                    }
                    If(LEqual(Arg1, 0x4)) {
                        If(LEqual(Arg0, 0x0201)) {
                            Or(LPE2, 0x1, LPE2)
                        }
                        If(LEqual(Arg0, 0x0209)) {
                            Or(LPE2, 0x2, LPE2)
                        }
                    }
                    If(LEqual(Arg1, 0x5)) {
                        Or(LPE1, 0x20, LPE1)
                        If(LEqual(Arg0, 0x0300)) {
                            Or(SNDD, 0x8, SNDD)
                        }
                        If(LEqual(Arg0, 0x0330)) {
                            And(SNDD, 0xf7, SNDD)
                        }
                    }
                    If(LEqual(Arg1, 0x6)) {
                        If(LNot(LEqual(Arg0, 0xffff))) {
                            And(Arg0, 0xff, Local0)
                            Or(Local0, 0x1, GN2L)
                            ShiftRight(Arg0, 0x8, GN2H)
                        }
                        Else {
                            Store(Zero, GN2H)
                            Store(Zero, GN2L)
                        }
                    }
                }
            }
            OperationRegion(LPDM, PCI_Config, 0x90, 0x2)
            Scope(\) {
                Field(\_SB_.PCI0.PX40.LPDM, ByteAcc, NoLock, Preserve) {
                    LDM0,	8,
                    LDM1,	8
                }
                Method(SLDM, 2) {
                    If(LEqual(Arg0, 0x0)) {
                        And(LDM0, 0xfc, Local0)
                        Or(Local0, 0x1, LDM0)
                    }
                    If(LEqual(Arg0, 0x1)) {
                        And(LDM0, 0xf3, Local0)
                        Or(Local0, 0x4, LDM0)
                    }
                    If(LEqual(Arg0, 0x2)) {
                        And(LDM0, 0xcf, Local0)
                        Or(Local0, 0x10, LDM0)
                    }
                    If(LEqual(Arg0, 0x3)) {
                        And(LDM0, 0x3f, Local0)
                        Or(Local0, 0x40, LDM0)
                    }
                    If(LEqual(Arg1, 0x0)) {
                        And(LDM0, 0xfc, Local0)
                        Or(Local0, 0x3, LDM0)
                    }
                    If(LEqual(Arg1, 0x1)) {
                        And(LDM0, 0xf3, Local0)
                        Or(Local0, 0xc, LDM0)
                    }
                    If(LEqual(Arg1, 0x2)) {
                        And(LDM0, 0xcf, Local0)
                        Or(Local0, 0x30, LDM0)
                    }
                    If(LEqual(Arg1, 0x3)) {
                        And(LDM0, 0x3f, Local0)
                        Or(Local0, 0xc0, LDM0)
                    }
                }
            }
        }
        Device(USB0) {
            Name(_ADR, 0x001f0002)
            Method(SS3D) {
                If(LEqual(OSFL, 0x2)) {
                    Return(0x2)
                }
                Return(0x3)
            }
            Method(_PRW) {
                Return(Package(0x2) {
                    0x13,
                    0x3,
                })
            }
        }
        Device(USB1) {
            Name(_ADR, 0x001f0004)
            Method(SS3D) {
                If(LEqual(OSFL, 0x2)) {
                    Return(0x2)
                }
                Return(0x3)
            }
            Method(_PRW) {
                Return(Package(0x2) {
                    0x14,
                    0x3,
                })
            }
        }
        Device(ICHX) {
            Name(_ADR, 0x001f0001)
            OperationRegion(PCI_, PCI_Config, 0x40, 0x20)
            Field(PCI_, DWordAcc, NoLock, Preserve) {
                ITM0,	16,
                ITM1,	16,
                SIT0,	4,
                SIT1,	4,
                Offset(0x8),
                UDC0,	2,
                UDC1,	2,
                Offset(0xa),
                UDT0,	8,
                UDT1,	8,
                Offset(0x14),
                ICF0,	2,
                ICF1,	2,
                ,	6,
                WPPE,	1,
                ,	1,
                FAS0,	2,
                FAS1,	2
            }
            Method(GTM_, 6) {
                Store(Buffer(0x14) { }, Local0)
                CreateDWordField(Local0, 0x0, PIO0)
                CreateDWordField(Local0, 0x4, DMA0)
                CreateDWordField(Local0, 0x8, PIO1)
                CreateDWordField(Local0, 0xc, DMA1)
                CreateDWordField(Local0, 0x10, FLAG)
                Store(0x10, FLAG)
                If(LOr(And(Arg0, 0x8, ), LNot(And(Arg0, 0x1, )))) {
                    Store(0x0384, PIO0)
                }
                Else {
                    Add(ShiftRight(And(Arg0, 0x0300, ), 0x8, ), ShiftRight(And(Arg0, 0x3000, ),
0xc, ), Local1)
                    Multiply(Subtract(0x9, Local1, ), 0x1e, PIO0)
                }
                If(LOr(LAnd(Arg0, 0x4000), LAnd(Arg2, 0x1))) {
                    If(LOr(And(Arg0, 0x80, ), LNot(And(Arg0, 0x10, )))) {
                        Store(0x0384, PIO1)
                    }
                    Else {
                        Add(And(Arg1, 0x3, ), ShiftRight(And(Arg1, 0xc, ), 0x2, ), Local1)
                        Multiply(Subtract(0x9, Local1, ), 0x1e, PIO1)
                    }
                }
                Else {
                    Store(PIO0, PIO1)
                }
                If(And(Arg2, 0x1, )) {
                    Subtract(0x4, And(Arg3, 0x3, ), Local1)
                    If(And(Arg5, 0x1, )) {
                        Store(0x14, DMA0)
                    }
                    Else {
                        If(And(Arg4, 0x1, )) {
                            Multiply(Local1, 0xf, DMA0)
                        }
                        Else {
                            Multiply(Local1, 0x1e, DMA0)
                        }
                    }
                }
                Else {
                    Store(PIO0, DMA0)
                }
                If(LOr(LAnd(Arg0, 0x4000), LAnd(Arg2, 0x1))) {
                    If(And(Arg2, 0x2, )) {
                        Subtract(0x4, ShiftRight(And(Arg3, 0x30, ), 0x4, ), Local1)
                        If(And(Arg5, 0x2, )) {
                            Store(0x14, DMA1)
                        }
                        Else {
                            If(And(Arg4, 0x2, )) {
                                Multiply(Local1, 0xf, DMA1)
                            }
                            Else {
                                Multiply(Local1, 0x1e, DMA1)
                            }
                        }
                    }
                    Else {
                        Store(PIO1, DMA1)
                    }
                }
                Else {
                    Store(DMA0, DMA1)
                }
                Store(Zero, FLAG)
                If(And(Arg0, 0x1, )) {
                    Or(FLAG, 0x10, FLAG)
                }
                If(And(Arg2, 0x1, )) {
                    Or(FLAG, 0x1, FLAG)
                }
                If(And(Arg0, 0x2, )) {
                    Or(FLAG, 0x2, FLAG)
                }
                If(And(Arg2, 0x2, )) {
                    Or(FLAG, 0x4, FLAG)
                }
                If(And(Arg0, 0x20, )) {
                    Or(FLAG, 0x8, FLAG)
                }
                Return(Local0)
            }
            Method(STM_, 3) {
                Store(Buffer(0x18) { }, Local7)
                CreateDWordField(Local7, 0x0, ITM_)
                CreateDWordField(Local7, 0x4, SIT_)
                CreateDWordField(Local7, 0x8, UDC_)
                CreateDWordField(Local7, 0xc, UDT_)
                CreateDWordField(Local7, 0x10, ICF_)
                CreateDWordField(Local7, 0x14, FAS_)
                CreateDWordField(Arg0, 0x0, PIO0)
                CreateDWordField(Arg0, 0x4, DMA0)
                CreateDWordField(Arg0, 0x8, PIO1)
                CreateDWordField(Arg0, 0xc, DMA1)
                CreateDWordField(Arg0, 0x10, FLAG)
                Store(FLAG, Local4)
                Store(0x8000, Local0)
                If(And(Local4, 0x2, )) {
                    Or(Local0, 0x7, Local0)
                }
                If(And(Local4, 0x8, )) {
                    Or(Local0, 0x4000, Local0)
                    Or(Local0, 0x70, Local0)
                }
                If(LAnd(LLess(DMA0, PIO0), LNot(And(Local4, 0x1, )))) {
                    Or(Local0, 0x8, Local0)
                }
                If(LAnd(LLess(DMA1, PIO1), LNot(And(Local4, 0x4, )))) {
                    Or(Local0, 0x80, Local0)
                }
                If(PIO0) {
                    If(LLess(PIO0, 0x0384)) {
                        Or(Local0, 0x1, Local0)
                    }
                }
                If(PIO1) {
                    If(LLess(PIO1, 0x0384)) {
                        Or(Local0, 0x10, Local0)
                    }
                }
                If(And(Local4, 0x1, )) {
                    Store(PIO0, Local1)
                }
                Else {
                    Store(DMA0, Local1)
                }
                If(Local1) {
                    If(LNot(LGreater(Local1, 0x78))) {
                        Or(Local0, 0x2300, Local0)
                    }
                    Else {
                        If(LNot(LGreater(Local1, 0xb4))) {
                            Or(Local0, 0x2100, Local0)
                        }
                        Else {
                            If(LNot(LGreater(Local1, 0xf0))) {
                                Or(Local0, 0x1000, Local0)
                            }
                        }
                    }
                }
                Store(Local0, ITM_)
                Store(Zero, Local0)
                If(And(Local4, 0x4, )) {
                    Store(PIO1, Local1)
                }
                Else {
                    Store(DMA1, Local1)
                }
                If(Local1) {
                    If(LNot(LGreater(Local1, 0x78))) {
                        Store(0xb, Local0)
                    }
                    Else {
                        If(LNot(LGreater(Local1, 0xb4))) {
                            Store(0x9, Local0)
                        }
                        Else {
                            If(LNot(LGreater(Local1, 0xf0))) {
                                Store(0x4, Local0)
                            }
                        }
                    }
                }
                Store(Local0, SIT_)
                Store(0x0, Local0)
                If(And(Local4, 0x1, )) {
                    Or(Local0, 0x1, Local0)
                }
                If(And(Local4, 0x4, )) {
                    Or(Local0, 0x2, Local0)
                }
                Store(Local0, UDC_)
                Store(0x0, Local0)
                If(And(Local4, 0x1, )) {
                    If(LEqual(DMA0, 0x14)) {
                        Store(0x1, Local0)
                    }
                    Else {
                        If(LLess(DMA0, 0x3c)) {
                            Divide(DMA0, 0xf, , Local1)
                        }
                        Else {
                            Divide(DMA0, 0x1e, , Local1)
                        }
                        Subtract(0x4, Local1, Local0)
                    }
                }
                If(And(Local4, 0x4, )) {
                    If(LEqual(DMA1, 0x14)) {
                        Store(0x1, Local1)
                    }
                    Else {
                        If(LLess(DMA1, 0x3c)) {
                            Divide(DMA1, 0xf, , Local1)
                        }
                        Else {
                            Divide(DMA1, 0x1e, , Local1)
                        }
                        Subtract(0x4, Local1, Local1)
                    }
                    ShiftLeft(Local1, 0x4, Local1)
                    Or(Local0, Local1, Local0)
                }
                Store(Local0, UDT_)
                Store(0x0, Local0)
                If(DMA0) {
                    If(LGreater(DMA0, 0x14)) {
                        If(LLess(DMA0, 0x3c)) {
                            Or(Local0, 0x1, Local0)
                        }
                    }
                }
                If(DMA1) {
                    If(LGreater(DMA1, 0x14)) {
                        If(LLess(DMA1, 0x3c)) {
                            Or(Local0, 0x2, Local0)
                        }
                    }
                }
                Store(Local0, ICF_)
                Store(0x0, Local0)
                If(LEqual(DMA0, 0x14)) {
                    Or(Local0, 0x1, Local0)
                }
                If(LEqual(DMA1, 0x14)) {
                    Or(Local0, 0x2, Local0)
                }
                Store(Local0, FAS_)
                Return(Local7)
            }
            Method(H15P, 1) {
                Name(BUFF, Buffer(0x8) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
                Store(Arg0, Local0)
                Store(BUFF, Local1)
                Concatenate(Local0, Local1, Local7)
                CreateWordField(Local7, 0x2, CYL_)
                CreateWordField(Local7, 0x6, HEAD)
                CreateWordField(Local7, 0xc, SPT_)
                If(LAnd(LNot(LLess(HEAD, 0x10)), LNot(LLess(CYL_, 0x2000)))) {
                    Return(SPT_)
                }
                Else {
                    Return(Zero)
                }
            }
            Method(GTF0, 7) {
                Store(Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef }, Local7)
                CreateByteField(Local7, 0x1, MODE)
                If(And(Arg2, 0x1, )) {
                    And(Arg3, 0x3, Local0)
                    If(And(Arg6, 0x1, )) {
                        Add(Local0, 0x4, Local0)
                    }
                    Else {
                        If(And(Arg4, 0x1, )) {
                            Add(Local0, 0x2, Local0)
                        }
                    }
                    Or(Local0, 0x40, MODE)
                }
                Else {
                    Add(ShiftRight(And(Arg0, 0x0300, ), 0x8, ), ShiftRight(And(Arg0, 0x3000, ),
0xc, ), Local0)
                    If(LNot(LLess(Local0, 0x5))) {
                        Store(0x22, MODE)
                    }
                    Else {
                        If(LNot(LLess(Local0, 0x3))) {
                            Store(0x21, MODE)
                        }
                        Else {
                            Store(0x20, MODE)
                        }
                    }
                }
                Concatenate(Local7, Local7, Local6)
                If(LOr(And(Arg0, 0x8, ), LNot(And(Arg0, 0x1, )))) {
                    If(And(Arg0, 0x2, )) {
                        Store(0x0, MODE)
                    }
                    Else {
                        Store(0x1, MODE)
                    }
                }
                Else {
                    Add(ShiftRight(And(Arg0, 0x0300, ), 0x8, ), ShiftRight(And(Arg0, 0x3000, ),
0xc, ), Local0)
                    If(LNot(LLess(Local0, 0x5))) {
                        Store(0xc, MODE)
                    }
                    Else {
                        If(LNot(LLess(Local0, 0x3))) {
                            Store(0xb, MODE)
                        }
                        Else {
                            Store(0xa, MODE)
                        }
                    }
                }
                Concatenate(Local6, Local7, Local5)
                If(Arg5) {
                    Store(Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0xae, 0x91 }, Local4)
                    CreateByteField(Local4, 0x1, SPT_)
                    Store(Arg5, SPT_)
                    Concatenate(Local5, Local4, Local6)
                    Return(Local6)
                }
                Else {
                    Return(Local5)
                }
            }
            Method(GTF1, 7) {
                Store(Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0xb0, 0xef }, Local7)
                CreateByteField(Local7, 0x1, MODE)
                If(And(Arg2, 0x2, )) {
                    ShiftRight(And(Arg3, 0x30, ), 0x4, Local0)
                    If(And(Arg6, 0x2, )) {
                        Add(Local0, 0x4, Local0)
                    }
                    Else {
                        If(And(Arg4, 0x2, )) {
                            Add(Local0, 0x2, Local0)
                        }
                    }
                    Or(Local0, 0x40, MODE)
                }
                Else {
                    Add(ShiftRight(And(Arg1, 0x3, ), 0x2, ), And(Arg1, 0xc, ), Local0)
                    If(LNot(LLess(Local0, 0x5))) {
                        Store(0x22, MODE)
                    }
                    Else {
                        If(LNot(LLess(Local0, 0x3))) {
                            Store(0x21, MODE)
                        }
                        Else {
                            Store(0x20, MODE)
                        }
                    }
                }
                Concatenate(Local7, Local7, Local6)
                If(LOr(And(Arg0, 0x80, ), LNot(And(Arg0, 0x10, )))) {
                    If(And(Arg0, 0x20, )) {
                        Store(0x0, MODE)
                    }
                    Else {
                        Store(0x1, MODE)
                    }
                }
                Else {
                    Add(ShiftRight(And(Arg1, 0x3, ), 0x2, ), And(Arg1, 0xc, ), Local0)
                    If(LNot(LLess(Local0, 0x5))) {
                        Store(0xc, MODE)
                    }
                    Else {
                        If(LNot(LLess(Local0, 0x3))) {
                            Store(0xb, MODE)
                        }
                        Else {
                            Store(0xa, MODE)
                        }
                    }
                }
                Concatenate(Local6, Local7, Local5)
                If(Arg5) {
                    Store(Buffer(0x7) {0x0, 0x0, 0x0, 0x0, 0x0, 0xbe, 0x91 }, Local4)
                    CreateByteField(Local4, 0x1, SPT_)
                    Store(Arg5, SPT_)
                    Concatenate(Local5, Local4, Local6)
                    Return(Local6)
                }
                Else {
                    Return(Local5)
                }
            }
            Device(PRIM) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Store(GTM_(ITM0, SIT0, UDC0, UDT0, ICF0, FAS0), Local0)
                    Return(Local0)
                }
                Method(_STM, 3) {
                    Store(STM_(Arg0, Arg1, Arg2), Local0)
                    CreateDWordField(Local0, 0x0, ITM_)
                    CreateDWordField(Local0, 0x4, SIT_)
                    CreateDWordField(Local0, 0x8, UDC_)
                    CreateDWordField(Local0, 0xc, UDT_)
                    CreateDWordField(Local0, 0x10, ICF_)
                    CreateDWordField(Local0, 0x14, FAS_)
                    Store(UDC_, UDC0)
                    Store(UDT_, UDT0)
                    Store(ICF_, ICF0)
                    Store(FAS_, FAS0)
                    Store(H15P(Arg1), ^MAST.H15F)
                    Store(H15P(Arg2), ^SLAV.H15F)
                }
                Device(MAST) {
                    Name(_ADR, 0x0)
                    Name(H15F, Zero)
                    Method(_GTF) {
                        Store(GTF0(ITM0, SIT0, UDC0, UDT0, ICF0, H15F, FAS0), Local0)
                        Return(Local0)
                    }
                }
                Device(SLAV) {
                    Name(_ADR, 0x1)
                    Name(H15F, Zero)
                    Method(_GTF) {
                        Store(GTF1(ITM0, SIT0, UDC0, UDT0, ICF0, H15F, FAS0), Local0)
                        Return(Local0)
                    }
                }
            }
            Device(SECN) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Store(GTM_(ITM1, SIT1, UDC1, UDT1, ICF1, FAS1), Local0)
                    Return(Local0)
                }
                Method(_STM, 3) {
                    Store(STM_(Arg0, Arg1, Arg2), Local0)
                    CreateDWordField(Local0, 0x0, ITM_)
                    CreateDWordField(Local0, 0x4, SIT_)
                    CreateDWordField(Local0, 0x8, UDC_)
                    CreateDWordField(Local0, 0xc, UDT_)
                    CreateDWordField(Local0, 0x10, ICF_)
                    CreateDWordField(Local0, 0x14, FAS_)
                    Store(UDC_, UDC1)
                    Store(UDT_, UDT1)
                    Store(ICF_, ICF1)
                    Store(FAS_, FAS1)
                    Store(H15P(Arg1), ^MAST.H15F)
                    Store(H15P(Arg2), ^SLAV.H15F)
                }
                Device(MAST) {
                    Name(_ADR, 0x0)
                    Name(H15F, Zero)
                    Method(_GTF) {
                        Store(GTF0(ITM1, SIT1, UDC1, UDT1, ICF1, H15F, FAS1), Local0)
                        Return(Local0)
                    }
                }
                Device(SLAV) {
                    Name(_ADR, 0x1)
                    Name(H15F, Zero)
                    Method(_GTF) {
                        Store(GTF1(ITM1, SIT1, UDC1, UDT1, ICF1, H15F, FAS1), Local0)
                        Return(Local0)
                    }
                }
            }
        }
        Device(PX43) {
            Name(_ADR, 0x001f0003)
            OperationRegion(PBAS, PCI_Config, 0x20, 0x2)
            Field(PBAS, ByteAcc, NoLock, Preserve) {
                BAS0,	16
            }
            Method(SMBB) {
                And(BAS0, 0xfffe, Local0)
                Return(Local0)
            }
        }
        Name(BUFA, Buffer(0x6) {0x23, 0xf8, 0xdc, 0x18, 0x79, 0x0 })
        Name(BUFB, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
        CreateWordField(BUFB, 0x1, IRQV)
        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) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRA, 0x80, PIRA)
            }
            Method(_CRS) {
                And(PIRA, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(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) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRB, 0x80, PIRB)
            }
            Method(_CRS) {
                And(PIRB, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(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)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRC, 0x80, PIRC)
            }
            Method(_CRS) {
                And(PIRC, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(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)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRD, 0x80, PIRD)
            }
            Method(_CRS) {
                And(PIRD, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(Local0, PIRD)
            }
        }
        Device(LNKE) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x5)
            Method(_STA) {
                And(PIRE, 0x80, Local0)
                If(LEqual(Local0, 0x80)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRE, 0x80, PIRE)
            }
            Method(_CRS) {
                And(PIRE, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(Local0, PIRE)
            }
        }
        Device(LNKF) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x6)
            Method(_STA) {
                And(PIRF, 0x80, Local0)
                If(LEqual(Local0, 0x80)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRF, 0x80, PIRF)
            }
            Method(_CRS) {
                And(PIRF, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(Local0, PIRF)
            }
        }
        Device(LNK0) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x7)
            Method(_STA) {
                And(PIRG, 0x80, Local0)
                If(LEqual(Local0, 0x80)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRG, 0x80, PIRG)
            }
            Method(_CRS) {
                And(PIRG, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(Local0, PIRG)
            }
        }
        Device(LNK1) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x8)
            Method(_STA) {
                And(PIRH, 0x80, Local0)
                If(LEqual(Local0, 0x80)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Return(BUFA)
            }
            Method(_DIS) {
                Or(PIRH, 0x80, PIRH)
            }
            Method(_CRS) {
                And(PIRH, 0xf, Local0)
                ShiftLeft(0x1, Local0, IRQV)
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateWordField(Arg0, 0x1, IRQ1)
                FindSetRightBit(IRQ1, Local0)
                Decrement(Local0)
                Store(Local0, PIRH)
            }
        }
        Method(\_SB_.PCI0._INI) {
            If(STRC(\_OS_, "Microsoft Windows")) {
            }
            Else {
                If(STRC(\_OS_, "Microsoft Windows NT")) {
                    Store(0x0, OSFL)
                }
                Else {
                    Store(0x2, OSFL)
                }
            }
        }
        Device(SYSR) {
            Name(_HID, 0x020cd041)
            Name(_UID, 0x1)
            Name(_CRS, Buffer(0x5a) {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, 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, 0x4, 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 })
        }
        Scope(\) {
            OperationRegion(WIN1, SystemIO, 0x2e, 0x2)
            Field(WIN1, ByteAcc, NoLock, Preserve) {
                INDP,	8,
                DATA,	8
            }
            IndexField(INDP, DATA, ByteAcc, NoLock, Preserve) {
                Offset(0x2),
                CFG_,	8,
                Offset(0x7),
                LDN_,	8,
                Offset(0x20),
                IDHI,	8,
                IDLO,	8,
                POWC,	8,
                Offset(0x30),
                ACTR,	8,
                Offset(0x60),
                IOAH,	8,
                IOAL,	8,
                IO2H,	8,
                IO2L,	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,
                OPT4,	8,
                OPT5,	8,
                OPT6,	8,
                OPT7,	8
            }
            Method(ENFG) {
                Store(0x87, INDP)
                Store(0x87, INDP)
            }
            Method(EXFG) {
                Store(0xaa, INDP)
            }
        }
        OperationRegion(COM1, SystemIO, 0x03f8, 0x8)
        Field(COM1, ByteAcc, NoLock, Preserve) {
            P3F8,	8,
            P3F9,	8,
            P3FA,	8,
            P3FB,	8,
            P3FC,	8,
            P3FD,	8,
            P3FE,	8,
            P3FF,	8
        }
        OperationRegion(COM2, SystemIO, 0x02f8, 0x8)
        Field(COM2, ByteAcc, NoLock, Preserve) {
            P2F8,	8,
            P2F9,	8,
            P2FA,	8,
            P2FB,	8,
            P2FC,	8,
            P2FD,	8,
            P2FE,	8,
            P2FF,	8
        }
        OperationRegion(COM3, SystemIO, 0x03e8, 0x8)
        Field(COM3, ByteAcc, NoLock, Preserve) {
            P3E8,	8,
            P3E9,	8,
            P3EA,	8,
            P3EB,	8,
            P3EC,	8,
            P3ED,	8,
            P3EE,	8,
            P3EF,	8
        }
        OperationRegion(COM4, SystemIO, 0x02e8, 0x8)
        Field(COM4, ByteAcc, NoLock, Preserve) {
            P2E8,	8,
            P2E9,	8,
            P2EA,	8,
            P2EB,	8,
            P2EC,	8,
            P2ED,	8,
            P2EE,	8,
            P2EF,	8
        }
        Method(ICOM, 1) {
            Store(Arg0, Local0)
            If(LEqual(Local0, 0x03f8)) {
                Store(P3FD, Local0)
                Store(P3FD, Local0)
                Store(0xc3, P3FA)
                While(LNot(LEqual(P3FA, 0xc1))) {
                    Store(P3FE, Local0)
                }
            }
            Else {
                If(LEqual(Local0, 0x02f8)) {
                    Store(P2FD, Local0)
                    Store(P2FD, Local0)
                    Store(0xc3, P2FA)
                    While(LNot(LEqual(P2FA, 0xc1))) {
                        Store(P2FE, Local0)
                    }
                }
                Else {
                    If(LEqual(Local0, 0x03e8)) {
                        Store(P3ED, Local0)
                        Store(P3ED, Local0)
                        Store(0xc3, P3EA)
                        While(LNot(LEqual(P3EA, 0xc1))) {
                            Store(P3EE, Local0)
                        }
                    }
                    Else {
                        If(LEqual(Local0, 0x02e8)) {
                            Store(P2ED, Local0)
                            Store(P2ED, Local0)
                            Store(0xc3, P2EA)
                            While(LNot(LEqual(P2EA, 0xc1))) {
                                Store(P2EE, Local0)
                            }
                        }
                    }
                }
            }
        }
        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)
                SLDM(DMCH, 0x4)
                EXFG()
                DISD(0x3)
            }
            Method(_CRS) {
                Name(BUF0, Buffer(0x18) {0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x8, 0x6, 0x47, 0x1,
0xf7, 0x3, 0xf7, 0x3, 0x8, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x79, 0x0 })
                CreateByteField(BUF0, 0x2, IOLO)
                CreateByteField(BUF0, 0x3, IOHI)
                CreateByteField(BUF0, 0x4, IORL)
                CreateByteField(BUF0, 0x5, IORH)
                ENFG()
                EXFG()
                Return(BUF0)
            }
            Name(_PRS, Buffer(0x1a) {0x30, 0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x8, 0x6, 0x47, 0x1,
0xf7, 0x3, 0xf7, 0x3, 0x8, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x19, IRQL)
                CreateByteField(Arg0, 0x1c, DMAV)
                ENFG()
                Store(Zero, LDN_)
                Store(One, ACTR)
                SLDM(DMCH, DMCH)
                EXFG()
                CKIO(IOAD, 0x3)
            }
        }
        Device(UAR1) {
            Name(_HID, 0x0105d041)
            Name(_UID, 0x1)
            Method(_STA) {
                ENFG()
                Store(0x2, LDN_)
                If(ACTR) {
                    EXFG()
                    Return(0xf)
                }
                Else {
                    If(LOr(IOAH, IOAL)) {
                        EXFG()
                        Return(0xd)
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
                EXFG()
            }
            Method(_DIS) {
                ENFG()
                Store(0x2, LDN_)
                Store(Zero, ACTR)
                EXFG()
                DISD(0x0)
            }
            Method(_CRS) {
                Name(BUF1, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x22, 0x0, 0x0,
0x79, 0x0 })
                CreateByteField(BUF1, 0x2, IOLO)
                CreateByteField(BUF1, 0x3, IOHI)
                CreateByteField(BUF1, 0x4, IORL)
                CreateByteField(BUF1, 0x5, IORH)
                CreateWordField(BUF1, 0x9, IRQW)
                ENFG()
                Store(0x2, LDN_)
                Store(IOAL, IOLO)
                Store(IOAL, IORL)
                Store(IOAH, IOHI)
                Store(IOAH, IORH)
                Store(One, Local0)
                ShiftLeft(Local0, INTR, IRQW)
                EXFG()
                Return(BUF1)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x22, 0xb8,
0x1e, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8,
0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22,
0xb8, 0x1e, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x9, IRQW)
                ENFG()
                Store(0x2, LDN_)
                Store(One, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                FindSetRightBit(IRQW, Local0)
                Subtract(Local0, 0x1, INTR)
                EXFG()
                CKIO(IOAD, 0x0)
            }
        }
        Device(UAR2) {
            Name(_HID, 0x0105d041)
            Name(_UID, 0x2)
            Method(_STA) {
                ENFG()
                Store(0x3, LDN_)
                And(OPT2, 0x30, Local0)
                If(LNot(LEqual(Local0, 0x10))) {
                    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_)
                And(OPT2, 0x38, Local0)
                If(LEqual(Local0, 0x0)) {
                    Store(Zero, ACTR)
                }
                EXFG()
                DISD(0x1)
            }
            Method(_CRS) {
                Name(BUF2, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x22, 0x10, 0x0,
0x79, 0x0 })
                CreateByteField(BUF2, 0x2, IOLO)
                CreateByteField(BUF2, 0x3, IOHI)
                CreateByteField(BUF2, 0x4, IORL)
                CreateByteField(BUF2, 0x5, IORH)
                CreateWordField(BUF2, 0x9, IRQW)
                ENFG()
                Store(0x3, LDN_)
                Store(IOAL, IOLO)
                Store(IOAL, IORL)
                Store(IOAH, IOHI)
                Store(IOAH, IORH)
                Store(One, Local0)
                ShiftLeft(Local0, INTR, IRQW)
                EXFG()
                Return(BUF2)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x22, 0xb8,
0x1e, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8,
0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22,
0xb8, 0x1e, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x9, IRQW)
                ENFG()
                Store(0x3, LDN_)
                Store(One, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                FindSetRightBit(IRQW, Local0)
                Subtract(Local0, 0x1, INTR)
                EXFG()
                CKIO(IOAD, 0x1)
            }
        }
        Device(IRDA) {
            Name(_HID, 0x1005d041)
            Method(_STA) {
                ENFG()
                Store(0x3, LDN_)
                And(OPT2, 0x30, Local0)
                If(LEqual(Local0, 0x10)) {
                    If(ACTR) {
                        EXFG()
                        Return(0xf)
                    }
                    Else {
                        If(LOr(IOAH, IOAL)) {
                            EXFG()
                            Return(0xd)
                        }
                        Else {
                            EXFG()
                            Return(0x0)
                        }
                    }
                }
                Else {
                    EXFG()
                    Return(0x0)
                }
            }
            Method(_DIS) {
                If(LEqual(DISE, 0x1)) {
                    ENFG()
                    Store(0x3, LDN_)
                    And(OPT2, 0x38, Local0)
                    If(LNot(LEqual(Local0, 0x0))) {
                        Store(Zero, ACTR)
                    }
                    EXFG()
                    DISD(0x1)
                }
                Store(Local0, Local0)
            }
            Method(_CRS) {
                Name(BUF4, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x22, 0x0, 0x0,
0x79, 0x0 })
                CreateByteField(BUF4, 0x2, IOLO)
                CreateByteField(BUF4, 0x3, IOHI)
                CreateByteField(BUF4, 0x4, IORL)
                CreateByteField(BUF4, 0x5, IORH)
                CreateWordField(BUF4, 0x9, IRQW)
                ENFG()
                Store(0x3, LDN_)
                Store(IOAL, IOLO)
                Store(IOAL, IORL)
                Store(IOAH, IOHI)
                Store(IOAH, IORH)
                ShiftLeft(0x1, INTR, IRQW)
                EXFG()
                Return(BUF4)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x8, 0x8, 0x22, 0xb8,
0x1e, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8,
0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xe8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22,
0xb8, 0x1e, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x9, IRQW)
                ENFG()
                Store(0x3, LDN_)
                Store(One, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                FindSetRightBit(IRQW, Local0)
                Subtract(Local0, 0x1, INTR)
                EXFG()
                CKIO(IOAD, 0x1)
            }
        }
        Device(LPT1) {
            Name(_HID, 0x0004d041)
            Method(_STA) {
                ENFG()
                Store(0x1, LDN_)
                And(OPT1, 0x2, Local0)
                If(LNot(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(0x1, LDN_)
                Store(Zero, ACTR)
                EXFG()
                DISD(0x2)
            }
            Method(_CRS) {
                Name(BUF5, Buffer(0x25) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8, 0x47, 0x1, 0x0,
0x0, 0x0, 0x0, 0x4, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0,
0x4, 0x4, 0x22, 0x0, 0x0, 0x79, 0x0 })
                CreateByteField(BUF5, 0x2, IOLO)
                CreateByteField(BUF5, 0x3, IOHI)
                CreateByteField(BUF5, 0x4, IORL)
                CreateByteField(BUF5, 0x5, IORH)
                CreateByteField(BUF5, 0x7, IOLE)
                CreateByteField(BUF5, 0xa, IO21)
                CreateByteField(BUF5, 0xb, IO22)
                CreateByteField(BUF5, 0xc, IO23)
                CreateByteField(BUF5, 0xd, IO24)
                CreateByteField(BUF5, 0x12, IO31)
                CreateByteField(BUF5, 0x13, IO32)
                CreateByteField(BUF5, 0x14, IO33)
                CreateByteField(BUF5, 0x15, IO34)
                CreateByteField(BUF5, 0x1a, IO41)
                CreateByteField(BUF5, 0x1b, IO42)
                CreateByteField(BUF5, 0x1c, IO43)
                CreateByteField(BUF5, 0x1d, IO44)
                CreateWordField(BUF5, 0x21, IRQW)
                ENFG()
                Store(0x1, LDN_)
                Store(IOAL, IOLO)
                Store(IOLO, IORL)
                Store(IOAH, IOHI)
                Store(IOHI, IORH)
                Store(IOAL, IO21)
                Store(IOAL, IO23)
                Add(IOAH, 0x4, IO22)
                Add(IOAH, 0x4, IO24)
                Store(IOAL, IO31)
                Store(IOAL, IO33)
                Add(IOAH, 0x8, IO32)
                Add(IOAH, 0x8, IO34)
                Store(IOAL, IO41)
                Store(IOAL, IO43)
                Add(IOAH, 0xc, IO42)
                Add(IOAH, 0xc, IO44)
                If(LEqual(IOLO, 0xbc)) {
                    Store(0x4, IOLE)
                }
                Else {
                    Store(0x8, IOLE)
                }
                Store(One, Local0)
                Store(INTR, Local5)
                ShiftLeft(Local0, Local5, IRQW)
                Store(One, ACTR)
                EXFG()
                Return(BUF5)
            }
            Name(_PRS, Buffer(0x6f) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x4, 0x8, 0x47, 0x1,
0x78, 0x7, 0x78, 0x7, 0x4, 0x4, 0x47, 0x1, 0x78, 0xb, 0x78, 0xb, 0x4, 0x4, 0x47, 0x1, 0x78, 0xf,
0x78, 0xf, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x4, 0x8, 0x47, 0x1,
0x78, 0x6, 0x78, 0x6, 0x4, 0x4, 0x47, 0x1, 0x78, 0xa, 0x78, 0xa, 0x4, 0x4, 0x47, 0x1, 0x78, 0xe,
0x78, 0xe, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x4, 0x4, 0x47, 0x1,
0xbc, 0x7, 0xbc, 0x7, 0x4, 0x4, 0x47, 0x1, 0xbc, 0xb, 0xbc, 0xb, 0x4, 0x4, 0x47, 0x1, 0xbc, 0xf,
0xbc, 0xf, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateByteField(Arg0, 0x4, IORL)
                CreateByteField(Arg0, 0x5, IORH)
                CreateWordField(Arg0, 0x21, IRQW)
                ENFG()
                Store(0x1, LDN_)
                Store(One, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                FindSetLeftBit(IRQW, Local0)
                Subtract(Local0, 0x1, Local0)
                Store(Local0, INTR)
                EXFG()
                CKIO(IOAD, 0x2)
            }
        }
        Device(ECP1) {
            Name(_HID, 0x0104d041)
            Method(_STA) {
                ENFG()
                Store(0x1, 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(0x1, LDN_)
                Store(Zero, ACTR)
                SLDM(DMCH, 0x4)
                EXFG()
                DISD(0x2)
            }
            Method(_CRS) {
                Name(BUF6, Buffer(0x28) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x4, 0x8, 0x47, 0x1, 0x0,
0x0, 0x0, 0x0, 0x4, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x47, 0x1, 0x0, 0x0, 0x0, 0x0,
0x4, 0x4, 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, 0xa, IOEL)
                CreateByteField(BUF6, 0xb, IOEH)
                CreateByteField(BUF6, 0xc, IOML)
                CreateByteField(BUF6, 0xd, IOMH)
                CreateByteField(BUF6, 0x7, IOLE)
                CreateByteField(BUF6, 0x12, IO31)
                CreateByteField(BUF6, 0x13, IO32)
                CreateByteField(BUF6, 0x14, IO33)
                CreateByteField(BUF6, 0x15, IO34)
                CreateByteField(BUF6, 0x1a, IO41)
                CreateByteField(BUF6, 0x1b, IO42)
                CreateByteField(BUF6, 0x1c, IO43)
                CreateByteField(BUF6, 0x1d, IO44)
                CreateWordField(BUF6, 0x21, IRQW)
                CreateByteField(BUF6, 0x24, DMAC)
                ENFG()
                Store(0x1, LDN_)
                Store(One, ACTR)
                Store(IOAL, Local2)
                Store(Local2, IOLO)
                Store(IOAH, Local3)
                Store(Local3, IOHI)
                Or(Local3, 0x4, Local3)
                Store(Local3, IOEH)
                Store(Local3, IOMH)
                Store(IOLO, IORL)
                Store(IOLO, IOEL)
                Store(IOLO, IOML)
                Store(IOHI, IORH)
                Store(IOAL, IO31)
                Store(IOAL, IO33)
                Add(IOAH, 0x8, IO32)
                Add(IOAH, 0x8, IO34)
                Store(IOAL, IO41)
                Store(IOAL, IO43)
                Add(IOAH, 0xc, IO42)
                Add(IOAH, 0xc, IO44)
                If(LEqual(IOLO, 0xbc)) {
                    Store(0x4, IOLE)
                }
                Else {
                    Store(0x8, IOLE)
                }
                Store(One, Local0)
                Store(INTR, Local5)
                ShiftLeft(Local0, Local5, IRQW)
                Store(One, Local0)
                Store(DMCH, Local5)
                ShiftLeft(Local0, Local5, DMAC)
                EXFG()
                Return(BUF6)
            }
            Name(_PRS, Buffer(0x78) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x0, 0x8, 0x47, 0x1,
0x78, 0x7, 0x78, 0x7, 0x0, 0x4, 0x47, 0x1, 0x78, 0xb, 0x78, 0xb, 0x4, 0x4, 0x47, 0x1, 0x78, 0xf,
0x78, 0xf, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x2a, 0xb, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x0,
0x8, 0x47, 0x1, 0x78, 0x6, 0x78, 0x6, 0x0, 0x4, 0x47, 0x1, 0x78, 0xa, 0x78, 0xa, 0x4, 0x4, 0x47,
0x1, 0x78, 0xe, 0x78, 0xe, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x2a, 0xb, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3,
0xbc, 0x3, 0x0, 0x4, 0x47, 0x1, 0xbc, 0x7, 0xbc, 0x7, 0x0, 0x4, 0x47, 0x1, 0xbc, 0xb, 0xbc, 0xb,
0x4, 0x4, 0x47, 0x1, 0xbc, 0xf, 0xbc, 0xf, 0x4, 0x4, 0x22, 0xb8, 0x1e, 0x2a, 0xb, 0x0, 0x38, 0x79,
0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x21, IRQW)
                CreateByteField(Arg0, 0x24, DMAC)
                ENFG()
                Store(0x1, LDN_)
                Store(One, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                FindSetLeftBit(IRQW, Local0)
                Subtract(Local0, 0x1, Local0)
                Store(Local0, INTR)
                FindSetLeftBit(DMAC, Local1)
                Store(DMCH, Local0)
                Subtract(Local1, 0x1, DMCH)
                SLDM(Local0, DMCH)
                EXFG()
                CKIO(IOAD, 0x2)
            }
        }
        OperationRegion(KBCT, SystemIO, 0x60, 0x5)
        Field(KBCT, ByteAcc, NoLock, Preserve) {
            P060,	8,
            Offset(0x4),
            P064,	8
        }
        Device(PS2M) {
            Name(_HID, 0x130fd041)
            Method(_STA) {
                If(LEqual(PS2F, 0x0)) {
                    Return(0xf)
                }
                Else {
                    Return(0x0)
                }
            }
            Method(_CRS) {
                Name(BUF1, Buffer(0x5) {0x22, 0x0, 0x10, 0x79, 0x0 })
                Name(BUF2, Buffer(0x15) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0, 0x1, 0x1, 0x47, 0x1,
0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x22, 0x0, 0x10, 0x79, 0x0 })
                If(LEqual(KBDI, 0x1)) {
                    If(LEqual(OSFL, 0x1)) {
                        Return(BUF1)
                    }
                    Else {
                        Return(BUF2)
                    }
                }
                Else {
                    Return(BUF1)
                }
            }
        }
        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 })
        }
        Device(GAME) {
            Name(_HID, 0x2fb0d041)
            Method(_STA) {
                ENFG()
                Store(0x7, LDN_)
                If(LOr(IOAH, IOAL)) {
                    EXFG()
                    Return(0xf)
                }
                Else {
                    And(ACTR, 0x2, Local0)
                    If(LEqual(Local0, 0x2)) {
                        EXFG()
                        Return(0xd)
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
            }
            Method(_DIS) {
                ENFG()
                Store(0x7, LDN_)
                Store(Zero, IOAH)
                Store(Zero, IOAL)
                EXFG()
                DISD(0x4)
            }
            Method(_CRS) {
                Name(BUF1, Buffer(0x12) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x7, 0x47, 0x1, 0x0,
0x0, 0x0, 0x0, 0x8, 0x1, 0x79, 0x0 })
                CreateByteField(BUF1, 0x2, IOLO)
                CreateByteField(BUF1, 0x3, IOHI)
                CreateByteField(BUF1, 0x4, IORL)
                CreateByteField(BUF1, 0x5, IORH)
                CreateByteField(BUF1, 0xa, IO21)
                CreateByteField(BUF1, 0xb, IO22)
                CreateByteField(BUF1, 0xc, IO23)
                CreateByteField(BUF1, 0xd, IO24)
                ENFG()
                Store(0x7, LDN_)
                Store(IOAL, IOLO)
                Store(IOAL, IORL)
                Store(IOAH, IOHI)
                Store(IOAH, IORH)
                Subtract(IOAL, 0x1, IO21)
                Subtract(IOAL, 0x1, IO23)
                Store(IOAH, IO22)
                Store(IOAH, IO24)
                EXFG()
                Return(BUF1)
            }
            Name(_PRS, Buffer(0x25) {0x30, 0x47, 0x1, 0x1, 0x2, 0x1, 0x2, 0x8, 0x7, 0x47, 0x1,
0x0, 0x2, 0x0, 0x2, 0x8, 0x1, 0x30, 0x47, 0x1, 0x9, 0x2, 0x9, 0x2, 0x8, 0x7, 0x47, 0x1, 0x8, 0x2,
0x8, 0x2, 0x8, 0x1, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                ENFG()
                Store(0x7, LDN_)
                Or(ACTR, 0x2, ACTR)
                Store(IOLO, IOAL)
                Store(IOHI, IOAH)
                EXFG()
                CKIO(IOAD, 0x4)
            }
        }
        Device(MIDI) {
            Name(_HID, 0x06b0d041)
            OperationRegion(MID1, SystemIO, 0x0290, 0x2)
            Field(MID1, ByteAcc, NoLock, Preserve) {
                MD1_,	8,
                ST1_,	8
            }
            OperationRegion(MID2, SystemIO, 0x0300, 0x2)
            Field(MID2, ByteAcc, NoLock, Preserve) {
                MD2_,	8,
                ST2_,	8
            }
            OperationRegion(MID3, SystemIO, 0x0330, 0x2)
            Field(MID3, ByteAcc, NoLock, Preserve) {
                MD3_,	8,
                ST3_,	8
            }
            Method(_STA) {
                ENFG()
                Store(0x7, LDN_)
                If(LOr(IO2H, IO2L)) {
                    EXFG()
                    Return(0xf)
                }
                Else {
                    And(ACTR, 0x4, Local0)
                    If(LEqual(Local0, 0x4)) {
                        EXFG()
                        Return(0xd)
                    }
                    Else {
                        EXFG()
                        Return(0x0)
                    }
                }
            }
            Method(_DIS) {
                ENFG()
                Store(0x7, LDN_)
                Store(Zero, IO2H)
                Store(Zero, IO2L)
                Store(Zero, INTR)
                EXFG()
                DISD(0x5)
            }
            Method(_CRS) {
                Name(BUF1, Buffer(0xd) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x22, 0x0, 0x0,
0x79, 0x0 })
                CreateByteField(BUF1, 0x2, IOLO)
                CreateByteField(BUF1, 0x3, IOHI)
                CreateByteField(BUF1, 0x4, IORL)
                CreateByteField(BUF1, 0x5, IORH)
                CreateWordField(BUF1, 0x9, IRQW)
                ENFG()
                Store(0x7, LDN_)
                Store(IO2L, IOLO)
                Store(IO2L, IORL)
                Store(IO2H, IOHI)
                Store(IO2H, IORH)
                Store(One, Local0)
                ShiftLeft(Local0, INTR, IRQW)
                EXFG()
                Return(BUF1)
            }
            Name(_PRS, Buffer(0x27) {0x30, 0x47, 0x1, 0x30, 0x3, 0x30, 0x3, 0x2, 0x2, 0x22, 0xb8,
0x1e, 0x30, 0x47, 0x1, 0x0, 0x3, 0x0, 0x3, 0x2, 0x2, 0x22, 0xb8, 0x1e, 0x30, 0x47, 0x1, 0x90, 0x2,
0x90, 0x2, 0x2, 0x2, 0x22, 0xb8, 0x1e, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x2, IOAD)
                CreateWordField(Arg0, 0x9, IRQW)
                ENFG()
                Store(0x7, LDN_)
                Or(ACTR, 0x4, ACTR)
                Store(IOLO, IO2L)
                Store(IOHI, IO2H)
                FindSetLeftBit(IRQW, Local0)
                Subtract(Local0, 0x1, Local0)
                Store(Local0, INTR)
                EXFG()
                CKIO(IOAD, 0x5)
                If(LEqual(IOAD, 0x0290)) {
                    And(ST1_, 0x40, Local0)
                    While(LEqual(Local0, 0x40)) {
                        Store(MD1_, Local0)
                        And(ST1_, 0x40, Local0)
                    }
                }
                Else {
                    If(LEqual(IOAD, 0x0300)) {
                        And(ST2_, 0x40, Local0)
                        While(LEqual(Local0, 0x40)) {
                            Store(MD2_, Local0)
                            And(ST2_, 0x40, Local0)
                        }
                    }
                    Else {
                        And(ST3_, 0x40, Local0)
                        While(LEqual(Local0, 0x40)) {
                            Store(MD3_, Local0)
                            And(ST3_, 0x40, Local0)
                        }
                    }
                }
            }
        }
        Scope(\) {
            Method(SALD, 1) {
                If(LEqual(Arg0, 0x0)) {
                    Store(0x0, Local0)
                }
                If(LEqual(Arg0, 0x1)) {
                    Store(0x80, Local0)
                }
                If(LEqual(Arg0, 0x3)) {
                    Store(0xc0, Local0)
                }
                If(LEqual(Arg0, 0x4)) {
                    XOr(0x0, 0x40, Local0)
                }
                If(LEqual(Arg0, 0x5)) {
                    XOr(0x0, 0x40, Local0)
                }
                SLED(Local0)
            }
        }
        Scope(\) {
            Method(SLED, 1) {
                ENFG()
                Store(0x9, LDN_)
                And(OPT4, 0x3f, Local0)
                Or(Local0, Arg0, OPT4)
                EXFG()
            }
        }
        Method(_PRW) {
            Return(Package(0x2) {
                0x1b,
                0x5,
            })
        }
        Method(\_SB_.PCI0.UAR1._PRW) {
            Return(Package(0x2) {
                0x18,
                0x5,
            })
        }
        Method(\_SB_.PCI0.UAR2._PRW) {
            Return(Package(0x2) {
                0x18,
                0x5,
            })
        }
    }
}

}


====================================================================================

found->	vendor=0x8086, dev=0x2440, revid=0x05
	bus=0, slot=31, func=0
	class=06-01-00, hdrtype=0x00, mfdev=1
	cmdreg=0x000f, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[20]: type 4, range 32, base 0000f000, size  4, enabled
found->	vendor=0x8086, dev=0x244b, revid=0x05
	bus=0, slot=31, func=1
	class=01-01-80, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	map[20]: type 4, range 32, base 0000d000, size  5, enabled
found->	vendor=0x8086, dev=0x2442, revid=0x05
	bus=0, slot=31, func=2
	class=0c-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=d, irq=11
	map[20]: type 4, range 32, base 00005000, size  4, enabled
found->	vendor=0x8086, dev=0x2443, revid=0x05
	bus=0, slot=31, func=3
	class=0c-05-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0001, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=b, irq=255
	map[20]: type 4, range 32, base 0000d400, size  5, enabled
found->	vendor=0x8086, dev=0x2444, revid=0x05
	bus=0, slot=31, func=4
	class=0c-03-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=c, irq=9
	map[10]: type 4, range 32, base 0000d800, size  8, enabled
	map[14]: type 4, range 32, base 0000dc00, size  6, enabled
found->	vendor=0x8086, dev=0x2445, revid=0x05
	bus=0, slot=31, func=5
	class=04-01-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0280, cachelnsz=0 (dwords)
	lattimer=0x00 (0 ns), mingnt=0x00 (0 ns), maxlat=0x00 (0 ns)
	intpin=b, irq=10
agp0: <Intel 82815 (i815 GMCH) host to PCI bridge> mem 0xd8000000-0xdbffffff at device 0.0 on pci0
agp0: allocating GATT for aperture of size 64M
pcib1: <PCIBIOS PCI-PCI bridge> at device 1.0 on pci0
pcib1:   secondary bus     1
pcib1:   subordinate bus   1
pcib1:   I/O decode        0xf000-0xfff
pcib1:   memory decode     0xdc000000-0xddffffff
pcib1:   prefetched decode 0xd0000000-0xd7ffffff
pci1: <PCI bus> on pcib1
pci1: physical bus=1
	map[10]: type 1, range 32, base dc000000, size 24, enabled
	map[14]: type 3, range 32, base d0000000, size 27, enabled
found->	vendor=0x10de, dev=0x0110, revid=0xb2
	bus=1, slot=0, func=0
	class=03-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0007, statreg=0x02b0, cachelnsz=0 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x05 (1250 ns), maxlat=0x01 (250 ns)
	intpin=a, irq=5
	powerspec 2  supports D0 D3  current D0
pci1: <display, VGA> at device 0.0 (no driver attached)
pcib2: <ACPI PCI-PCI bridge> at device 30.0 on pci0
pcib2:   secondary bus     2
pcib2:   subordinate bus   4
pcib2:   I/O decode        0x9000-0xcfff
pcib2:   memory decode     0xde000000-0xdfffffff
pcib2:   prefetched decode 0xfff00000-0xfffff
---- initial configuration ------------------------
\\_SB_.PCI0.LNKE irq   0: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.0
\\_SB_.PCI0.LNKF irq   0: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.1
\\_SB_.PCI0.LNK0 irq   0: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.2
\\_SB_.PCI0.LNK1 irq   9: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.3
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.0
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.1
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.2
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.3
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.0
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.1
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.2
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.3
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.0
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.1
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.2
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.3
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.0
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.1
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.2
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.3
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.0
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.1
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.2
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.3
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.0
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.1
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.2
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.3
---- before setting priority for links ------------
\\_SB_.PCI0.LNKE:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	0
\\_SB_.PCI0.LNKF:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	0
\\_SB_.PCI0.LNK0:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	0
---- before fixup boot-disabled links -------------
\\_SB_.PCI0.LNKE:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	3550
\\_SB_.PCI0.LNKF:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	3550
\\_SB_.PCI0.LNK0:
	interrupts:	     3     4     5     6     7    10    11    12    14    15
	penalty:	  1660  1660  1660  1660  1660  1660  2560  1660 10660 10660
	references:	1
	priority:	3550
---- after fixup boot-disabled links --------------
---- arbitrated configuration ---------------------
\\_SB_.PCI0.LNKE irq  12: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.0
\\_SB_.PCI0.LNKF irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.1
\\_SB_.PCI0.LNK0 irq   7: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.2
\\_SB_.PCI0.LNK1 irq   9: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.8.3
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.0
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.1
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.2
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.1.3
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.0
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.1
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.2
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.0.3
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.0
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.1
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.2
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.3.3
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.0
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.1
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.2
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.2.3
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.0
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.1
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.2
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.4.3
\\_SB_.PCI0.LNKB irq  10: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.0
\\_SB_.PCI0.LNKC irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.1
\\_SB_.PCI0.LNKD irq  11: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.2
\\_SB_.PCI0.LNKA irq   5: [  3  4  5  6  7 10 11 12 14 15] low,level,sharable 2.5.3
pci2: <ACPI PCI bus> on pcib2
pci2: physical bus=2
	map[10]: type 1, range 32, base df009000, size 12, enabled
found->	vendor=0x104c, dev=0xac1c, revid=0x01
	bus=2, slot=1, func=0
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0007, statreg=0x0210, cachelnsz=8 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x40 (16000 ns), maxlat=0x03 (750 ns)
	intpin=a, irq=10
	powerspec 1  supports D0 D1 D2 D3  current D0
	map[10]: type 1, range 32, base df004000, size 12, enabled
found->	vendor=0x104c, dev=0xac1c, revid=0x01
	bus=2, slot=1, func=1
	class=06-07-00, hdrtype=0x02, mfdev=1
	cmdreg=0x0007, statreg=0x0210, cachelnsz=8 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x40 (16000 ns), maxlat=0x03 (750 ns)
	intpin=a, irq=10
	powerspec 1  supports D0 D1 D2 D3  current D0
	map[10]: type 4, range 32, base 0000b000, size  3, enabled
	map[14]: type 4, range 32, base 0000b400, size  2, enabled
	map[18]: type 4, range 32, base 0000b800, size  3, enabled
	map[1c]: type 4, range 32, base 0000bc00, size  2, enabled
	map[20]: type 4, range 32, base 0000c000, size  8, enabled
found->	vendor=0x1103, dev=0x0004, revid=0x04
	bus=2, slot=3, func=0
	class=01-80-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0005, statreg=0x0230, cachelnsz=8 (dwords)
	lattimer=0x40 (1920 ns), mingnt=0x08 (2000 ns), maxlat=0x08 (2000 ns)
	intpin=a, irq=11
	powerspec 2  supports D0 D3  current D0
	map[10]: type 4, range 32, base 0000c400, size  6, enabled
found->	vendor=0x10b7, dev=0x9050, revid=0x00
	bus=2, slot=5, func=0
	class=02-00-00, hdrtype=0x00, mfdev=0
	cmdreg=0x0007, statreg=0x0200, cachelnsz=0 (dwords)
	lattimer=0x20 (960 ns), mingnt=0x03 (750 ns), maxlat=0x08 (2000 ns)
	intpin=a, irq=10
cbb0: <TI1225 PCI-CardBus Bridge> mem 0xdf009000-0xdf009fff irq 10 at device 1.0 on pci2
pcib2: device cbb0 requested decoded memory range 0xdf009000-0xdf009fff
cardbus0: <CardBus bus> on cbb0
pccard0: <16-bit PCCard bus> on cbb0
cbb1: <TI1225 PCI-CardBus Bridge> mem 0xdf004000-0xdf004fff irq 10 at device 1.1 on pci2
pcib2: device cbb1 requested decoded memory range 0xdf004000-0xdf004fff
cardbus1: <CardBus bus> on cbb1
pccard1: <16-bit PCCard bus> on cbb1
atapci0: <HighPoint HPT370 UDMA100 controller> port
0xc000-0xc0ff,0xbc00-0xbc03,0xb800-0xb807,0xb400-0xb403,0xb000-0xb007 irq 11 at device 3.0 on pci2
pcib2: device atapci0 requested decoded I/O range 0xc000-0xc0ff
pcib2: device atapci0 requested decoded I/O range 0xb000-0xb007
pcib2: device atapci0 requested decoded I/O range 0xb400-0xb403
pcib2: device atapci0 requested decoded I/O range 0xb402-0xb402
pcib2: device ata2 requested decoded I/O range 0xc000-0xc007
ata2: iobase=0xb000 altiobase=0xb402 bmaddr=0xc000
ata2: pre reset mask=03 ostat0=50 ostat2=00
ata2-master: ATAPI 00 00
ata2-slave: ATAPI 00 00
ata2: after reset mask=03 stat0=50 stat1=00
ata2-master: ATA 01 a5
ata2: devices=01
ata2: at 0xb000 on atapci0
pcib2: device atapci0 requested decoded I/O range 0xb800-0xb807
pcib2: device atapci0 requested decoded I/O range 0xbc00-0xbc03
pcib2: device atapci0 requested decoded I/O range 0xbc02-0xbc02
pcib2: device ata3 requested decoded I/O range 0xc008-0xc00f
ata3: iobase=0xb800 altiobase=0xbc02 bmaddr=0xc008
ata3: pre reset mask=03 ostat0=50 ostat2=00
ata3-master: ATAPI 00 00
ata3-slave: ATAPI 00 00
ata3: after reset mask=03 stat0=50 stat1=00
ata3-master: ATA 01 a5
ata3: devices=01
ata3: at 0xb800 on atapci0
xl0: <3Com 3c905-TX Fast Etherlink XL> port 0xc400-0xc43f irq 10 at device 5.0 on pci2
pcib2: device xl0 requested decoded I/O range 0xc400-0xc43f
xl0: Ethernet address: 00:60:97:93:6a:7c
xl0: media options word: e040
xl0: found MII/AUTO
miibus0: <MII bus> on xl0
nsphy0: <DP83840 10/100 media interface> on miibus0
nsphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
xl0: bpf attached
isab0: <PCI-ISA bridge> at device 31.0 on pci0
isa0: <ISA bus> on isab0
atapci1: <Intel ICH2 UDMA100 controller> port 0xf000-0xf00f at device 31.1 on pci0
ata0: iobase=0x01f0 altiobase=0x03f6 bmaddr=0xf000
ata0: pre reset mask=03 ostat0=00 ostat2=00
ata0-master: ATAPI 74 74
ata0-slave: ATAPI 74 74
ata0: after reset mask=03 stat0=74 stat1=74
ata0: devices=00
ata0: at 0x1f0 irq 14 on atapci1
ata1: iobase=0x0170 altiobase=0x0376 bmaddr=0xf008
ata1: pre reset mask=03 ostat0=50 ostat2=00
ata1-master: ATAPI 14 eb
ata1-slave: ATAPI 00 00
ata1: after reset mask=03 stat0=00 stat1=00
ata1: devices=04
ata1: at 0x170 irq 15 on atapci1
uhci0: <Intel 82801BA/BAM (ICH2) USB controller USB-A> port 0xd000-0xd01f irq 11 at device 31.2 on
pci0
usb0: <Intel 82801BA/BAM (ICH2) USB controller USB-A> on uhci0
usb0: USB revision 1.0
uhub0: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 2 ports with 2 removable, self powered
pci0: <serial bus, SMBus> at device 31.3 (no driver attached)
uhci1: <Intel 82801BA/BAM (ICH2) USB controller USB-B> port 0xd400-0xd41f irq 9 at device 31.4 on
pci0
usb1: <Intel 82801BA/BAM (ICH2) USB controller USB-B> on uhci1
usb1: USB revision 1.0
uhub1: Intel UHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 2 ports with 2 removable, self powered
pcm0: <Intel 82801BA (ICH2)> port 0xdc00-0xdc3f,0xd800-0xd8ff irq 10 at device 31.5 on pci0
pcm0: <Avance Logic ALC200/200P ac97 codec>
pcm0: ac97 codec features headphone, 18 bit DAC, 18 bit ADC, 5 bit master volume, Realtek 3D
Stereo Enhancement
pcm0: ac97 primary codec extended features variable rate PCM, reserved 1, AMAP, reserved 4
pcm0: sndbuf_setmap 748000, 4000; 0xd1cf1000 -> 748000
pcm0: sndbuf_setmap 77c000, 4000; 0xd1cf5000 -> 77c000
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
fdc0: <Enhanced floppy controller (i82077, NE72065 or clone)> port 0x3f7,0x3f0-0x3f5 irq 6 drq 2
on acpi0
fdc0: FIFO enabled, 8 bytes threshold
fd0: <1440-KB 3.5" drive> on fdc0 drive 0
sio0: irq maps: 0x41 0x51 0x41 0x41
sio0 port 0x3f8-0x3ff irq 4 on acpi0
sio0: type 16550A
sio1: irq maps: 0x41 0x49 0x41 0x41
sio1 port 0x2f8-0x2ff irq 3 on acpi0
sio1: type 16550A
unknown: not probed (disabled)
unknown: not probed (disabled)
ppc0: using extended I/O port range
ppc0: ECP SPP ECP+EPP SPP
ppc0 port 0xf78-0xf7b,0xb78-0xb7b,0x778-0x77b,0x378-0x37f irq 7 drq 3 on acpi0
ppc0: SMC-like chipset (ECP/EPP/PS2/NIBBLE) in COMPATIBLE mode
ppc0: FIFO with 16/16/16 bytes threshold
ppbus0: IEEE1284 device found /NIBBLE/PS2/ECP/ECP_RLE/NIBBLE_ID/PS2_ID/ECP_ID/ECP_RLE_ID
Probing for PnP devices on ppbus0:
plip0: <PLIP network interface> on ppbus0
lp0: bpf attached
lpt0: <Printer> on ppbus0
lpt0: Interrupt-driven port
ppi0: <Parallel I/O> on ppbus0
psmcpnp0 irq 12 on acpi0
atkbdc0: <Keyboard controller (i8042)> port 0x64,0x60 irq 1 on acpi0
atkbd0: <AT Keyboard> flags 0x1 irq 1 on atkbdc0
atkbd: the current kbd controller command byte 0047
atkbd: keyboard ID 0x41ab (2)
kbd0 at atkbd0
kbd0: atkbd0, AT 101/102 (2), config:0x1, flags:0x3d0000
psm0: current command byte:0047
psm0: <PS/2 Mouse> irq 12 on atkbdc0
psm0: model IntelliMouse Explorer, device ID 4-00, 5 buttons
psm0: config:00000000, flags:00000000, packet size:4
psm0: syncmask:08, syncbits:08
unknown: not probed (disabled)
unknown: not probed (disabled)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_probe: no address given, try 0x530
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
unknown: not probed (disabled)
unknown: not probed (disabled)
unknown: not probed (disabled)
unknown: not probed (disabled)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
mss_detect, busy still set (0xff)
ata: ata0 already exists; skipping it
ata: ata1 already exists; skipping it
atkbdc: atkbdc0 already exists; skipping it
fdc: fdc0 already exists; skipping it
ppc: ppc0 already exists; skipping it
sio: sio0 already exists; skipping it
sio: sio1 already exists; skipping it
Trying Read_Port at 203
Trying Read_Port at 243
Trying Read_Port at 283
Trying Read_Port at 2c3
Trying Read_Port at 303
Trying Read_Port at 343
Trying Read_Port at 383
Trying Read_Port at 3c3
sc: sc0 already exists; skipping it
vga: vga0 already exists; skipping it
isa_probe_children: disabling PnP devices
isa_probe_children: probing non-PnP devices
pmtimer0 on isa0
adv0: not probed (disabled)
aha0: not probed (disabled)
aic0: not probed (disabled)
bt0: not probed (disabled)
cs0: not probed (disabled)
ed0: not probed (disabled)
fe0: not probed (disabled)
ie0: not probed (disabled)
le0: not probed (disabled)
lnc0: not probed (disabled)
pcic0 failed to probe at port 0x3e0 iomem 0xd0000 on isa0
pcic1: not probed (disabled)
sc0: <System console> at flags 0x100 on isa0
sc0: VGA <16 virtual consoles, flags=0x300>
sc0: fb0, kbd0, terminal emulator: sc (syscons terminal)
sio2: not probed (disabled)
sio3: not probed (disabled)
sn0: not probed (disabled)
vga0: <Generic ISA VGA> at port 0x3c0-0x3df iomem 0xa0000-0xbffff on isa0
fb0: vga0, vga, type:VGA (5), flags:0x7007f
fb0: port:0x3c0-0x3df, crtc:0x3d4, mem:0xa0000 0x20000
fb0: init mode:24, bios mode:3, current mode:24
fb0: window:0xc00b8000 size:32k gran:32k, buf:0 size:32k
VGA parameters upon power-up
50 18 10 00 00 00 03 00 02 67 5f 4f 50 82 54 80 
bf 1f 00 4f 0e 0f 00 00 07 80 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
VGA parameters in BIOS for mode 24
50 18 10 00 10 00 03 00 02 67 5f 4f 50 82 54 80 
bf 1f 00 4f 0d 0e 00 00 00 00 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
EGA/VGA parameters to be used for mode 24
50 18 10 00 10 00 03 00 02 67 5f 4f 50 82 54 80 
bf 1f 00 4f 0d 0e 00 00 00 00 9c 8e 8f 28 1f 96 
b9 a3 ff 00 01 02 03 04 05 14 07 38 39 3a 3b 3c 
3d 3e 3f 0c 00 0f 08 00 00 00 00 00 10 0e 00 ff 
vt0: not probed (disabled)
isa_probe_children: probing PnP devices
Device configuration finished.
procfs registered
Timecounters tick every 10.000 msec
lo0: bpf attached
acpi_cpu0: set speed to 100.0%
acpi_cpu: throttling enabled, 2 steps (100% to 50.0%), currently 100.0%
pcib2: device pccard0 requested decoded memory range 0xde000000-0xdfffffff
pccard0: CIS version PC Card Standard 5.0
pccard0: CIS info: Lucent Technologies, WaveLAN/IEEE, Version 01.01, 
pccard0: Manufacturer code 0x156, product 0x2
pccard0: function 0: network adapter, ccr addr 3e0 mask 1
pccard0: function 0, config table entry 1: I/O card; irq mask ffff; iomask 6, iospace 0-3f; io16
irqpulse irqlevel
pcib2: device pccard0 requested decoded I/O range 0x100-0xffffffff
pcib2: device pccard0 requested decoded memory range 0xde000000-0xdfffffff
wi0: <WaveLAN/IEEE> at port 0x100-0x13f irq 10 function 0 config 1 on pccard0
pcib2: device wi0 requested decoded I/O range 0x100-0x13f
pcib2: device pccard0 requested decoded I/O range 0x100-0x13f
pcib2: device wi0 requested decoded I/O range 0x100-0x13f
wi0: 802.11 address: 00:60:1d:f2:38:c0
wi0: using Lucent Technologies, WaveLAN/IEEE
wi0: Lucent Firmware: Station (8.72.1)
wi0: supported rates: 1Mbps 2Mbps 5.5Mbps 11Mbps
wi0: bpf attached
wi0: bpf attached
cbb1: ready never happened, status = 0c
pcib2: device pccard1 requested decoded memory range 0xde000000-0xdfffffff
pccard1: Card has no functions!
cbb1: PC Card card activation failed
ad4: success setting PIO4 on HighPoint chip
GEOM: new disk ad4
ad6: success setting PIO4 on HighPoint chip
ata1-master: piomode=12 dmamode=34 udmamode=-1 dmaflag=1
ata1-master: success setting WDMA2 on Intel ICH2 chip
acd0: <SONY CD-RW CRX120E/1.0j> CD-RW drive at ata1 as master
acd0: read 4134KB/s (34515KB/s) write 689KB/s (689KB/s), 2048KB buffer, WDMA2
acd0: Reads: CD-R, CD-RW, CD-DA stream, packet
acd0: Writes: CD-R, CD-RW, test write
acd0: Audio: play, 256 volume levels
acd0: Mechanism: ejectable tray, unlocked
acd0: Medium: CD-R 120mm data disc
ar0: 29314MB <ATA RAID1 array> [3737/255/63] status: READY subdisks:
 0 READY ad4: <IBM-DTLA-307030/TX4OA50C> ATA-5 disk at ata2-master
ad4: 29314MB (60036480 sectors), 59560 C, 16 H, 63 S, 512 B
ad4: 16 secs/int, 1 depth queue, PIO4
ad4: piomode=12 dmamode=34 udmamode=69 cblid=1
 1 READY ad6: <IBM-DTLA-307030/TX4OA60A> ATA-5 disk at ata3-master
ad6: 29314MB (60036480 sectors), 59560 C, 16 H, 63 S, 512 B
ad6: 16 secs/int, 1 depth queue, PIO4
ad6: piomode=12 dmamode=34 udmamode=69 cblid=1
pcm0: measured ac97 link rate at 682666666 Hz
[0] f:80 typ:165 s(CHS):0/1/1 e(CHS):255/254/255 s:63 l:60034842
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ad4s1, start 32256 length 30737839104 end 30737871359
Opened disk ad4 -> 16
GEOM: new disk ad6
GEOM: new disk ar0
Opened disk ad4 -> 16
Opened disk ad4 -> 16
Opened disk ad4 -> 16
Opened disk ad6 -> 16
Opened disk ad6 -> 16
[0] f:80 typ:165 s(CHS):0/1/1 e(CHS):255/254/255 s:63 l:60034842
[1] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[2] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
[3] f:00 typ:0 s(CHS):0/0/0 e(CHS):0/0/0 s:0 l:0
GEOM: Configure ar0s1, start 32256 length 30737839104 end 30737871359
GEOM: Add ar0 hot[0] start 512 length 276 end 787
GEOM: Configure ar0a, start 0 length 268435456 end 268435455
GEOM: Configure ar0b, start 268435456 length 775503872 end 1043939327
GEOM: Configure ar0c, start 0 length 30738677248 end 30738677247
GEOM: Configure ar0d, start 1043939328 length 268435456 end 1312374783
GEOM: Configure ar0e, start 1312374784 length 268435456 end 1580810239
GEOM: Configure ar0f, start 1580810240 length 29157867008 end 30738677247
GEOM: Add ar0s1 hot[0] start 512 length 276 end 787
GEOM: Configure ar0s1a, start 0 length 30200037376 end 30200037375
GEOM: Configure ar0s1b, start 30200037376 length 537801728 end 30737839103
GEOM: Configure ar0s1c, start 0 length 30737839104 end 30737839103
GEOM: Add ar0a hot[0] start 512 length 276 end 787
GEOM: Add ar0c hot[0] start 512 length 276 end 787
GEOM: Add ar0s1a hot[0] start 512 length 276 end 787
GEOM: Add ar0s1c hot[0] start 512 length 276 end 787
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): error 5
(probe0:ata0:0:0:0): Retries Exhausted
(probe1:ata0:0:1:0): error 5
(probe1:ata0:0:1:0): Retries Exhausted
(probe3:ata1:0:1:0): error 5
(probe3:ata1:0:1:0): Retries Exhausted
(probe6:ata3:0:0:0): error 5
(probe6:ata3:0:0:0): Retries Exhausted
(probe7:ata3:0:1:0): error 5
(probe7:ata3:0:1:0): Retries Exhausted
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): CAM Status 0x39
(probe0:ata0:0:0:0): Retrying Command
(probe1:ata0:0:1:0): CAM Status 0x39
(probe1:ata0:0:1:0): Retrying Command
(probe3:ata1:0:1:0): CAM Status 0x39
(probe3:ata1:0:1:0): Retrying Command
(probe6:ata3:0:0:0): CAM Status 0x39
(probe6:ata3:0:0:0): Retrying Command
(probe7:ata3:0:1:0): CAM Status 0x39
(probe7:ata3:0:1:0): Retrying Command
(probe0:ata0:0:0:0): error 5
(probe0:ata0:0:0:0): Retries Exhausted
(probe1:ata0:0:1:0): error 5
(probe1:ata0:0:1:0): Retries Exhausted
(probe3:ata1:0:1:0): error 5
(probe3:ata1:0:1:0): Retries Exhausted
(probe6:ata3:0:0:0): error 5
(probe6:ata3:0:0:0): Retries Exhausted
(probe7:ata3:0:1:0): error 5
(probe7:ata3:0:1:0): Retries Exhausted
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): error 5
(probe4:ata2:0:0:0): Retries Exhausted
(probe5:ata2:0:1:0): error 5
(probe5:ata2:0:1:0): Retries Exhausted
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): CAM Status 0x39
(probe4:ata2:0:0:0): Retrying Command
(probe5:ata2:0:1:0): CAM Status 0x39
(probe5:ata2:0:1:0): Retrying Command
(probe4:ata2:0:0:0): error 5
(probe4:ata2:0:0:0): Retries Exhausted
(probe5:ata2:0:1:0): error 5
(probe5:ata2:0:1:0): Retries Exhausted
pass0 at ata1 bus 0 target 0 lun 0
pass0: <SONY CD-RW  CRX120E 1.0j> Removable CD-ROM SCSI-0 device 
pass0: Serial Number [
pass0: 16.000MB/s transfers
Mounting root from ufs:/dev/ar0s1a
cd0 at ata1 bus 0 target 0 lun 0
cd0: <SONY CD-RW  CRX120E 1.0j> Removable CD-ROM SCSI-0 device 
cd0: Serial Number [
cd0: 16.000MB/s transfers
cd0: cd present [264396 x 2048 byte records]

__________________________________________________
Do you Yahoo!?
Yahoo! Tax Center - forms, calculators, tips, more
http://taxes.yahoo.com/
