From owner-acpi-jp@jp.freebsd.org  Tue Sep 11 17:05:46 2001
Received: (from daemon@localhost)
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) id RAA16050;
	Tue, 11 Sep 2001 17:05:46 +0900 (JST)
	(envelope-from owner-acpi-jp@jp.FreeBSD.org)
Received: from freebsd.dk (fw-rl0.freebsd.dk [212.242.86.114])
	by castle.jp.freebsd.org (8.9.3+3.2W/8.7.3) with ESMTP id RAA16045
	for <acpi-jp@jp.freebsd.org>; Tue, 11 Sep 2001 17:05:42 +0900 (JST)
	(envelope-from sos@freebsd.dk)
Received: (from sos@localhost)
	by freebsd.dk (8.11.3/8.11.3) id f8B860o45562
	for acpi-jp@jp.freebsd.org; Tue, 11 Sep 2001 10:06:00 +0200 (CEST)
	(envelope-from sos)
From: Sren Schmidt <sos@freebsd.dk>
Message-Id: <200109110806.f8B860o45562@freebsd.dk>
To: acpi-jp@jp.freebsd.org
Date: Tue, 11 Sep 2001 10:06:00 +0200 (CEST)
X-Mailer: ELM [version 2.4ME+ PL88 (25)]
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset=ISO-8859-1
Reply-to: sos@freebsd.dk
Precedence: list
X-Distribute: distribute version 2.1 (Alpha) patchlevel 24e+010328
X-Sequence: acpi-jp 1268
Subject: [acpi-jp 1268] acpidump from Epox8kta3+ (power off doesn't work)
Errors-To: owner-acpi-jp@jp.freebsd.org
Sender: owner-acpi-jp@jp.freebsd.org
X-Originator: sos@freebsd.dk


Mike Smith asked me to mail you the acpidump from this system:

Epox 8kta3+ latest BIOS version available (8kta31614).

The problem is that power off doesn't work, the system shuts down
nicely but then it just reboots instead of powering off.
This is the case both with a halt -p and pressing the power button.

Suspend doesn't work either, it reboots.

Both works nicely when the old APM interface is used, and ACPI
works nicely under Win2K as well..

Hope this help to find the problem, if there is anything you
wnat me ty try, just ask...

RSD PTR: Checksum=3D0, OEMID=3DVIA694, RsdtAddress=3D0x2fff3000
RSDT: Lenth=3D40, Revision=3D1, Checksum=3D47,
	OEMID=3DVIA694, OEM Table ID=3DAWRDACPI, OEM Revision=3D0x42302e31,
	Creator ID=3DAWRD, Creator Revision=3D0x0
	Entries=3D{ 0x2fff3040 }
	DSDT=3D0x2fff30c0
	INT_MODEL=3DPIC
	SCI_INT=3D9
	SMI_CMD=3D0x402f, ACPI_ENABLE=3D0xa1, ACPI_DISABLE=3D0xa0, S4BIOS_REQ=3D0x0
	PM1a_EVT_BLK=3D0x4000-0x4003
	PM1a_CNT_BLK=3D0x40f0-0x40f1
	PM2_TMR_BLK=3D0x4008-0x400b
	PM2_GPE0_BLK=3D0x4020-0x4023
	P_LVL2_LAT=3D90ms, P_LVL3_LAT=3D900ms
	FLUSH_SIZE=3D0, FLUSH_STRIDE=3D0
	DUTY_OFFSET=3D0, DUTY_WIDTH=3D1
	DAY_ALRM=3D125, MON_ALRM=3D126, CENTURY=3D50
	Flags=3D{WBINVD,PROC_C1,SLP_BUTTON}
DSDT: Lenth=3D11645, Revision=3D1, Checksum=3D13,
	OEMID=3DVIA694, OEM Table ID=3DAWRDACPI, OEM Revision=3D0x1000,
	Creator ID=3DMSFT, Creator Revision=3D0x100000c
Scope(\_PR_) {
    Processor(\_PR_.CPU0, 1, 0x4010, 0x6) {
    }
}
Name(\_S0_, Package(0x4) {
    Zero,
    Zero,
    Zero,
    Zero,
})
Name(\_S1_, Package(0x4) {
    0x4,
    0x4,
    0x4,
    0x4,
})
Name(\_S4_, Package(0x4) {
    0x2,
    0x2,
    0x2,
    0x2,
})
Name(\_S5_, Package(0x4) {
    0x2,
    0x2,
    0x2,
    0x2,
})
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(ELCR, SystemIO, 0x04d0, 0x2)
Field(ELCR, ByteAcc, NoLock, Preserve) {
    ELC1,	8,
    ELC2,	8
}
OperationRegion(\STUS, SystemIO, 0x4030, 0x1)
Field(\STUS, ByteAcc, NoLock, Preserve) {
    G_ST,	8
}
OperationRegion(\WIRQ, SystemIO, 0x402a, 0x1)
Field(\WIRQ, ByteAcc, NoLock, Preserve) {
    IRQR,	8
}
OperationRegion(\SMIC, SystemIO, 0x402f, 0x1)
Field(\SMIC, ByteAcc, NoLock, Preserve) {
    SCP_,	8
}
OperationRegion(GPOB, SystemIO, 0x404c, 0x4)
Field(GPOB, ByteAcc, NoLock, Preserve) {
    GP00,	1,
    GP01,	1,
    GP02,	1,
    GP03,	1,
    GP04,	1,
    GP05,	1,
    GP06,	1,
    GP07,	1,
    GP08,	1,
    GP09,	1,
    GP10,	1,
    GP11,	1,
    GP12,	1,
    GP13,	1,
    GP14,	1,
    GP15,	1,
    GP16,	1,
    GP17,	1,
    GP18,	1,
    GP19,	1,
    GP20,	1,
    GP21,	1,
    GP22,	1,
    GP23,	1,
    GP24,	1,
    GP25,	1,
    GP26,	1,
    GP27,	1,
    GP28,	1,
    GP29,	1,
    GP30,	1,
    GPXX,	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_)
}
Method(\_PTS, 1) {
    Or(Arg0, 0xf0, Local0)
    Store(Local0, DBG1)
    If(LNot(LEqual(Arg0, 0x5))) {
        If(LNot(LEqual(Arg0, 0x4))) {
        }
        And(PWC1, 0xfc, PWC1)
        Or(PWC1, 0x2, PWC1)
        And(PWC1, 0xfc, PWC1)
        Or(PWC1, 0x1, PWC1)
    }
    If(LNot(LEqual(Arg0, 0x5))) {
        Or(Arg0, 0x50, Local1)
        Store(Local1, SCP_)
    }
    If(LEqual(Arg0, 0x1)) {
        And(GAR1, 0xfd, GAR1)
        And(GAR2, 0x2, Local0)
        Or(Local0, GAR1, GAR1)
        Store(G_ST, Local1)
        While(LNot(LEqual(Local1, 0x0))) {
            Store(Local1, G_ST)
            Store(G_ST, Local1)
        }
        Or(IRQR, 0x80, IRQR)
    }
    If(LEqual(Arg0, 0x5)) {
    }
}
Method(\_WAK, 1) {
    Store(0xff, DBG1)
    And(PWC1, 0xfc, PWC1)
    If(LEqual(RTCW, 0x0)) {
        Notify(\_SB_.PWRB, 0x2)
    }
}
Scope(\_SI_) {
    Method(_MSG, 1) {
        Store(Local0, Local0)
    }
    Method(_SST, 1) {
        If(LEqual(Arg0, 0x3)) {
        }
        If(LEqual(Arg0, 0x1)) {
        }
        If(LEqual(Arg0, Zero)) {
        }
        Store(Local0, Local0)
    }
}
Scope(\_GPE) {
    Method(_L05) {
        Noop
    }
    Method(_L09) {
        Notify(\_SB_.PCI0.USB0, 0x2)
    }
    Method(_L0D) {
        Notify(\_SB_.PCI0.MODM, 0x2)
    }
    Method(_L08) {
        Noop
    }
}
Scope(\_SB_) {
    Device(PWRB) {
        Name(_HID, 0x0c0cd041)
        Method(_STA) {
            Return(0xb)
        }
    }
    Device(MEM_) {
        Name(_HID, 0x010cd041)
        Method(_CRS) {
            Name(BUF0, Buffer(0x6e) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xf, 0x=
0, 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, 0xc=
0, 0xf, 0x0, 0x0, 0x40, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x1, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x=
1, 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, 0x79, 0x0 })
            CreateDWordField(BUF0, 0x34, ACMM)
            CreateDWordField(BUF0, 0x4, RMA1)
            CreateDWordField(BUF0, 0x8, RSS1)
            CreateDWordField(BUF0, 0x10, RMA2)
            CreateDWordField(BUF0, 0x14, RSS2)
            CreateDWordField(BUF0, 0x1c, RMA3)
            CreateDWordField(BUF0, 0x20, RSS3)
            CreateDWordField(BUF0, 0x28, RMA4)
            CreateDWordField(BUF0, 0x2c, RSS4)
            CreateDWordField(BUF0, 0x5c, EXTM)
            Subtract(AMEM, 0x00100000, EXTM)
            If(LNot(LEqual(ROM1, Zero))) {
                Store(RMA1, RMA2)
                ShiftLeft(ROM1, 0x8, Local0)
                Store(Local0, RMA1)
                ShiftLeft(RMS1, 0x8, Local0)
                Store(Local0, RSS1)
                Store(0x8000, RSS2)
            }
            If(LNot(LEqual(ROM2, Zero))) {
                Store(RMA2, RMA3)
                ShiftLeft(ROM2, 0x8, Local0)
                Store(Local0, RMA2)
                ShiftLeft(RMS2, 0x8, Local0)
                Store(Local0, RSS2)
                Store(0xc000, RSS3)
            }
            If(LNot(LEqual(ROM3, Zero))) {
                Store(RMA3, RMA4)
                ShiftLeft(ROM3, 0x8, Local0)
                Store(Local0, RMA3)
                ShiftLeft(RMS3, 0x8, Local0)
                Store(Local0, RSS3)
                Store(0x00010000, RSS4)
            }
            Store(AMEM, ACMM)
            Return(BUF0)
        }
    }
    Device(PCI0) {
        Name(_HID, 0x030ad041)
        Name(_ADR, 0x0)
        Name(SS3D, 0x2)
        OperationRegion(GART, PCI_Config, 0x80, 0x1)
        Scope(\) {
            Field(\_SB_.PCI0.GART, ByteAcc, NoLock, Preserve) {
                GAR1,	8
            }
        }
        OperationRegion(GARA, PCI_Config, 0x88, 0x1)
        Scope(\) {
            Field(\_SB_.PCI0.GARA, ByteAcc, NoLock, Preserve) {
                GAR2,	8
            }
        }
        OperationRegion(NB00, PCI_Config, 0x0, 0x0100)
        Field(NB00, ByteAcc, NoLock, Preserve) {
            Offset(0x57),
            EADD,	8,
            Offset(0x69),
            RXOP,	8,
            Offset(0x88),
            AG88,	8,
            AG89,	8
        }
        Method(_STA) {
            Return(0xf)
        }
        Method(_CRS) {
            Name(BUF0, Buffer(0xd8) {0x88, 0xd, 0x0, 0x2, 0x1, 0x0, 0x0, 0x=
0, 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, 0=
x0, 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, 0x80, 0x47, 0x1, 0x80, 0x40, 0x80, 0x=
40, 0x1, 0x80, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x41, 0xff, 0x=
4f, 0x0, 0x0, 0xff, 0xe, 0x47=
, 0x1, 0x0, 0x50, 0x0, 0x50, 0x1, 0x10, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0,=
 0x0, 0x10, 0x50, 0xff, 0x5f, 0x0, 0x0, 0xef, 0xf, 0x47, 0x1, 0x0, 0x60, 0x=
0, 0x60, 0x1, 0x80, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x80, 0x60, 0x=
ff, 0xff, 0x0, 0x0, 0x7f, 0x9=
f, 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, 0=
x0, 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, 0=
x0, 0x10, 0x0, 0xff, 0xff, 0xef, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, =
0xff, 0x79, 0x0 })
            CreateDWordField(BUF0, 0xc6, TCMM)
            CreateDWordField(BUF0, 0xd2, TOMM)
            Add(AMEM, 0x00010000, TCMM)
            Subtract(0xfff00000, TCMM, TOMM)
            Return(BUF0)
        }
        Name(_PRT, Package(0x2c) {
            Package(0x4) {
                0x0008ffff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x2,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0008ffff,
                0x3,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x0,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x1,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x2,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x0009ffff,
                0x3,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x0,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x1,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x2,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000affff,
                0x3,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x0,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x1,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x2,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000bffff,
                0x3,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x0,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x1,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x2,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x3,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x0,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x1,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x2,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x3,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x0,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x1,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x2,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000cffff,
                0x3,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x0,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x1,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x2,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000dffff,
                0x3,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x000effff,
                0x0,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x000effff,
                0x1,
                \_SB_.PCI0.LNKD,
                0x0,
            },
            Package(0x4) {
                0x000effff,
                0x2,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x000effff,
                0x3,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x0,
                \_SB_.PCI0.LNKA,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x1,
                \_SB_.PCI0.LNKB,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                0x2,
                \_SB_.PCI0.LNKC,
                0x0,
            },
            Package(0x4) {
                0x0007ffff,
                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(VT86) {
            Name(_ADR, 0x00070000)
            OperationRegion(CREV, PCI_Config, 0x8, 0x1)
            Field(CREV, ByteAcc, NoLock, Preserve) {
                REVN,	8
            }
            OperationRegion(PIRQ, PCI_Config, 0x55, 0x3)
            Scope(\) {
                Field(\_SB_.PCI0.VT86.PIRQ, ByteAcc, NoLock, Preserve) {
                    PIRA,	8,
                    PIBC,	8,
                    PIRD,	8
                }
            }
        }
        Device(USB0) {
            Name(_ADR, 0x00070002)
            Name(_PRW, Package(0x2) {
                0x9,
                0x5,
            })
            Name(SS3D, 0x2)
        }
        Device(USB1) {
            Name(_ADR, 0x00070003)
            Name(_PRW, Package(0x2) {
                0x9,
                0x5,
            })
            Name(SS3D, 0x2)
        }
        Device(IDE0) {
            Name(_ADR, 0x00070001)
            Name(REGF, 0x1)
            Method(_REG, 2) {
                If(LEqual(Arg0, 0x2)) {
                    Store(Arg1, REGF)
                }
            }
            OperationRegion(\_SB_.PCI0.VT86.V686, PCI_Config, 0xf6, 0x1)
            Field(\_SB_.PCI0.VT86.V686, ByteAcc, NoLock, Preserve) {
                VERS,	8
            }
            Method(B686) {
                If(LNot(LLess(VERS, 0x40))) {
                    Return(One)
                }
                Else {
                    Return(Zero)
                }
            }
            Name(TIM0, Package(0xc) {
                Package(0x4) {
                    0x78,
                    0xb4,
                    0xf0,
                    0x0384,
                },
                Package(0x4) {
                    0x20,
                    0x31,
                    0x65,
                    0xa8,
                },
                Package(0x8) {
                    0x2,
                    0x1,
                    0x0,
                    0x0,
                    0x0,
                    0x0,
                    0x0,
                    0x0,
                },
                Package(0x8) {
                    0x4,
                    0x3,
                    0x2,
                    0x2,
                    0x1,
                    0x1,
                    0x0,
                    0x0,
                },
                Package(0x6) {
                    0x70,
                    0x49,
                    0x36,
                    0x27,
                    0x19,
                    0x14,
                },
                Package(0x5) {
                    0x2,
                    0x1,
                    0x0,
                    0x0,
                    0x0,
                },
                Package(0x5) {
                    0x6,
                    0x4,
                    0x2,
                    0x1,
                    0x0,
                },
                Package(0x5) {
                    0x0,
                    0x0,
                    0x0,
                    0x1,
                    0x1,
                },
                Package(0x4) {
                    0x4,
                    0x3,
                    0x2,
                    0x0,
                },
                Package(0x4) {
                    0x2,
                    0x1,
                    0x0,
                    0x0,
                },
                Package(0x8) {
                    0x5,
                    0x4,
                    0x3,
                    0x2,
                    0x2,
                    0x1,
                    0x1,
                    0x0,
                },
                Package(0x6) {
                    0x7,
                    0x6,
                    0x4,
                    0x2,
                    0x1,
                    0x0,
                },
            })
            Name(TMD0, Buffer(0x14) { })
            CreateDWordField(TMD0, 0x0, PIO0)
            CreateDWordField(TMD0, 0x4, DMA0)
            CreateDWordField(TMD0, 0x8, PIO1)
            CreateDWordField(TMD0, 0xc, DMA1)
            CreateDWordField(TMD0, 0x10, CHNF)
            OperationRegion(CFG2, PCI_Config, 0x40, 0x20)
            Field(CFG2, DWordAcc, NoLock, Preserve) {
                Offset(0x8),
                SSPT,	8,
                SMPT,	8,
                PSPT,	8,
                PMPT,	8,
                Offset(0x10),
                SSUT,	3,
                SCBC,	1,
                ,	1,
                SSUE,	3,
                SMUT,	3,
                ,	2,
                SMUE,	3,
                PSUT,	3,
                PCBC,	1,
                ,	1,
                PSUE,	3,
                PMUT,	3,
                ,	2,
                PMUE,	3
            }
            Name(GMPT, 0x0)
            Name(GMUE, 0x0)
            Name(GMUT, 0x0)
            Name(GSPT, 0x0)
            Name(GSUE, 0x0)
            Name(GSUT, 0x0)
            Name(GBCS, 0x0)
            Device(CHN0) {
                Name(_ADR, 0x0)
                Method(_GTM) {
                    Return(GTM_)
                    PMPT
                    PMUE
                    PMUT
                    PSPT
                    PSUE
                    PSUT
                    PCBC
                }
                Method(_STM, 3) {
                    Store(Arg0, TMD0)
                    Store(PMPT, GMPT)
                    Store(PMUE, GMUE)
                    Store(PMUT, GMUT)
                    Store(PSPT, GSPT)
                    Store(PSUE, GSUE)
                    Store(PSUT, GSUT)
                    Store(PCBC, GBCS)
                    STM_
                    Store(GMPT, PMPT)
                    Store(GMUE, PMUE)
                    Store(GMUT, PMUT)
                    Store(GSPT, PSPT)
                    Store(GSUE, PSUE)
                    Store(GSUT, PSUT)
                    Store(GBCS, PCBC)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(GTF_)
                        0x0
                        PMUE
                        PMUT
                        PMPT
                        PCBC
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(GTF_)
                        0x1
                        PSUE
                        PSUT
                        PSPT
                        PCBC
                    }
                }
            }
            Device(CHN1) {
                Name(_ADR, 0x1)
                Method(_GTM) {
                    Return(GTM_)
                    SMPT
                    SMUE
                    SMUT
                    SSPT
                    SSUE
                    SSUT
                    SCBC
                }
                Method(_STM, 3) {
                    Store(Arg0, TMD0)
                    Store(SMPT, GMPT)
                    Store(SMUE, GMUE)
                    Store(SMUT, GMUT)
                    Store(SSPT, GSPT)
                    Store(SSUE, GSUE)
                    Store(SSUT, GSUT)
                    Store(SCBC, GBCS)
                    STM_
                    Store(GMPT, SMPT)
                    Store(GMUE, SMUE)
                    Store(GMUT, SMUT)
                    Store(GSPT, SSPT)
                    Store(GSUE, SSUE)
                    Store(GSUT, SSUT)
                    Store(GBCS, SCBC)
                }
                Device(DRV0) {
                    Name(_ADR, 0x0)
                    Method(_GTF) {
                        Return(GTF_)
                        0x2
                        SMUE
                        SMUT
                        SMPT
                        PCBC
                    }
                }
                Device(DRV1) {
                    Name(_ADR, 0x1)
                    Method(_GTF) {
                        Return(GTF_)
                        0x3
                        SSUE
                        SSUT
                        SSPT
                        PCBC
                    }
                }
            }
            Method(GTF_, 5, Serialized) {
                Store(Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef }, L=
ocal1)
                Store(Buffer(0x7) {0x3, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xef }, L=
ocal2)
                CreateByteField(Local1, 0x1, MODE)
                CreateByteField(Local2, 0x1, UMOD)
                CreateByteField(Local1, 0x5, PCHA)
                CreateByteField(Local2, 0x5, UCHA)
                And(Arg0, 0x3, Local3)
                If(LEqual(And(Local3, 0x1, ), 0x1)) {
                    Store(0xb0, PCHA)
                    Store(0xb0, UCHA)
                }
                If(Arg1) {
                    If(B686) {
                        Store(DerefOf(Index(DerefOf(Index(TIM0, 0xa, )), Ar=
g2, )), UMOD)
                    }
                    Else {
                        If(Arg4) {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, ))=
, Arg2, )), UMOD)
                        }
                        Else {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x2, ))=
, Arg2, )), UMOD)
                        }
                    }
                    Or(UMOD, 0x40, UMOD)
                }
                Else {
                    Store(Match(DerefOf(Index(TIM0, 0x1, )), MEQ, Arg3, MTR=
, 0x0, 0x0), Local0)
                    Or(0x20, DerefOf(Index(DerefOf(Index(TIM0, 0x9, )), Loc=
al0, )), UMOD)
                }
                Store(Match(DerefOf(Index(TIM0, 0x1, )), MEQ, Arg3, MTR, 0x=
0, 0x0), Local0)
                Or(0x8, DerefOf(Index(DerefOf(Index(TIM0, 0x8, )), Local0, =
)), MODE)
                Concat(Local1, Local2, Local6)
                Return(Local6)
            }
            Method(GTM_, 7, Serialized) {
                Store(Ones, PIO0)
                Store(Ones, PIO1)
                Store(Ones, DMA0)
                Store(Ones, DMA1)
                Store(0x10, CHNF)
                If(REGF) {
                }
                Else {
                    Return(TMD0)
                }
                Store(Match(DerefOf(Index(TIM0, 0x1, )), MEQ, Arg0, MTR, 0x=
0, 0x0), Local6)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local6, ))=
, Local7)
                Store(Local7, DMA0)
                Store(Local7, PIO0)
                Store(Match(DerefOf(Index(TIM0, 0x1, )), MEQ, Arg3, MTR, 0x=
0, 0x0), Local6)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x0, )), Local6, ))=
, Local7)
                Store(Local7, DMA1)
                Store(Local7, PIO1)
                If(Arg1) {
                    If(B686) {
                        Store(DerefOf(Index(DerefOf(Index(TIM0, 0xa, )), Ar=
g2, )), Local5)
                    }
                    Else {
                        If(Arg6) {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, ))=
, Arg2, )), Local5)
                        }
                        Else {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x2, ))=
, Arg2, )), Local5)
                        }
                    }
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x4, )), Local5=
, )), DMA0)
                    Or(CHNF, 0x1, CHNF)
                }
                If(Arg4) {
                    If(B686) {
                        Store(DerefOf(Index(DerefOf(Index(TIM0, 0xa, )), Ar=
g5, )), Local5)
                    }
                    Else {
                        If(Arg6) {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x3, ))=
, Arg5, )), Local5)
                        }
                        Else {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x2, ))=
, Arg5, )), Local5)
                        }
                    }
                    Store(DerefOf(Index(DerefOf(Index(TIM0, 0x4, )), Local5=
, )), DMA1)
                    Or(CHNF, 0x4, CHNF)
                }
                Return(TMD0)
            }
            Method(STM_, 0, Serialized) {
                If(REGF) {
                }
                Else {
                    Return(TMD0)
                }
                Store(0x0, GMUE)
                Store(0x0, GSUE)
                If(B686) {
                    Store(0x7, GMUT)
                    Store(0x7, GSUT)
                }
                Else {
                    Store(0x3, GMUT)
                    Store(0x3, GSUT)
                }
                If(And(CHNF, 0x1, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x4, )), MLE, DMA0, MTR=
, 0x0, 0x0), Local0)
                    If(B686) {
                        Store(DerefOf(Index(DerefOf(Index(TIM0, 0xb, )), Lo=
cal0, )), GMUT)
                        Or(GMUE, 0x3, GMUE)
                    }
                    Else {
                        If(LGreater(Local0, 0x4)) {
                            Store(0x4, Local0)
                        }
                        If(GBCS) {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x6, ))=
, Local0, )), GMUT)
                        }
                        Else {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x5, ))=
, Local0, )), GMUT)
                        }
                        Or(GMUE, 0x7, GMUE)
                    }
                }
                Else {
                    If(Or(LEqual(PIO0, Ones), LEqual(PIO0, 0x0), )) {
                        If(And(LLess(DMA0, Ones), LGreater(DMA0, 0x0), )) {
                            Store(DMA0, PIO0)
                        }
                    }
                }
                If(And(CHNF, 0x4, )) {
                    Store(Match(DerefOf(Index(TIM0, 0x4, )), MLE, DMA1, MTR=
, 0x0, 0x0), Local0)
                    If(B686) {
                        Store(DerefOf(Index(DerefOf(Index(TIM0, 0xb, )), Lo=
cal0, )), GSUT)
                        Or(GMUE, 0x3, GMUE)
                    }
                    Else {
                        If(LGreater(Local0, 0x4)) {
                            Store(0x4, Local0)
                        }
                        If(GBCS) {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x6, ))=
, Local0, )), GSUT)
                        }
                        Else {
                            Store(DerefOf(Index(DerefOf(Index(TIM0, 0x5, ))=
, Local0, )), GSUT)
                        }
                        Or(GSUE, 0x7, GSUE)
                    }
                }
                Else {
                    If(Or(LEqual(PIO1, Ones), LEqual(PIO1, 0x0), )) {
                        If(And(LLess(DMA1, Ones), LGreater(DMA1, 0x0), )) {
                            Store(DMA1, PIO1)
                        }
                    }
                }
                And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO0, MTR, 0x0,=
 0x0), 0x3, Local0)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x1, )), Local0, ))=
, Local1)
                Store(Local1, GMPT)
                And(Match(DerefOf(Index(TIM0, 0x0, )), MGE, PIO1, MTR, 0x0,=
 0x0), 0x3, Local0)
                Store(DerefOf(Index(DerefOf(Index(TIM0, 0x1, )), Local0, ))=
, Local1)
                Store(Local1, GSPT)
            }
        }
        Device(VTAC) {
            Name(_ADR, 0x00070004)
            OperationRegion(PWC_, PCI_Config, 0x54, 0x1)
            Scope(\) {
                Field(\_SB_.PCI0.VTAC.PWC_, ByteAcc, NoLock, Preserve) {
                    PWC1,	8
                }
            }
        }
        Device(AUDI) {
            Name(_ADR, 0x00070005)
        }
        Device(MODM) {
            Name(_ADR, 0x00070006)
            Name(_PRW, Package(0x2) {
                0xd,
                0x4,
            })
        }
        Device(PIB_) {
            Name(_ADR, 0x00070000)
            OperationRegion(SB70, PCI_Config, 0x0, 0x88)
            Field(SB70, ByteAcc, NoLock, Preserve) {
                Offset(0x48),
                ,	2,
                EUSB,	1,
                Offset(0x49),
                Offset(0x50),
                FLDA,	2,
                LPDA,	2,
                Offset(0x51),
                FLIR,	4,
                LPIR,	4,
                U1IR,	4,
                U2IR,	4,
                Offset(0x55),
                ,	4,
                PIA_,	4,
                PIB_,	4,
                PIC_,	4,
                ,	4,
                PID_,	4,
                Offset(0x85),
                EP3C,	1,
                EN3C,	1,
                Offset(0x86)
            }
        }
        Device(LNKA) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x1)
            Method(_STA) {
                And(PIRA, 0xf0, Local0)
                If(LEqual(Local0, 0x0)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Name(BUFB, Buffer(0x6) {0x23, 0xfa, 0xdc, 0x18, 0x79, 0x0 })
                Return(BUFB)
            }
            Method(_DIS) {
                And(PIRA, 0xf, PIRA)
            }
            Method(_CRS) {
                Name(BUFB, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                CreateByteField(BUFB, 0x1, IRB1)
                CreateByteField(BUFB, 0x2, IRB2)
                Store(0x0, Local3)
                Store(0x0, Local4)
                And(PIRA, 0xf0, Local1)
                ShiftRight(Local1, 0x4, Local1)
                If(LNot(LEqual(Local1, 0x0))) {
                    If(LGreater(Local1, 0x7)) {
                        Subtract(Local1, 0x8, Local2)
                        ShiftLeft(One, Local2, Local4)
                    }
                    Else {
                        If(LGreater(Local1, 0x0)) {
                            ShiftLeft(One, Local1, Local3)
                        }
                    }
                    Store(Local3, IRB1)
                    Store(Local4, IRB2)
                }
                Return(BUFB)
            }
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x1, IRB1)
                CreateByteField(Arg0, 0x2, IRB2)
                ShiftLeft(IRB2, 0x8, Local0)
                Or(Local0, IRB1, Local0)
                Store(0x0, Local1)
                ShiftRight(Local0, 0x1, Local0)
                While(LGreater(Local0, 0x0)) {
                    Increment(Local1)
                    ShiftRight(Local0, 0x1, Local0)
                }
                And(PIRA, 0xf, PIRA)
                ShiftLeft(Local1, 0x4, Local1)
                Or(PIRA, Local1, PIRA)
            }
        }
        Device(LNKB) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x2)
            Method(_STA) {
                And(PIBC, 0xf, Local0)
                If(LEqual(Local0, 0x0)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Name(BUFA, Buffer(0x6) {0x23, 0xfa, 0xdc, 0x18, 0x79, 0x0 })
                Return(BUFA)
            }
            Method(_DIS) {
                And(PIBC, 0xf0, PIBC)
            }
            Method(_CRS) {
                Name(BUFA, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                CreateByteField(BUFA, 0x1, IRA1)
                CreateByteField(BUFA, 0x2, IRA2)
                Store(0x0, Local3)
                Store(0x0, Local4)
                And(PIBC, 0xf, Local1)
                If(LNot(LEqual(Local1, 0x0))) {
                    If(LGreater(Local1, 0x7)) {
                        Subtract(Local1, 0x8, Local2)
                        ShiftLeft(One, Local2, Local4)
                    }
                    Else {
                        If(LGreater(Local1, 0x0)) {
                            ShiftLeft(One, Local1, Local3)
                        }
                    }
                    Store(Local3, IRA1)
                    Store(Local4, IRA2)
                }
                Return(BUFA)
            }
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x1, IRA1)
                CreateByteField(Arg0, 0x2, IRA2)
                ShiftLeft(IRA2, 0x8, Local0)
                Or(Local0, IRA1, Local0)
                Store(0x0, Local1)
                ShiftRight(Local0, 0x1, Local0)
                While(LGreater(Local0, 0x0)) {
                    Increment(Local1)
                    ShiftRight(Local0, 0x1, Local0)
                }
                And(PIBC, 0xf0, PIBC)
                Or(PIBC, Local1, PIBC)
            }
        }
        Device(LNKC) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x3)
            Method(_STA) {
                And(PIBC, 0xf0, Local0)
                If(LEqual(Local0, 0x0)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Name(BUFC, Buffer(0x6) {0x23, 0xfa, 0xdc, 0x18, 0x79, 0x0 })
                Return(BUFC)
            }
            Method(_DIS) {
                And(PIBC, 0xf, PIBC)
            }
            Method(_CRS) {
                Name(BUFC, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                CreateByteField(BUFC, 0x1, IRC1)
                CreateByteField(BUFC, 0x2, IRC2)
                Store(0x0, Local3)
                Store(0x0, Local4)
                And(PIBC, 0xf0, Local1)
                ShiftRight(Local1, 0x4, Local1)
                If(LNot(LEqual(Local1, 0x0))) {
                    If(LGreater(Local1, 0x7)) {
                        Subtract(Local1, 0x8, Local2)
                        ShiftLeft(One, Local2, Local4)
                    }
                    Else {
                        If(LGreater(Local1, 0x0)) {
                            ShiftLeft(One, Local1, Local3)
                        }
                    }
                    Store(Local3, IRC1)
                    Store(Local4, IRC2)
                }
                Return(BUFC)
            }
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x1, IRC1)
                CreateByteField(Arg0, 0x2, IRC2)
                ShiftLeft(IRC2, 0x8, Local0)
                Or(Local0, IRC1, Local0)
                Store(0x0, Local1)
                ShiftRight(Local0, 0x1, Local0)
                While(LGreater(Local0, 0x0)) {
                    Increment(Local1)
                    ShiftRight(Local0, 0x1, Local0)
                }
                And(PIBC, 0xf, PIBC)
                ShiftLeft(Local1, 0x4, Local1)
                Or(PIBC, Local1, PIBC)
            }
        }
        Device(LNKD) {
            Name(_HID, 0x0f0cd041)
            Name(_UID, 0x4)
            Method(_STA) {
                And(PIRD, 0xf0, Local0)
                If(LEqual(Local0, 0x0)) {
                    Return(0x9)
                }
                Else {
                    Return(0xb)
                }
            }
            Method(_PRS) {
                Name(BUFD, Buffer(0x6) {0x23, 0xfa, 0xdc, 0x18, 0x79, 0x0 })
                Return(BUFD)
            }
            Method(_DIS) {
                And(PIRD, 0xf, PIRD)
            }
            Method(_CRS) {
                Name(BUFD, Buffer(0x6) {0x23, 0x0, 0x0, 0x18, 0x79, 0x0 })
                CreateByteField(BUFD, 0x1, IRD1)
                CreateByteField(BUFD, 0x2, IRD2)
                Store(0x0, Local3)
                Store(0x0, Local4)
                And(PIRD, 0xf0, Local1)
                ShiftRight(Local1, 0x4, Local1)
                If(LNot(LEqual(Local1, 0x0))) {
                    If(LGreater(Local1, 0x7)) {
                        Subtract(Local1, 0x8, Local2)
                        ShiftLeft(One, Local2, Local4)
                    }
                    Else {
                        If(LGreater(Local1, 0x0)) {
                            ShiftLeft(One, Local1, Local3)
                        }
                    }
                    Store(Local3, IRD1)
                    Store(Local4, IRD2)
                }
                Return(BUFD)
            }
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x1, IRD1)
                CreateByteField(Arg0, 0x2, IRD2)
                ShiftLeft(IRD2, 0x8, Local0)
                Or(Local0, IRD1, Local0)
                Store(0x0, Local1)
                ShiftRight(Local0, 0x1, Local0)
                While(LGreater(Local0, 0x0)) {
                    Increment(Local1)
                    ShiftRight(Local0, 0x1, Local0)
                }
                And(PIRD, 0xf, PIRD)
                ShiftLeft(Local1, 0x4, Local1)
                Or(PIRD, Local1, PIRD)
            }
        }
        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(0x52) {0x47, 0x1, 0x10, 0x0, 0x10, 0x0, 0x1, =
0x10, 0x47, 0x1, 0x22, 0x0, 0x22, 0x0, 0x1, 0x1e, 0x47, 0x1, 0x44, 0x0, 0x4=
4, 0x0, 0x1, 0x1c, 0x47, 0x1, 0x62, 0x0, 0x62, 0x0, 0x1, 0x2, 0x47, 0x1, 0x=
65, 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, 0x=
0, 0xe0, 0x0, 0x1, 0x10, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x79, 0=
x0 })
        }
        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, 0=
x4, 0x22, 0x1, 0x0, 0x79, 0x0 })
        }
        Device(RTC_) {
            Name(_HID, 0x000bd041)
            Name(_CRS, Buffer(0xd) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0, 0x4, 0=
x4, 0x22, 0x0, 0x1, 0x79, 0x0 })
        }
        Device(SPKR) {
            Name(_HID, 0x0008d041)
            Name(_CRS, Buffer(0xa) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0, 0x1, 0=
x1, 0x79, 0x0 })
        }
        Device(COPR) {
            Name(_HID, 0x040cd041)
            Name(_CRS, Buffer(0xd) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0, 0x1, 0=
x10, 0x22, 0x0, 0x20, 0x79, 0x0 })
        }
        OperationRegion(SPIO, SystemIO, 0x03f0, 0x2)
        Field(SPIO, ByteAcc, NoLock, Preserve) {
            INDX,	8,
            DATA,	8
        }
        IndexField(INDX, DATA, ByteAcc, NoLock, Preserve) {
            Offset(0xe0),
            CRC0,	8,
            CRC1,	8,
            CRC2,	8,
            CRC3,	8,
            CRC4,	8,
            CRC5,	8,
            CRC6,	8,
            CRC7,	8,
            CRC8,	8,
            CRC9,	8,
            CRCA,	8,
            CRCB,	8,
            CRCC,	8,
            CRCD,	8,
            CRCE,	8,
            CRCF,	8,
            CRD0,	8,
            CRD1,	8,
            CRD2,	8,
            CRD3,	8,
            CRD4,	8,
            CRD5,	8,
            CRD6,	8,
            CRD7,	8,
            CRD8,	8
        }
        OperationRegion(PCIC, SystemIO, 0x0cf8, 0x8)
        Field(PCIC, DWordAcc, NoLock, Preserve) {
            PIND,	32,
            PDAT,	32
        }
        Method(ENFG) {
            Store(0x80003884, PIND)
            Store(PDAT, Local0)
            Or(Local0, 0x0200, Local0)
            Store(0x80003884, PIND)
            Store(Local0, PDAT)
        }
        Method(EXFG) {
            Store(0x80003884, PIND)
            Store(PDAT, Local0)
            And(Local0, 0xfffffdff, Local0)
            Store(0x80003884, PIND)
            Store(Local0, PDAT)
        }
        Device(FDC0) {
            Name(_HID, 0x0007d041)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                Else {
                    ENFG
                    Store(CRC2, Local0)
                    And(Local0, 0x10, Local0)
                    If(LNot(LEqual(Local0, 0x0))) {
                        EXFG
                        Return(0xf)
                    }
                    Else {
                        Store(CRC3, Local1)
                        If(LNot(LEqual(Local1, 0x0))) {
                            EXFG
                            Return(0xd)
                        }
                        Else {
                            EXFG
                            Return(0x0)
                        }
                    }
                }
            }
            Method(_DIS) {
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0xef, Local0)
                Store(Local0, CRC2)
                EXFG
            }
            Method(_CRS) {
                Name(BUFF, Buffer(0x18) {0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0=
x8, 0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, =
0x4, 0x4, 0x79, 0x0 })
                Return(BUFF)
            }
            Name(_PRS, Buffer(0x18) {0x47, 0x1, 0xf0, 0x3, 0xf0, 0x3, 0x8, =
0x6, 0x47, 0x1, 0xf7, 0x3, 0xf7, 0x3, 0x1, 0x1, 0x22, 0x40, 0x0, 0x2a, 0x4,=
 0x4, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x11, IRQ0)
                CreateByteField(Arg0, 0x14, DMA0)
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0xef, Local1)
                Store(Local1, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                And(Local0, 0xfc, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC3)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.FLIR)
                FindSetRightBit(DMA0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.FLDA)
                Store(CRC2, Local0)
                Or(Local0, 0x10, Local1)
                Store(Local1, CRC2)
                EXFG
            }
        }
        Device(UAR1) {
            Name(_HID, 0x0105d041)
            Name(_UID, 0x1)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                Else {
                    ENFG
                    Store(CRC2, Local0)
                    And(Local0, 0x4, Local0)
                    If(LNot(LEqual(Local0, 0x0))) {
                        EXFG
                        Return(0xf)
                    }
                    Else {
                        Store(CRC7, Local1)
                        If(LNot(LEqual(Local1, 0x0))) {
                            EXFG
                            Return(0xd)
                        }
                        Else {
                            EXFG
                            Return(0x0)
                        }
                    }
                }
            }
            Method(_DIS) {
                ENFG
                EXFG
            }
            Method(_CRS) {
                Name(BFU1, Buffer(0xd) {0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3, 0x=
8, 0x8, 0x22, 0x10, 0x0, 0x79, 0x0 })
                CreateWordField(BFU1, 0x2, IMIN)
                CreateWordField(BFU1, 0x4, IMAX)
                CreateWordField(BFU1, 0x9, IRQ0)
                ENFG
                Store(CRC7, Local0)
                Store(Local0, Local1)
                And(Local1, 0xc0, Local1)
                ShiftLeft(Local1, 0x2, Local1)
                And(Local0, 0x3f, Local0)
                ShiftLeft(Local0, 0x2, Local0)
                Or(Local0, Local1, Local0)
                Store(Local0, IMIN)
                Store(Local0, IMAX)
                EXFG
                Store(\_SB_.PCI0.PIB_.U1IR, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, IRQ0)
                Return(BFU1)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3,=
 0x8, 0x8, 0x22, 0x10, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8=
, 0x22, 0x8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0x=
10, 0x0, 0x30, 0x47, 0x1, 0xe=
8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22, 0x8, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x9, IRQ0)
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0xfb, Local1)
                Store(Local1, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                And(Local0, 0xfe, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC7)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.U1IR)
                Store(CRC2, Local0)
                Or(Local0, 0x4, Local1)
                Store(Local1, CRC2)
                EXFG
            }
        }
        Device(UAR2) {
            Name(_HID, 0x0105d041)
            Name(_UID, 0x2)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                Else {
                    ENFG
                    Store(CRCE, Local0)
                    And(Local0, 0x38, Local0)
                    If(LNot(LEqual(Local0, 0x8))) {
                        Store(CRC2, Local1)
                        And(Local1, 0x8, Local1)
                        If(LNot(LEqual(Local1, 0x0))) {
                            EXFG
                            Return(0xf)
                        }
                        Else {
                            Store(CRC8, Local1)
                            If(LNot(LEqual(Local1, 0x0))) {
                                EXFG
                                Return(0xd)
                            }
                            Else {
                                EXFG
                                Return(0x0)
                            }
                        }
                    }
                    Else {
                        EXFG
                        Return(0x0)
                    }
                }
            }
            Method(_DIS) {
                ENFG
                EXFG
            }
            Method(_CRS) {
                Name(BFU2, Buffer(0xd) {0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x=
8, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0 })
                CreateWordField(BFU2, 0x2, IMIN)
                CreateWordField(BFU2, 0x4, IMAX)
                CreateWordField(BFU2, 0x9, IRQ0)
                ENFG
                Store(CRC8, Local0)
                Store(Local0, Local1)
                And(Local1, 0xc0, Local1)
                ShiftLeft(Local1, 0x2, Local1)
                And(Local0, 0x3f, Local0)
                ShiftLeft(Local0, 0x2, Local0)
                Or(Local0, Local1, Local0)
                Store(Local0, IMIN)
                Store(Local0, IMAX)
                EXFG
                Store(\_SB_.PCI0.PIB_.U2IR, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, IRQ0)
                Return(BFU2)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3,=
 0x8, 0x8, 0x22, 0x10, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8=
, 0x22, 0x8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0x=
10, 0x0, 0x30, 0x47, 0x1, 0xe=
8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22, 0x8, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x9, IRQ0)
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0xf7, Local1)
                Store(Local1, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                And(Local0, 0xfe, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC8)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.U2IR)
                Store(CRC2, Local0)
                Or(Local0, 0x8, Local1)
                Store(Local1, CRC2)
                EXFG
            }
        }
        Device(IRDA) {
            Name(_HID, 0x1005d041)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                ENFG
                Store(CRCE, Local0)
                And(Local0, 0x38, Local0)
                If(LEqual(Local0, 0x8)) {
                    And(CRC2, 0x8, Local1)
                    If(LNot(LEqual(Local1, 0x0))) {
                        EXFG
                        Return(0xf)
                    }
                    Else {
                        EXFG
                        Return(0xd)
                    }
                }
                Else {
                    EXFG
                    Return(0x0)
                }
            }
            Method(_DIS) {
                If(LEqual(DISE, 0x1)) {
                    ENFG
                    And(CRC2, 0xf7, CRC2)
                    EXFG
                }
                Store(Local0, Local0)
            }
            Method(_CRS) {
                Name(BFU2, Buffer(0xd) {0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x=
8, 0x8, 0x22, 0x8, 0x0, 0x79, 0x0 })
                CreateWordField(BFU2, 0x2, IMIN)
                CreateWordField(BFU2, 0x4, IMAX)
                CreateWordField(BFU2, 0x9, IRQ0)
                ENFG
                Store(CRC8, Local0)
                Store(Local0, Local1)
                And(Local1, 0xc0, Local1)
                ShiftLeft(Local1, 0x2, Local1)
                And(Local0, 0x3f, Local0)
                ShiftLeft(Local0, 0x2, Local0)
                Or(Local0, Local1, Local0)
                Store(Local0, IMIN)
                Store(Local0, IMAX)
                EXFG
                Store(\_SB_.PCI0.PIB_.U2IR, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, IRQ0)
                Return(BFU2)
            }
            Name(_PRS, Buffer(0x33) {0x30, 0x47, 0x1, 0xf8, 0x3, 0xf8, 0x3,=
 0x8, 0x8, 0x22, 0x10, 0x0, 0x30, 0x47, 0x1, 0xf8, 0x2, 0xf8, 0x2, 0x8, 0x8=
, 0x22, 0x8, 0x0, 0x30, 0x47, 0x1, 0xe8, 0x3, 0xe8, 0x3, 0x8, 0x8, 0x22, 0x=
10, 0x0, 0x30, 0x47, 0x1, 0xe=
8, 0x2, 0xe8, 0x2, 0x8, 0x8, 0x22, 0x8, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x9, IRQ0)
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0xf7, Local1)
                Store(Local1, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                And(Local0, 0xfe, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC8)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.U2IR)
                Store(CRC2, Local0)
                Or(Local0, 0x8, Local1)
                Store(Local1, CRC2)
                EXFG
            }
        }
        Device(LPT1) {
            Name(PIOM, Buffer(0x1) {0x0 })
            CreateByteField(PIOM, 0x0, LPTM)
            Name(_HID, 0x0004d041)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                Else {
                    ENFG
                    Store(CRC2, Local0)
                    And(Local0, 0x3, Local0)
                    If(LEqual(Local0, 0x1)) {
                        EXFG
                        Return(0x0)
                    }
                    If(LEqual(Local0, 0x3)) {
                        Store(CRC6, Local1)
                        If(LNot(LEqual(Local1, 0x0))) {
                            EXFG
                            Return(0xd)
                        }
                        Else {
                            EXFG
                            Return(0x0)
                        }
                    }
                    Else {
                        Store(Local0, LPTM)
                        EXFG
                        Return(0xf)
                    }
                }
            }
            Method(_DIS) {
                ENFG
                Or(CRC2, 0x3, CRC2)
                EXFG
            }
            Method(_CRS) {
                Name(BUFL, Buffer(0xd) {0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0x=
8, 0x8, 0x22, 0x80, 0x0, 0x79, 0x0 })
                CreateWordField(BUFL, 0x2, IMIN)
                CreateWordField(BUFL, 0x4, IMAX)
                CreateByteField(BUFL, 0x6, LALN)
                CreateByteField(BUFL, 0x7, LLEN)
                CreateWordField(BUFL, 0x9, IRQ0)
                ENFG
                Store(CRC6, Local0)
                EXFG
                Store(Local0, Local1)
                And(Local1, 0xc0, Local1)
                ShiftLeft(Local1, 0x2, Local1)
                ShiftLeft(Local0, 0x2, Local0)
                Or(Local0, Local1, Local0)
                Store(Local0, IMIN)
                Store(Local0, IMAX)
                If(LEqual(IMIN, 0x03bc)) {
                    Store(0x4, LALN)
                    Store(0x4, LLEN)
                }
                Else {
                    Store(0x8, LALN)
                    Store(0x8, LLEN)
                }
                Store(\_SB_.PCI0.PIB_.LPIR, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, IRQ0)
                Return(BUFL)
            }
            Name(_PRS, Buffer(0x27) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3,=
 0x8, 0x8, 0x22, 0x80, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8=
, 0x22, 0x20, 0x0, 0x30, 0x47, 0x1, 0xbc, 0x3, 0xbc, 0x3, 0x4, 0x4, 0x22, 0=
x80, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x9, IRQ0)
                ENFG
                Store(CRC2, Local0)
                Or(Local0, 0x3, Local0)
                Store(Local0, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC6)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.LPIR)
                Store(CRC2, Local0)
                And(Local0, 0xfc, Local0)
                Store(LPTM, Local1)
                Or(Local0, Local1, Local1)
                Store(Local1, CRC2)
                EXFG
            }
        }
        Device(ECP1) {
            Name(_HID, 0x0104d041)
            Method(_STA) {
                Store(0x80003884, PIND)
                Store(PDAT, Local0)
                And(Local0, 0x0100, Local0)
                If(LNot(Local0)) {
                    Return(0x0)
                }
                ENFG
                Store(CRC2, Local0)
                And(Local0, 0x3, Local0)
                If(LOr(LEqual(Local0, 0x0), LEqual(Local0, 0x2))) {
                    EXFG
                    Return(0x0)
                }
                If(LEqual(Local0, 0x1)) {
                    EXFG
                    Return(0xf)
                }
                If(LEqual(Local0, 0x3)) {
                    If(LNot(LEqual(\_SB_.PCI0.PIB_.LPDA, 0x0))) {
                        EXFG
                        Return(0xd)
                    }
                    Else {
                        EXFG
                        Return(0x0)
                    }
                }
            }
            Method(_DIS) {
            }
            Method(_CRS) {
                Name(BUFE, Buffer(0x18) {0x47, 0x1, 0x78, 0x3, 0x78, 0x3, 0=
x8, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x8, 0x8, 0x22, 0x80, 0x0, 0x2a, =
0x8, 0x0, 0x79, 0x0 })
                CreateWordField(BUFE, 0x2, IMI1)
                CreateWordField(BUFE, 0x4, IMA1)
                CreateByteField(BUFE, 0x6, ALN1)
                CreateByteField(BUFE, 0x7, LEN1)
                CreateWordField(BUFE, 0xa, IMI2)
                CreateWordField(BUFE, 0xc, IMA2)
                CreateByteField(BUFE, 0xe, ALN2)
                CreateByteField(BUFE, 0xf, LEN2)
                CreateWordField(BUFE, 0x11, IRQ0)
                CreateByteField(BUFE, 0x14, DMA0)
                ENFG
                Store(CRC6, Local0)
                EXFG
                Store(Local0, Local1)
                And(Local1, 0xc0, Local1)
                ShiftLeft(Local1, 0x2, Local1)
                ShiftLeft(Local0, 0x2, Local0)
                Or(Local0, Local1, Local0)
                Store(Local0, IMI1)
                Store(Local0, IMA1)
                Add(Local0, 0x0400, Local0)
                Store(Local0, IMI2)
                Store(Local0, IMA2)
                If(LEqual(IMI1, 0x03bc)) {
                    Store(0x4, ALN1)
                    Store(0x4, LEN1)
                    Store(0x4, ALN2)
                    Store(0x4, LEN2)
                }
                Else {
                    Store(0x8, ALN1)
                    Store(0x8, LEN1)
                    Store(0x4, ALN2)
                    Store(0x4, LEN2)
                }
                Store(\_SB_.PCI0.PIB_.LPIR, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, IRQ0)
                Store(\_SB_.PCI0.PIB_.LPDA, Local0)
                And(Local0, 0x3, Local0)
                Store(0x1, Local1)
                ShiftLeft(Local1, Local0, DMA0)
                Return(BUFE)
            }
            Name(_PRS, Buffer(0x31) {0x30, 0x47, 0x1, 0x78, 0x3, 0x78, 0x3,=
 0x8, 0x8, 0x47, 0x1, 0x78, 0x7, 0x78, 0x7, 0x4, 0x4, 0x22, 0x80, 0x0, 0x2a=
, 0xa, 0x0, 0x30, 0x47, 0x1, 0x78, 0x2, 0x78, 0x2, 0x8, 0x8, 0x47, 0x1, 0x7=
8, 0x6, 0x78, 0x6, 0x4, 0x4,=20=
0x22, 0x20, 0x0, 0x2a, 0xa, 0x0, 0x38, 0x79, 0x0 })
            Method(_SRS, 1) {
                CreateByteField(Arg0, 0x2, IOLO)
                CreateByteField(Arg0, 0x3, IOHI)
                CreateWordField(Arg0, 0x11, IRQ0)
                CreateByteField(Arg0, 0x14, DMA0)
                ENFG
                Store(CRC2, Local0)
                Or(Local0, 0x3, Local0)
                Store(Local0, CRC2)
                Store(IOLO, Local0)
                ShiftRight(Local0, 0x2, Local0)
                Store(IOHI, Local1)
                ShiftLeft(Local1, 0x6, Local1)
                Or(Local0, Local1, Local0)
                Store(Local0, CRC6)
                FindSetRightBit(IRQ0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.LPIR)
                FindSetRightBit(DMA0, Local0)
                If(LGreater(Local0, 0x0)) {
                    Decrement(Local0)
                }
                Store(Local0, \_SB_.PCI0.PIB_.LPDA)
                Store(CRC2, Local0)
                And(Local0, 0xfc, Local0)
                Or(Local0, 0x1, Local0)
                Store(Local0, CRC2)
                EXFG
            }
        }
        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, 0=
x1, 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 })
        }
        Method(_PRW) {
            Return(Package(0x2) {
                0x5,
                0x5,
            })
        }
        Method(\_SB_.PCI0.UAR1._PRW) {
            If(OSFL) {
                Return(Package(0x2) {
                    0x8,
                    0x4,
                })
            }
            Else {
                Return(Package(0x2) {
                    0x8,
                    0x8,
                })
            }
        }
        Method(\_SB_.PCI0.UAR2._PRW) {
            If(OSFL) {
                Return(Package(0x2) {
                    0x8,
                    0x4,
                })
            }
            Else {
                Return(Package(0x2) {
                    0x8,
                    0x8,
                })
            }
        }
        Method(\_SB_.PCI0.ECP1._PRW) {
            If(OSFL) {
                Return(Package(0x2) {
                    0x8,
                    0x4,
                })
            }
            Else {
                Return(Package(0x2) {
                    0x8,
                    0x8,
                })
            }
        }
    }
}

-S=F8ren
