The following reply was made to PR kern/42051; it has been noted by GNATS.
From: Arto Huusko <arto.huusko%pp2.inet.fi@localhost>
To: gnats-bugs%NetBSD.org@localhost
Cc:
Subject: Re: kern/42051
Date: Mon, 14 Sep 2009 21:09:51 +0300
This is a multi-part message in MIME format.
--------------020902030803040906090409
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
> dmesg and ACPI dump of the machine attached.
For real this time.
--------------020902030803040906090409
Content-Type: text/plain;
name="acer5530.acpi"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline;
filename="acer5530.acpi"
/*
RSD PTR: Checksum=3D2, OEMID=3DACRSYS, RsdtAddress=3D0xafed1755
*/
/*
RSDT: Length=3D64, Revision=3D1, Checksum=3D116,
OEMID=3DACRSYS, OEM Table ID=3DACRPRDCT, OEM Revision=3D0x6040000,
Creator ID=3D LTP, Creator Revision=3D0x0
*/
/*
Entries=3D{ 0xafedb965, 0xafedb9d9, 0xafedbb4f, 0xafedbe03, 0xafedbe61,
=
0xafedbe9d, 0xafedbed5 }
*/
/*
DSDT=3D0xafed17f1
INT_MODEL=3DPIC
SCI_INT=3D9
SMI_CMD=3D0xb0, ACPI_ENABLE=3D0xf0, ACPI_DISABLE=3D0xf1,
S4BIOS_REQ=3D0x=
0
PM1a_EVT_BLK=3D0x8000-0x8003
PM1a_CNT_BLK=3D0x8004-0x8005
PM2_CNT_BLK=3D0x8200-0x8200
PM2_TMR_BLK=3D0x8008-0x800b
PM2_GPE0_BLK=3D0x8020-0x8027
P_LVL2_LAT=3D101ms, P_LVL3_LAT=3D1001ms
FLUSH_SIZE=3D0, FLUSH_STRIDE=3D0
DUTY_OFFSET=3D1, DUTY_WIDTH=3D3
DAY_ALRM=3D13, MON_ALRM=3D0, CENTURY=3D0
Flags=3D{WBINVD,PROC_C1,SLP_BUTTON,RTC_S4,TMR_VAL_EXT,DCK_CAP}
*/
/*
DSDT: Length=3D41088, Revision=3D1, Checksum=3D252,
OEMID=3DAcer, OEM Table ID=3DSB700, OEM Revision=3D0x6040000,
Creator ID=3DMSFT, Creator Revision=3D0x3000000
*/
DefinitionBlock ("acpi_dst.aml", "DSDT", 0x1, "Acer", "SB700", 0x6040000)=
{
Name(Z000, 0x01)
Name(Z001, 0x02)
Name(Z002, 0x04)
Name(Z003, 0x08)
Name(Z004, 0x00)
Name(Z005, 0x0f)
Name(Z006, 0x0d)
Name(Z007, 0x0b)
Name(Z008, 0x09)
Scope(\_PR) {
Processor(CPU0, 0, 0x8010, 0x6) {
}
Processor(CPU1, 1, 0x0, 0x0) {
}
}
Name(_S0, Package(0x04) {
0x00,
0x00,
0x00,
0x00,
})
Name(_S3, Package(0x04) {
0x03,
0x03,
0x00,
0x00,
})
Name(_S4, Package(0x04) {
0x04,
0x04,
0x00,
0x00,
})
Name(_S5, Package(0x04) {
0x05,
0x05,
0x00,
0x00,
})
Name(CRTS, 0x00)
OperationRegion(\DEB2, SystemIO, 0x80, 0x02)
Field(\DEB2, WordAcc, NoLock, Preserve) {
P80H, 16
}
OperationRegion(\PMIO, SystemIO, 0x0cd6, 0x02)
Field(\PMIO, ByteAcc, NoLock, Preserve) {
PIDX, 8,
PDAT, 8
}
OperationRegion(\P01, SystemIO, 0x8001, 0x01)
Field(\P01, ByteAcc, NoLock, Preserve) {
PST1, 8
}
OperationRegion(MNVS, SystemMemory, 0xafedde74, 0xaa55)
Field(MNVS, AnyAcc, Lock, Preserve) {
OSYS, 16,
SMIF, 8,
PRM0, 8,
PRM1, 8,
SCIF, 8,
PRM2, 8,
PRM3, 8,
LCKF, 8,
PRM4, 8,
PRM5, 8,
P80D, 32,
LIDS, 8,
UMAS, 8,
CPUS, 8,
PTYP, 8,
KBTP, 8,
PJID, 8,
SFIR, 8,
SBTH, 8,
EBID, 8
}
Name(HTTX, 0x00)
Method(_PTS, 1) {
If(LNot(LGreater(\_SB.PCI0.SMB.RVID, 0x13))) {
Store(Zero, \_SB.PCI0.SMB.PWDE)
}
If(LEqual(Arg0, 0x05)) {
Store(0x05, P80H)
Store(One, \_SB.PCI0.SMB.SLPS)
}
If(LEqual(Arg0, 0x04)) {
Store(0x04, P80H)
\_SB.PCI0.LPC0.PHSS(0x0e)
Store(One, \_SB.PCI0.SMB.SLPS)
}
If(LEqual(Arg0, 0x03)) {
Store(0x03, P80H)
Store(Zero, \_SB.PCI0.SMB.RSTU)
Store(One, \_SB.PCI0.SMB.SLPS)
}
}
Method(_WAK, 1) {
Store(0xe0, P80H)
\_GPE._L1A()
Store(0xe1, P80H)
If(LEqual(\_SB.TPOS, 0x80)) {
Store(0xe2, P80H)
Store(One, \_SB.PCI0.SMB.MT3A)
}
Store(\_SB.PCI0.SMB.PEWS, \_SB.PCI0.SMB.PEWS)
Store(One, \_SB.PCI0.SMB.HECO)
Store(0xe3, P80H)
Store(0x81, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Store(0xe4, P80H)
If(LEqual(Arg0, 0x03)) {
Store(0x13, P80H)
If(LOr(LEqual(PJID, 0x00), LEqual(PJID, 0x02))) {
Notify(\_SB.PCI0.PB9, 0x00)
}
Store(0x23, P80H)
Store(One, \_SB.PCI0.SMB.RSTU)
Store(One, \_SB.PCI0.SMB.IR9S)
Store(One, \_SB.PCI0.SMB.IR9E)
Store(0x33, P80H)
If(LEqual(\_SB.TPOS, 0x40)) {
Notify(\_SB.PWRB, 0x02)
}
Store(0x63, P80H)
}
If(LEqual(Arg0, 0x04)) {
Store(0x14, P80H)
\_SB.PCI0.LPC0.PHSS(0x0f)
Store(0x24, P80H)
If(GPIC) {
Store(0x34, P80H)
\_SB.PCI0.LPC0.DSPI()
}
Store(0x44, P80H)
Notify(\_SB.PWRB, 0x02)
Store(0x64, P80H)
}
Notify(\_SB.PCI0, 0x00)
}
Scope(\_SI) {
Method(_SST, 1) {
If(LEqual(Arg0, 0x01)) {
Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Working\x20\x3d\x3d\x3d=
\x3d\x3d", Debug)
}
If(LEqual(Arg0, 0x02)) {
Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Waking\x20\x3d\x3d\x3d\=
x3d\x3d", Debug)
}
If(LEqual(Arg0, 0x03)) {
Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Sleeping\x20\x3d\x3d\x3=
d\x3d\x3d", Debug)
}
If(LEqual(Arg0, 0x04)) {
Store("\x3d\x3d\x3d\x3d\x3d\x20SST\x20Sleeping\x20S4\x20\x3d\=
x3d\x3d\x3d\x3d", Debug)
}
}
}
Scope(\_SB) {
Name(LINX, 0x00)
Name(OSSP, 0x00)
Name(OSTB, Ones)
OperationRegion(OSTY, SystemMemory, 0xafedddfc, 0x00000001)
Field(OSTY, AnyAcc, NoLock, Preserve) {
TPOS, 8
}
Method(OSTP) {
If(LEqual(^OSTB, Ones)) {
If(CondRefOf(\_OSI, Local0)) {
Store(0x00, ^OSTB)
Store(0x00, ^TPOS)
If(\_OSI("Windows\x202001")) {
Store(0x08, ^OSTB)
Store(0x08, ^TPOS)
}
If(\_OSI("Windows\x202001.1")) {
Store(0x20, ^OSTB)
Store(0x20, ^TPOS)
}
If(\_OSI("Windows\x202001\x20SP1")) {
Store(0x10, ^OSTB)
Store(0x10, ^TPOS)
}
If(\_OSI("Windows\x202001\x20SP2")) {
Store(0x11, ^OSTB)
Store(0x11, ^TPOS)
}
If(\_OSI("Windows\x202001\x20SP3")) {
Store(0x12, ^OSTB)
Store(0x12, ^TPOS)
}
If(\_OSI("Windows\x202006")) {
Store(0x40, ^OSTB)
Store(0x40, ^TPOS)
Store(0x40, OSYS)
}
If(\_OSI("Windows\x202006\x20SP1")) {
Store(0x01, OSSP)
Store(0x40, ^OSTB)
Store(0x40, ^TPOS)
}
If(\_OSI("Linux")) {
Store(0x01, LINX)
Store(0x80, ^OSTB)
Store(0x80, ^TPOS)
}
}
Else {
If(CondRefOf(\_OS, Local0)) {
If(^SEQL(\_OS, "Microsoft\x20Windows")) {
Store(0x01, ^OSTB)
Store(0x01, ^TPOS)
}
Else {
If(^SEQL(\_OS, "Microsoft\x20WindowsME\x3a\x20Mil=
lennium\x20Edition")) {
Store(0x02, ^OSTB)
Store(0x02, ^TPOS)
}
Else {
If(^SEQL(\_OS, "Microsoft\x20Windows\x20NT"))=
{
Store(0x04, ^OSTB)
Store(0x04, ^TPOS)
}
Else {
Store(0x00, ^OSTB)
Store(0x00, ^TPOS)
}
}
}
}
Else {
Store(0x00, ^OSTB)
Store(0x00, ^TPOS)
}
}
Store(0xb0, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
If(LEqual(TPOS, 0x80)) {
Store(One, \_SB.PCI0.SMB.MT3A)
}
}
Return(^OSTB)
}
Method(OSHT) {
\_SB.OSTP()
Store(0x48, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
}
Method(SEQL, 2, Serialized) {
Store(SizeOf(Arg0), Local0)
Store(SizeOf(Arg1), Local1)
If(LNot(LEqual(Local0, Local1))) {
Return(Zero)
}
Name(BUF0, Buffer(Local0) { })
Store(Arg0, BUF0)
Name(BUF1, Buffer(Local0) { })
Store(Arg1, BUF1)
Store(Zero, Local2)
While(LLess(Local2, Local0)) {
Store(DerefOf(Index(BUF0, Local2, )), Local3)
Store(DerefOf(Index(BUF1, Local2, )), Local4)
If(LNot(LEqual(Local3, Local4))) {
Return(Zero)
}
Increment(Local2)
}
Return(One)
}
}
Name(\GPIC, 0x00)
Method(\_PIC, 1) {
Store(Arg0, GPIC)
If(Arg0) {
\_SB.PCI0.LPC0.DSPI()
}
}
Scope(\_SB) {
Device(PWRB) {
Name(_HID, 0x0c0cd041)
}
Device(SLPB) {
Name(_HID, 0x0e0cd041)
}
Device(LID) {
Name(_HID, 0x0d0cd041)
Method(_LID) {
Return(LNot(\_SB.PCI0.SMB.GM4C))
}
}
Device(WMID) {
Name(_HID, "PNP0C14")
Name(_UID, 0x00)
Name(ERRD, 0x00010000)
Name(BUFF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 })
CreateByteField(BUFF, 0x00, BF00)
CreateByteField(BUFF, 0x01, BF01)
CreateByteField(BUFF, 0x02, BF02)
CreateByteField(BUFF, 0x03, BF03)
CreateByteField(BUFF, 0x04, BF04)
Name(BUF1, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
Name(AADS, Buffer(0x04) {0x0 })
CreateField(AADS, 0x00, 0x04, AS00)
CreateField(AADS, 0x04, 0x01, AS01)
CreateField(AADS, 0x05, 0x01, AS02)
CreateField(AADS, 0x10, 0x10, AS03)
Name(BAEF, 0x00)
Name(BADF, 0x00)
Name(BADG, Package(0x0d) {
0x01,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00,
0x00010000,
})
Name(WLDS, 0x00)
Name(WLED, 0x00)
Name(BTDS, 0x00)
Name(BTED, 0x00)
Name(BLDS, 0x00)
Name(BLED, 0x00)
Name(NTDC, 0x00)
Name(NTDV, 0x00)
Name(WLSD, 0x0100)
Name(WLSE, 0x0101)
Name(BLTD, 0x0200)
Name(BLTE, 0x0201)
Name(LBL0, 0x0300)
Name(LBL1, 0x0301)
Name(LBL2, 0x0302)
Name(LBL3, 0x0303)
Name(LBL4, 0x0304)
Name(LBL5, 0x0305)
Name(LBL6, 0x0306)
Name(LBL7, 0x0307)
Name(LBL8, 0x0308)
Name(LBL9, 0x0309)
Name(LBLA, 0x030a)
Name(LBLB, 0x030b)
Name(LBLC, 0x030c)
Name(LBLD, 0x030d)
Name(LBLE, 0x030e)
Name(LBLF, 0x030f)
Name(VAPO, 0x0600)
Name(VAPI, 0x0601)
Name(CADI, 0x0401)
Name(CADO, 0x0400)
Name(GSEE, 0x0501)
Name(GSED, 0x0502)
Name(WBBO, 0x0701)
Name(WBBI, 0x0700)
Name(G3MD, 0x0800)
Name(G3ME, 0x0801)
Name(LANI, 0x0900)
Name(LANO, 0x0901)
Name(LDOF, 0x0a00)
Name(LDON, 0x0a01)
Name(BBSB, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
CreateField(BBSB, 0x00, 0x10, BBD0)
CreateField(BBSB, 0x10, 0x10, BBD1)
Name(TLS0, 0x00)
Name(TLS1, 0x01)
Name(TLS2, 0x02)
Name(TLS3, 0x03)
Name(TLS4, 0x04)
Name(TLS5, 0x05)
Name(TLS6, 0x06)
Name(TLS7, 0x07)
Name(BCDS, Package(0x0d) {
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
})
Name(BDDS, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
CreateField(BDDS, 0x00, 0x10, BDD0)
CreateField(BDDS, 0x10, 0x10, BDD1)
Name(DSY0, Buffer(0x28) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0x0, 0x0 })
Name(DSY1, Buffer(0x18) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0 })
Name(DSY2, Buffer(0x10) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
Name(DSY3, Buffer(0x18) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0 })
Name(DSY4, Buffer(0x10) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
Name(DSY5, Buffer(0x28) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0=
x0, 0x0, 0x0 })
CreateField(DSY0, 0x00, 0x40, DY00)
CreateField(DSY0, 0x40, 0x40, DY01)
CreateField(DSY0, 0x80, 0x40, DY02)
CreateField(DSY0, 0xc0, 0x40, DY03)
CreateField(DSY0, 0x0100, 0x40, DY04)
CreateField(DSY1, 0x00, 0x40, DY10)
CreateField(DSY1, 0x40, 0x40, DY11)
CreateField(DSY1, 0x80, 0x40, DY12)
CreateField(DSY2, 0x00, 0x40, DY20)
CreateField(DSY2, 0x40, 0x10, DY21)
CreateField(DSY2, 0x50, 0x10, DY22)
CreateField(DSY0, 0x00, 0xc0, DSX4)
Name(BEDS, Package(0x13) {
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
0x00010000,
})
Name(WIT0, 0x00)
Name(DSY6, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
CreateField(DSY6, 0x00, 0x20, DY60)
CreateField(DSY6, 0x20, 0x20, DY61)
CreateField(DSY6, 0x40, 0x20, DY62)
CreateField(DSY6, 0x60, 0x20, DY63)
CreateField(DSY6, 0x80, 0x20, DY64)
Name(WPRW, Buffer(0x14) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 })
CreateField(WPRW, 0x00, 0x08, WWD0)
CreateField(WPRW, 0x08, 0x08, WWD1)
CreateField(WPRW, 0x10, 0x08, WWD2)
CreateField(WPRW, 0x18, 0x08, WWD3)
CreateField(WPRW, 0x20, 0x08, WWD4)
CreateField(WPRW, 0x28, 0x20, WWD5)
Name(WPCI, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
CreateField(WPCI, 0x00, 0x08, WPIR)
CreateField(WPCI, 0x08, 0x03, WPIF)
CreateField(WPCI, 0x0b, 0x05, WPID)
CreateField(WPCI, 0x10, 0x08, WPIB)
Name(BFDS, Package(0x04) {
0x02,
0x02,
0x02,
0x02,
})
Name(GSTS, 0x00)
Name(BFEF, 0x00)
Name(BGEF, 0x00)
Name(BGDS, Package(0x01) {
0x01,
})
Method(AAF1) {
Store(\_SB.PCI0.LPC0.EC0.WLEX, AS00)
Store(\_SB.PCI0.LPC0.EC0.BTEX, AS01)
Store(0x00, AS02)
Store(0x00, AS03)
}
Method(Z009, 1) {
Store(\_SB.PCI0.LPC0.EC0.WLAT, Local0)
Store(Local0, Index(BADG, 0x00, ))
Store(\_SB.PCI0.LPC0.EC0.BTAT, Local0)
Store(Local0, Index(BADG, 0x01, ))
Store(\_SB.PCI0.LPC0.EC0.BRTS, Local0)
Store(Local0, Index(BADG, 0x02, ))
Store(0x01, Local0)
Store(Local0, Index(BADG, 0x07, ))
Store(0x00, Local0)
Store(Local0, Index(BADG, 0x08, ))
Store(\_SB.PCI0.LPC0.EC0.LANC, Local0)
Store(Local0, Index(BADG, 0x0b, ))
If(LOr(LEqual(PJID, 0x02), LEqual(PJID, 0x03))) {
Store(ERRD, Index(BADG, 0x0b, ))
}
Store(\_SB.PCI0.LPC0.EC0.LCDS, Local0)
Store(Local0, Index(BADG, 0x0c, ))
}
Method(Z00A, 2) {
Store(Arg1, BUFF)
Store(Arg0, Local0)
Store(BF00, Local1)
Store(Local0, Debug)
Store(Local1, Debug)
Store(0x00, Local2)
While(One) {
Name(_T_0, 0x00)
Store(Local1, _T_0)
If(LEqual(_T_0, 0x00)) {
While(One) {
Name(_T_1, 0x00)
Store(Local0, _T_1)
If(LEqual(_T_1, 0x04)) {
Store(0x00, \_SB.PCI0.LPC0.EC0.WLAT)
}
Else {
If(LEqual(_T_1, 0x05)) {
Store(0x00, \_SB.PCI0.LPC0.EC0.BTAT)
}
Else {
If(LEqual(_T_1, 0x06)) {
Store(0x00, \_SB.PCI0.LPC0.EC0.BRTS)
}
Else {
If(LEqual(_T_1, 0x07)) {
Store(0x00, BAEF)
}
Else {
Store(0x01, Local2)
}
}
}
}
Break
}
}
Else {
While(One) {
Name(_T_2, 0x00)
Store(Local0, _T_2)
If(LEqual(_T_2, 0x04)) {
Store(0x01, \_SB.PCI0.LPC0.EC0.WLAT)
Store(0x00, Index(BADG, 0x03, ))
}
Else {
If(LEqual(_T_2, 0x05)) {
Store(0x01, \_SB.PCI0.LPC0.EC0.BTAT)
Store(0x00, Index(BADG, 0x04, ))
}
Else {
If(LEqual(_T_2, 0x06)) {
Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS=
)
Store(0x00, Index(BADG, 0x05, ))
}
Else {
If(LEqual(_T_2, 0x07)) {
Store(0x01, BAEF)
Store(0x00, Index(BADG, 0x06, ))
}
Else {
Store(0x01, Local2)
}
}
}
}
Break
}
}
Break
}
If(LEqual(Local2, 0x01)) {
While(One) {
Name(_T_3, 0x00)
Store(Local0, _T_3)
If(LEqual(_T_3, 0x04)) {
Store(0x02, Index(BADG, 0x03, ))
}
Else {
If(LEqual(_T_3, 0x05)) {
Store(0x03, Index(BADG, 0x03, ))
}
Else {
If(LEqual(_T_3, 0x06)) {
Store(0x04, Index(BADG, 0x03, ))
}
}
}
Break
}
}
}
Method(Z00B) {
If(LEqual(BGEF, 0x01)) {
Store(NTDV, Local0)
If(LNot(LEqual(Local0, 0x00))) {
Store(0x00, NTDV)
Return(Local0)
}
}
If(LEqual(BAEF, 0x01)) {
Store(NTDC, Local0)
If(LNot(LEqual(Local0, 0x00))) {
Store(0x00, NTDC)
Return(Local0)
}
}
If(LEqual(BFEF, 0x01)) {
}
}
Method(Z00C, 2) {
Store(Arg0, Local0)
Store(Arg1, BUFF)
Store(0x00, BBSB)
If(LEqual(Local0, 0x01)) {
Store(SBTH, BBD0)
}
Else {
If(LEqual(Local0, 0x02)) {
Store(BF00, SBTH)
}
Else {
Store(ERRD, BBSB)
}
}
}
Method(Z00D, 2) {
Store(Arg1, BUFF)
Store(ERRD, Index(BCDS, BF00, ))
}
Method(Z00E, 1) {
Store(DSY5, DSY0)
Store(Arg0, Local0)
Store(\_SB.PHWM(0x00, Arg0), Local2)
Store(Local2, DSY6)
Store(DY60, DY00)
Store(DY61, DY01)
Store(DY62, DY02)
Store(DY63, DY03)
}
Method(Z00F, 1) {
Store(DSY3, DSY1)
Store(Arg0, DY00)
Store(\_SB.PHWM(0x01, Arg0), Local2)
Store(Local2, DSY6)
Store(DY60, DY10)
Store(DY61, DY11)
Store(0x00, WIT0)
Store(WIT0, DY12)
}
Method(Z00G, 1) {
Store(DSY3, DSY1)
Store(\_SB.PHWM(0x02, Arg0), Local2)
Store(Local2, DSY6)
Store(DY60, DY10)
Store(DY61, DY11)
Store(0x00, WIT0)
Store(WIT0, DY12)
}
Method(Z00H, 2) {
Store(0x00010000, Index(BCDS, 0x09, ))
}
Method(Z00I) {
Store(\_SB.PCI0.LPC0.EC0.THFN, Local0)
Multiply(Local0, 0x64, Local1)
Store(Local1, Index(BCDS, 0x0a, ))
}
Method(Z00J) {
Store(\_SB.PCI0.LPC0.EC0.CTMP, Index(BCDS, 0x0b, ))
}
Method(Z00K, 1) {
Store(Arg0, Local0)
Store(\_SB.PHWM(0x03, Arg0), Local2)
Store(Local2, DY20)
Store(Local2, DSY6)
Store(DSY4, DSY2)
Store(DY60, DY20)
}
Method(Z00L, 1) {
Store(Arg0, Local0)
Store(Arg0, DY20)
Store(\_SB.PHWM(0x04, Arg0), Local2)
Store(Local2, DSY6)
Store(DY61, BUFF)
}
Method(Z00M) {
Store(\_SB.PHWM(0x05, 0x00), Local2)
Store(Local2, BUFF)
Store(BUFF, Index(BCDS, 0x0c, ))
}
Method(PCID, 1) {
Store(\_SB.PHWM(0x03, Arg0), Local2)
Store(Local2, DSY6)
}
Method(Z00N, 2) {
Store(Arg0, Local0)
Store(Arg1, BUFF)
If(LEqual(\_SB.PCI0.LPC0.EC0.BDC0, 0x00)) {
Store(0x00020000, Local1)
Decrement(Local0)
Store(Local1, Index(BEDS, Local0, ))
}
Else {
While(One) {
Name(_T_0, 0x00)
Store(Local0, _T_0)
If(LEqual(_T_0, 0x01)) {
Store(0x00, Index(BEDS, 0x00, ))
}
Else {
If(LEqual(_T_0, 0x02)) {
Store(\_SB.PCI0.LPC0.EC0.BPTC, Index(BEDS, 0x=
01, ))
}
Else {
If(LEqual(_T_0, 0x03)) {
Store(\_SB.PCI0.LPC0.EC0.BPV0, Index(BEDS=
, 0x02, ))
}
Else {
If(LEqual(_T_0, 0x04)) {
Store(\_SB.PCI0.LPC0.EC0.BSCU, Index(=
BEDS, 0x03, ))
}
Else {
If(LEqual(_T_0, 0x05)) {
Store(\_SB.PCI0.LPC0.EC0.BRC0, In=
dex(BEDS, 0x04, ))
}
Else {
If(LEqual(_T_0, 0x06)) {
Store(\_SB.PCI0.LPC0.EC0.BFC0=
, Index(BEDS, 0x05, ))
}
Else {
If(LEqual(_T_0, 0x07)) {
Store(\_SB.PCI0.LPC0.EC0.=
BSCY, Index(BEDS, 0x06, ))
}
Else {
If(LEqual(_T_0, 0x08)) {
Store(\_SB.PCI0.LPC0.=
EC0.BDC0, Index(BEDS, 0x07, ))
}
Else {
If(LEqual(_T_0, 0x09)=
) {
Store(\_SB.PCI0.L=
PC0.EC0.BDV0, Index(BEDS, 0x08, ))
}
Else {
If(LEqual(_T_0, 0=
x0a)) {
Store(\_SB.PC=
I0.LPC0.EC0.BDAD, Index(BEDS, 0x09, ))
}
Else {
If(LEqual(_T_=
0, 0x0b)) {
Store(\_S=
B.PCI0.LPC0.EC0.BSN0, Index(BEDS, 0x0a, ))
}
Else {
If(LEqual=
(_T_0, 0x0c)) {
If(LE=
qual(\_SB.PCI0.LPC0.EC0.ACIS, 0x01)) {
S=
tore(0x00, \_SB.PCI0.LPC0.EC0.PSRC)
S=
tore(0x01, Index(BEDS, 0x0b, ))
}
Else =
{
S=
tore(0x00020000, Index(BEDS, 0x0b, ))
}
}
Else {
If(LE=
qual(_T_0, 0x0d)) {
S=
tore(Local1, \_SB.PCI0.LPC0.EC0.BTMA)
S=
tore(0x01, \_SB.PCI0.LPC0.EC0.SCCF)
S=
tore(0x01, Index(BEDS, 0x0c, ))
}
Else =
{
I=
f(LEqual(_T_0, 0x0e)) {
=
Store(Local1, \_SB.PCI0.LPC0.EC0.BTPV)
=
Store(0x00, \_SB.PCI0.LPC0.EC0.SCHG)
=
Store(0x01, \_SB.PCI0.LPC0.EC0.SCPF)
=
Store(0x01, Index(BEDS, 0x0d, ))
}=
E=
lse {
=
If(LEqual(_T_0, 0x0f)) {
=
Store(\_SB.PCI0.LPC0.EC0.BDFC, Index(BEDS, 0x0e, ))
=
}
=
Else {
=
If(LEqual(_T_0, 0x10)) {
=
Store(\_SB.PCI0.LPC0.EC0.BDME, Index(BEDS, 0x0f, ))
=
}
=
Else {
=
If(LEqual(_T_0, 0x11)) {
=
Store(0x03e8, Index(BEDS, 0x10, ))
=
}
=
Else {
=
If(LEqual(_T_0, 0x12)) {
=
Store(0x0100, Index(BEDS, 0x11, ))
=
}
=
Else {
=
If(LEqual(_T_0, 0x13)) {
=
Store(BF00, Local1)
=
Store(BF04, BF00)
=
Store(Local1, BF04)
=
While(One) {
=
Name(_T_1, 0x00)
=
Store(BF04, _T_1)
=
If(LEqual(_T_1, 0x03)) {
=
Store(\_SB.PCI0.LPC0.EC0.BATM, Index(BEDS,=
0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x08)) {
=
Store(\_SB.PCI0.LPC0.EC0.BTTC, Index(B=
EDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x09)) {
=
Store(\_SB.PCI0.LPC0.EC0.BPV0, Ind=
ex(BEDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x0a)) {
=
Store(\_SB.PCI0.LPC0.EC0.BSCU,=
Index(BEDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x17)) {
=
Store(\_SB.PCI0.LPC0.EC0.B=
SCY, Index(BEDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x18)) {
=
Store(\_SB.PCI0.LPC0.E=
C0.BDC0, Index(BEDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x19))=
{
=
Store(\_SB.PCI0.LP=
C0.EC0.BDV0, Index(BEDS, 0x12, ))
=
}
=
Else {
=
If(LEqual(_T_1, 0x=
1b)) {
=
Store(\_SB.PCI=
0.LPC0.EC0.BDAD, Index(BEDS, 0x12, ))
=
}
=
Else {
=
}
=
}
=
}
=
}
=
}
=
}
=
}
=
}
=
Break
=
}
=
}
=
Else {
=
}
=
}
=
}
=
}
=
}
}=
}
}
}
}
}
}
}
}
}
}
}
}
}
Break
}
}
}
Method(Z00O) {
Store(0x01, GSTS)
Return(GSTS)
}
Method(Z00P, 1) {
}
Method(Z00Q, 1) {
}
Method(Z00R, 1) {
}
Method(Z00S, 1) {
}
Method(Z00T, 1) {
Store(Arg0, Local0)
If(LEqual(Local0, 0x01)) {
Store(0x01, BGEF)
}
Else {
Store(0x00, BGEF)
}
Store(0x00, Index(BGDS, 0x00, ))
}
Name(_WDG, Buffer(0xdc) {0x9, 0x4e, 0x76, 0x95, 0x56, 0xfb, 0x83,=
0x4e, 0xb3, 0x1a, 0x37, 0x76, 0x1f, 0x60, 0x99, 0x4a, 0x41, 0x41, 0x1, 0=
x1, 0x58, 0xf2, 0xf4, 0x6a, 0x1, 0xb4, 0xfd, 0x42, 0xbe, 0x91, 0x3d, 0x4a=
, 0xc2, 0xd7, 0xc0, 0xd3, 0x42, 0x41, 0x1, 0x2, 0xac, 0x61, 0x1a, 0xcc, 0=
x56, 0x42, 0xa3, 0x41, 0xb9, 0xe0, 0x5, 0xa4, 0x45, 0xad, 0xe2, 0xf5, 0x8=
0, 0x0, 0x1, 0x8, 0x53, 0x44, 0x8c, 0xe7, 0x27, 0x2, 0x61, 0x48, 0x9e, 0x=
de, 0xf5, 0x60, 0xb, 0x4a, 0x3d, 0x39, 0x42, 0x42, 0x1, 0x2, 0x7b, 0x4f, =
0xe0, 0xaa, 0xc5, 0xb3, 0x65, 0x48, 0x95, 0xd6, 0x9f, 0xac, 0x7f, 0xf3, 0=
xe9, 0x2b, 0x42, 0x43, 0x1, 0x2, 0x79, 0x4c, 0xf9, 0xcf, 0x77, 0x6c, 0xf7=
, 0x4a, 0xac, 0x56, 0x7d, 0xd0, 0xce, 0x1, 0xc9, 0x97, 0x42, 0x44, 0x1, 0=
x2, 0xc5, 0x2e, 0x77, 0x79, 0xb1, 0x4, 0xfd, 0x4b, 0x84, 0x3c, 0x61, 0xe7=
, 0xf7, 0x7b, 0x6c, 0xc9, 0x42, 0x45, 0x1, 0x2, 0xb7, 0xa0, 0xc9, 0xa7, 0=
x9d, 0x4c, 0x72, 0x4c, 0x83, 0xbb, 0x53, 0xa3, 0x45, 0x91, 0x71, 0xdf, 0x=
42, 0x46, 0x1, 0x2, 0x4f, 0x6, 0x3a, 0x65, 0x3a, 0xa2, 0x5f, 0x48, 0xb3, =
0xd9, 0x13, 0xf6, 0x53, 0x2a, 0x1, 0x82, 0x42, 0x47, 0x1, 0x2, 0xa7, 0xb1=
, 0x85, 0xdb, 0x9a, 0x6, 0xbb, 0x4a, 0xa2, 0xb5, 0xd1, 0x86, 0xa2, 0x1b, =
0x80, 0xf1, 0x81, 0x0, 0x1, 0x8, 0x91, 0x6b, 0x91, 0x36, 0x64, 0x1a, 0x83=
, 0x45, 0x84, 0xd0, 0x53, 0x83, 0xf, 0xb9, 0x10, 0x8d, 0x82, 0x0, 0x1, 0x=
8 })
Method(WQAA, 1) {
AAF1()
Store(AADS, BUFF)
Return(BUFF)
}
Method(WMBA, 3) {
While(One) {
Name(_T_0, 0x00)
Store(Arg1, _T_0)
If(LNot(LEqual(Match(Package(0x08) {
0x01,
0x02,
0x03,
0x08,
0x09,
0x0a,
0x0c,
0x0d,
}, MEQ, _T_0, MTR, 0x00, 0x00), Ones))) {
Store(0x00, Local0)
}
Else {
If(LNot(LEqual(Match(Package(0x05) {
0x04,
0x05,
0x06,
0x07,
0x0b,
}, MEQ, _T_0, MTR, 0x00, 0x00), Ones))) {
If(LEqual(Arg1, 0x07)) {
Store(Arg2, BUFF)
If(BF00) {
Store(0x01, BAEF)
}
}
Store(0x01, Local0)
}
}
Break
}
If(Local0) {
Z00A(Arg1, Arg2)
}
Else {
Z009(Arg1)
}
Store(DerefOf(Index(BADG, Subtract(Arg1, 0x01, ), )), BUFF)
Return(BUFF)
}
Method(_WED, 1) {
If(LNot(LLess(Arg0, 0x80))) {
If(LLess(Arg0, 0x83)) {
Return(Z00B())
}
}
}
Method(WMBB, 3) {
Z00C(Arg1, Arg2)
If(LEqual(Arg1, 0x01)) {
Store(BBSB, BUFF)
}
If(LEqual(Arg1, 0x02)) {
Store(BBD1, BUFF)
}
Return(BUFF)
}
Method(WMBC, 3) {
Z00D(Arg1, Arg2)
If(LLess(Arg1, 0x0a)) {
Subtract(Arg1, 0x01, Local0)
Store(DerefOf(Index(BCDS, Subtract(Arg1, 0x01, ), )), BUF=
F)
}
Else {
ShiftRight(DerefOf(Index(BCDS, Subtract(Arg1, 0x0a, ), ))=
, 0x10, BUFF)
}
Return(BUFF)
}
Method(WMBD, 3) {
If(LEqual(Arg1, 0x01)) {
Store(Arg2, BUFF)
Store(BUFF, Local0)
Store(Arg2, WIT0)
Z00E(WIT0)
Return(DSY0)
}
If(LEqual(Arg1, 0x02)) {
Store(Arg2, Local0)
Z00F(Arg2)
Return(DSY1)
}
If(LEqual(Arg1, 0x03)) {
Store(Arg2, Local0)
Z00G(Arg2)
Return(DSY1)
}
If(LEqual(Arg1, 0x04)) {
Z00H(Arg1, Arg2)
ShiftRight(DerefOf(Index(BCDS, Add(Arg1, 0x05, ), )), 0x1=
0, BUFF)
Return(BUFF)
}
If(LEqual(Arg1, 0x05)) {
Z00H(Arg1, Arg2)
Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
Return(BUFF)
}
If(LEqual(Arg1, 0x06)) {
Z00I()
Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
Return(BUFF)
}
If(LEqual(Arg1, 0x07)) {
Z00J()
Store(DerefOf(Index(BCDS, Add(Arg1, 0x04, ), )), BUFF)
Return(BUFF)
}
If(LEqual(Arg1, 0x08)) {
Store(Arg2, WPRW)
Store(WWD1, WPIR)
Store(WWD2, WPIF)
Store(WWD3, WPID)
Store(WWD4, WPIB)
Concatenate(WPCI, WWD0, Local0)
Z00K(Local0)
Return(DSY2)
}
If(LEqual(Arg1, 0x09)) {
Store(Arg2, DSY6)
Store(DY60, Local0)
Store(Arg2, DSY0)
Store(DY01, WPRW)
Store(WWD1, WPIR)
Store(WWD2, WPIF)
Store(WWD3, WPID)
Store(WWD4, WPIB)
Store(WPCI, Local1)
Concatenate(DY60, WPCI, Local0)
Concatenate(Local0, WWD0, Local1)
Z00L(Local1)
Return(BUFF)
}
If(LEqual(Arg1, 0x0a)) {
Z00M()
Store(DerefOf(Index(BCDS, Add(Arg1, 0x02, ), )), BUFF)
Return(BUFF)
}
If(LEqual(Arg1, 0x0b)) {
PCID(Arg2)
Return(DSY6)
}
}
Method(WMBE, 3) {
Z00N(Arg1, Arg2)
Store(BUFF, Debug)
Store(BEDS, Debug)
Store(DerefOf(Index(BEDS, Subtract(Arg1, 0x01, ), )), BUFF)
Store(BUFF, Debug)
Return(BUFF)
}
Method(WMBF, 3) {
If(LGreater(Arg1, 0x04)) {
Store(0x02, BF00)
Store(0x00, BF01)
Store(0x00, BF02)
Store(0x00, BF03)
Return(BUFF)
}
If(Z00O()) {
Store(Arg2, BUFF)
If(LEqual(Arg1, 0x01)) {
Z00P(BF00)
}
Else {
If(LEqual(Arg1, 0x02)) {
Z00Q(BF00)
}
Else {
If(LEqual(Arg1, 0x03)) {
Z00R(BF00)
}
Else {
Z00S(BF00)
}
}
}
Store(DerefOf(Index(BFDS, Subtract(Arg1, 0x01, ), )), BUF=
F)
Store(BUFF, Debug)
}
Else {
Store(0x03, BF00)
Store(0x00, BF01)
Store(0x00, BF02)
Store(0x00, BF03)
}
Return(BUFF)
}
Method(WMBG, 3) {
Store(Arg2, BUFF)
Z00T(BF00)
Store(DerefOf(Index(BGDS, Subtract(Arg1, 0x01, ), )), BUFF)
Store(BUFF, Debug)
Return(BUFF)
}
}
OperationRegion(SMI2, SystemMemory, 0xafeddcdc, 0x00000120)
Field(SMI2, AnyAcc, NoLock, Preserve) {
WCMD, 8,
WDID, 32,
TPID, 8,
DI00, 320
}
Field(SMI2, AnyAcc, NoLock, Preserve) {
Offset(0x6),
D000, 32,
D001, 32,
D002, 32,
D003, 32,
D004, 32
}
Method(PHWM, 2) {
Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
Store(0xe0, WCMD)
Store(0x57, TPID)
Store(Arg0, WDID)
Store(Arg1, DI00)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Store(DI00, Local0)
Release(\_SB.PCI0.LPC0.PSMX)
Return(Local0)
}
Device(PCI0) {
Name(_HID, 0x080ad041)
Name(_CID, 0x030ad041)
Name(_ADR, 0x00)
Name(_UID, 0x01)
Name(_BBN, 0x00)
Name(SUPP, 0x00)
Name(CTRL, 0x00)
Method(XOSC, 4) {
CreateDWordField(Arg3, 0x00, CDW1)
CreateDWordField(Arg3, 0x04, CDW2)
CreateDWordField(Arg3, 0x08, CDW3)
If(LEqual(Arg0, Buffer(0x10) {0x5b, 0x4d, 0xdb, 0x33, 0xf7, 0=
x1f, 0x1c, 0x40, 0x96, 0x57, 0x74, 0x41, 0xc0, 0x3d, 0xd7, 0x66 })) {
Store(CDW2, SUPP)
Store(CDW3, CTRL)
If(LNot(LEqual(And(SUPP, 0x16, ), 0x16))) {
And(CTRL, 0x1e, CTRL)
}
And(CTRL, 0x1d, CTRL)
If(Not(And(CDW1, 0x01, ), )) {
If(And(CTRL, 0x01, )) {
}
If(And(CTRL, 0x04, )) {
Store(One, \_SB.PCI0.SMB.EPNM)
Store(One, \_SB.PCI0.SMB.DPPF)
Store(One, \_SB.PCI0.SMB.FNGS)
}
Else {
Store(0x00, \_SB.PCI0.SMB.EPNM)
Store(0x00, \_SB.PCI0.SMB.DPPF)
Store(0x00, \_SB.PCI0.SMB.FNGS)
}
}
If(LNot(LEqual(Arg1, One))) {
Or(CDW1, 0x08, CDW1)
}
If(LNot(LEqual(CDW3, CTRL))) {
Or(CDW1, 0x10, CDW1)
}
Store(CTRL, CDW3)
Return(Arg3)
}
Else {
Or(CDW1, 0x04, CDW1)
Return(Arg3)
}
}
Method(_INI) {
Store(0xf1, P80H)
\_SB.OSTP()
\_SB.PCI0.LPC0.PHSS(0x76)
If(LLess(PJID, 0x02)) {
\_SB.PCI0.AMD3.HTCS()
}
\_GPE._L1A()
If(LOr(LEqual(PJID, 0x00), LEqual(PJID, 0x02))) {
\_SB.PCI0.LPC0.PHSS(0x5a)
Notify(\_SB.PCI0.PB9, 0x00)
}
If(LAnd(LNot(LLess(TPOS, 0x04)), LLess(TPOS, 0x40))) {
Store(And(\_SB.PCI0.SMB.GM4C, 0x01, ), Local0)
Store(Local0, \_SB.PCI0.LPC0.INFO)
Store(0x8f, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
}
}
OperationRegion(NBRV, PCI_Config, 0x08, 0x01)
Field(NBRV, ByteAcc, NoLock, Preserve) {
PREV, 8
}
OperationRegion(NBBR, PCI_Config, 0x1c, 0x08)
Field(NBBR, DWordAcc, NoLock, Preserve) {
BR3L, 32,
BR3H, 32
}
OperationRegion(NBBI, PCI_Config, 0x84, 0x04)
Field(NBBI, DWordAcc, NoLock, Preserve) {
PARB, 32
}
OperationRegion(NBMS, PCI_Config, 0x60, 0x08)
Field(NBMS, DWordAcc, NoLock, Preserve) {
MIDX, 32,
MIDR, 32
}
Mutex(NBMM, 0)
Method(NBMR, 1) {
Acquire(NBMM, 0xffff)
And(Arg0, 0x7f, Local0)
Store(Local0, MIDX)
Store(MIDR, Local0)
Store(0x7f, MIDX)
Release(NBMM)
Return(Local0)
}
Method(NBMW, 2) {
Acquire(NBMM, 0xffff)
And(Arg0, 0x7f, Local0)
Or(Local0, 0x80, Local0)
Store(Local0, MIDX)
Store(Arg1, MIDR)
Store(And(Local0, 0x7f, Local0), MIDX)
Release(NBMM)
}
OperationRegion(NBXP, PCI_Config, 0xe0, 0x08)
Field(NBXP, DWordAcc, NoLock, Preserve) {
NBXI, 32,
NBXD, 32
}
Mutex(NBXM, 0)
Method(NBXR, 1) {
Acquire(NBXM, 0xffff)
Store(Arg0, NBXI)
Store(NBXD, Local0)
Store(0x00, NBXI)
Release(NBXM)
Return(Local0)
}
Method(NBXW, 2) {
Acquire(NBXM, 0xffff)
Store(Arg0, NBXI)
Store(Arg1, NBXD)
Store(0x00, NBXI)
Release(NBXM)
}
Method(GFXM) {
Store(NBMR(0x08), Local0)
And(Local0, 0x0f, Local0)
Return(Local0)
}
Method(GPPM) {
Store(NBMR(0x31), Local0)
And(Local0, 0x0f, Local0)
Return(Local0)
}
Method(XPTR, 2) {
If(LAnd(LLess(Arg0, 0x02), LGreater(Arg0, 0x07))) {
Return(0x00)
}
Else {
Store(0x01, Local0)
If(LLess(Arg0, 0x04)) {
Add(Arg0, 0x02, Local1)
}
Else {
Add(Arg0, 0x11, Local1)
}
ShiftLeft(Local0, Local1, Local0)
Store(NBMR(0x08), Local2)
If(Arg1) {
And(Local2, Not(Local0, ), Local2)
}
Else {
Or(Local2, Local0, Local2)
}
NBMW(0x08, Local2)
Return(Ones)
}
}
Name(PX3L, 0x80000000)
Name(PX3H, 0x80000000)
Name(PX3S, 0x10000000)
Name(PX3K, 0xf0000000)
Mutex(BR3X, 0)
Method(BR3M) {
Store(PARB, Local0)
ShiftRight(Local0, 0x10, Local0)
And(Local0, 0x07, Local0)
If(Local0) {
ShiftLeft(0x01, Local0, Local1)
Subtract(0x1000, Local1, Local1)
ShiftLeft(Local1, 0x14, Local1)
Store(Local1, PX3K)
ShiftRight(0x00100000, Local0, Local0)
Store(Local0, PX3S)
}
Acquire(BR3X, 0xffff)
Store(NBMR(0x00), Local0)
And(Local0, 0xfffffff7, Local0)
NBMW(0x00, Local0)
Store(BR3L, Local0)
And(Local0, PX3K, Local0)
Store(Local0, PX3L)
Store(BR3H, Local0)
And(Local0, 0xff, Local0)
Store(Local0, PX3H)
Store(NBMR(0x00), Local0)
Or(Local0, 0x08, Local0)
NBMW(0x00, Local0)
Release(BR3X)
Return(PX3L)
}
OperationRegion(K8ST, SystemMemory, 0xafeddf74, 0x00000048)
Field(K8ST, AnyAcc, NoLock, Preserve) {
C0_0, 16,
C2_0, 16,
C4_0, 16,
C6_0, 16,
C8_0, 16,
CA_0, 16,
CC_0, 16,
CE_0, 16,
D0_0, 16,
D2_0, 16,
D4_0, 16,
D6_0, 16,
D8_0, 16,
DA_0, 16,
DC_0, 16,
DE_0, 16,
E0_0, 16,
E2_0, 16,
E4_0, 16,
E6_0, 16,
E8_0, 16,
EA_0, 16,
EC_0, 16,
EE_0, 16,
F0_0, 16,
F2_0, 16,
F4_0, 16,
F6_0, 16,
F8_0, 16,
FA_0, 16,
FC_0, 16,
FE_0, 16,
TOML, 32,
TOMH, 32
}
Name(RSRC, Buffer(0x0316) {0x88, 0xe, 0x0, 0x2, 0xe, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x87, 0x18, 0x0, 0x0, 0x=
e, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0xff, 0xff, 0xb, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1,=
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0xff, 0x1f, 0xc, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x20, 0xc, 0x0, 0xff, 0x3f, 0xc, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x40, 0xc, 0x0, 0xff, 0x5f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x60, 0xc, 0x0, 0xff, 0x7f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, =
0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, =
0x0, 0x80, 0xc, 0x0, 0xff, 0x9f, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20,=
0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, =
0xa0, 0xc, 0x0, 0xff, 0xbf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0,=
0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0,=
0xc, 0x0, 0xff, 0xdf, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0,=
0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0, 0xc,=
0x0, 0xff, 0xff, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,=
0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, =
0xff, 0x1f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87,=
0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0xd, 0x0, 0xff,=
0x3f, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18=
, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0xd, 0x0, 0xff, 0x5f=
, 0xd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0=
, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x60, 0xd, 0x0, 0xff, 0x7f, 0xd=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0=
, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0xd, 0x0, 0xff, 0x9f, 0xd, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe=
, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xd, 0x0, 0xff, 0xbf, 0xd, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1=
, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xd, 0x0, 0xff, 0xdf, 0xd, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0xe0, 0xd, 0x0, 0xff, 0xff, 0xd, 0x0, 0x0, 0x0, 0x0=
, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0=
, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0, 0xff, 0x1f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0,=
0x0, 0x0, 0x20, 0xe, 0x0, 0xff, 0x3f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x20, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0,=
0x0, 0x40, 0xe, 0x0, 0xff, 0x5f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20=
, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x60, 0xe, 0x0, 0xff, 0x7f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0=
, 0x0, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80=
, 0xe, 0x0, 0xff, 0x9f, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0=
, 0x0, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xe=
, 0x0, 0xff, 0xbf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0=
, 0x87, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xe, 0x0=
, 0xff, 0xdf, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x8=
7, 0x18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0, 0xe, 0x0, 0xf=
f, 0xff, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x87, 0x=
18, 0x0, 0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x87, 0x18, 0x0, =
0x0, 0xe, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, =
0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x47, 0x1, 0xf8, 0xc, =
0xf8, 0xc, 0x1, 0x8, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x0, 0=
xf7, 0xc, 0x0, 0x0, 0xf8, 0xc, 0x0, 0x88, 0xe, 0x0, 0x1, 0xc, 0x3, 0x0, 0=
x0, 0x0, 0xd, 0xff, 0xff, 0x0, 0x0, 0x0, 0xf3, 0x0, 0x79, 0x0 })
Method(_CRS, 0, Serialized) {
CreateBitField(RSRC, 0x0188, C0RW)
CreateDWordField(RSRC, 0x42, C0LN)
Store(One, C0RW)
Store(0x2000, C0LN)
If(And(C0_0, 0x1818, )) {
Store(0x00, C0LN)
}
CreateBitField(RSRC, 0x0260, C2RW)
CreateDWordField(RSRC, 0x5d, C2LN)
Store(One, C2RW)
Store(0x2000, C2LN)
If(And(C2_0, 0x1818, )) {
Store(0x00, C2LN)
}
CreateBitField(RSRC, 0x0338, C4RW)
CreateDWordField(RSRC, 0x78, C4LN)
Store(One, C4RW)
Store(0x2000, C4LN)
If(And(C4_0, 0x1818, )) {
Store(0x00, C4LN)
}
CreateBitField(RSRC, 0x0410, C6RW)
CreateDWordField(RSRC, 0x93, C6LN)
Store(One, C6RW)
Store(0x2000, C6LN)
If(And(C6_0, 0x1818, )) {
Store(0x00, C6LN)
}
CreateBitField(RSRC, 0x04e8, C8RW)
CreateDWordField(RSRC, 0xae, C8LN)
Store(One, C8RW)
Store(0x2000, C8LN)
If(And(C8_0, 0x1818, )) {
Store(0x00, C8LN)
}
CreateBitField(RSRC, 0x05c0, CARW)
CreateDWordField(RSRC, 0xc9, CALN)
Store(One, CARW)
Store(0x2000, CALN)
If(And(CA_0, 0x1818, )) {
Store(0x00, CALN)
}
CreateBitField(RSRC, 0x0698, CCRW)
CreateDWordField(RSRC, 0xe4, CCLN)
Store(One, CCRW)
Store(0x2000, CCLN)
If(And(CC_0, 0x1818, )) {
Store(0x00, CCLN)
}
CreateBitField(RSRC, 0x0770, CERW)
CreateDWordField(RSRC, 0xff, CELN)
Store(One, CERW)
Store(0x2000, CELN)
If(And(CE_0, 0x1818, )) {
Store(0x00, CELN)
}
CreateBitField(RSRC, 0x0848, D0RW)
CreateDWordField(RSRC, 0x011a, D0LN)
Store(One, D0RW)
Store(0x2000, D0LN)
If(And(D0_0, 0x1818, )) {
Store(0x00, D0LN)
}
CreateBitField(RSRC, 0x0920, D2RW)
CreateDWordField(RSRC, 0x0135, D2LN)
Store(One, D2RW)
Store(0x2000, D2LN)
If(And(D2_0, 0x1818, )) {
Store(0x00, D2LN)
}
CreateBitField(RSRC, 0x09f8, D4RW)
CreateDWordField(RSRC, 0x0150, D4LN)
Store(One, D4RW)
Store(0x2000, D4LN)
If(And(D4_0, 0x1818, )) {
Store(0x00, D4LN)
}
CreateBitField(RSRC, 0x0ad0, D6RW)
CreateDWordField(RSRC, 0x016b, D6LN)
Store(One, D6RW)
Store(0x2000, D6LN)
If(And(D6_0, 0x1818, )) {
Store(0x00, D6LN)
}
CreateBitField(RSRC, 0x0ba8, D8RW)
CreateDWordField(RSRC, 0x0186, D8LN)
Store(One, D8RW)
Store(0x2000, D8LN)
If(And(D8_0, 0x1818, )) {
Store(0x00, D8LN)
}
CreateBitField(RSRC, 0x0c80, DARW)
CreateDWordField(RSRC, 0x01a1, DALN)
Store(One, DARW)
Store(0x2000, DALN)
If(And(DA_0, 0x1818, )) {
Store(0x00, DALN)
}
CreateBitField(RSRC, 0x0d58, DCRW)
CreateDWordField(RSRC, 0x01bc, DCLN)
Store(One, DCRW)
Store(0x2000, DCLN)
If(And(DC_0, 0x1818, )) {
Store(0x00, DCLN)
}
CreateBitField(RSRC, 0x0e30, DERW)
CreateDWordField(RSRC, 0x01d7, DELN)
Store(One, DERW)
Store(0x2000, DELN)
If(And(DE_0, 0x1818, )) {
Store(0x00, DELN)
}
CreateBitField(RSRC, 0x0f08, E0RW)
CreateDWordField(RSRC, 0x01f2, E0LN)
Store(One, E0RW)
Store(0x2000, E0LN)
If(And(E0_0, 0x1818, )) {
Store(0x00, E0LN)
}
CreateBitField(RSRC, 0x0fe0, E2RW)
CreateDWordField(RSRC, 0x020d, E2LN)
Store(One, E2RW)
Store(0x2000, E2LN)
If(And(E2_0, 0x1818, )) {
Store(0x00, E2LN)
}
CreateBitField(RSRC, 0x10b8, E4RW)
CreateDWordField(RSRC, 0x0228, E4LN)
Store(One, E4RW)
Store(0x2000, E4LN)
If(And(E4_0, 0x1818, )) {
Store(0x00, E4LN)
}
CreateBitField(RSRC, 0x1190, E6RW)
CreateDWordField(RSRC, 0x0243, E6LN)
Store(One, E6RW)
Store(0x2000, E6LN)
If(And(E6_0, 0x1818, )) {
Store(0x00, E6LN)
}
CreateBitField(RSRC, 0x1268, E8RW)
CreateDWordField(RSRC, 0x025e, E8LN)
Store(One, E8RW)
Store(0x2000, E8LN)
If(And(E8_0, 0x1818, )) {
Store(0x00, E8LN)
}
CreateBitField(RSRC, 0x1340, EARW)
CreateDWordField(RSRC, 0x0279, EALN)
Store(One, EARW)
Store(0x2000, EALN)
If(And(EA_0, 0x1818, )) {
Store(0x00, EALN)
}
CreateBitField(RSRC, 0x1418, ECRW)
CreateDWordField(RSRC, 0x0294, ECLN)
Store(One, ECRW)
Store(0x2000, ECLN)
If(And(EC_0, 0x1818, )) {
Store(0x00, ECLN)
}
CreateBitField(RSRC, 0x14f0, EERW)
CreateDWordField(RSRC, 0x02af, EELN)
Store(One, EERW)
Store(0x2000, EELN)
If(And(EE_0, 0x1818, )) {
Store(0x00, EELN)
}
CreateDWordField(RSRC, 0x02be, BT1S)
CreateDWordField(RSRC, 0x02c2, BT1M)
CreateDWordField(RSRC, 0x02ca, BT1L)
CreateDWordField(RSRC, 0x02d9, BT2S)
CreateDWordField(RSRC, 0x02dd, BT2M)
CreateDWordField(RSRC, 0x02e5, BT2L)
Store(BR3M(), Local0)
Store(PX3H, Local2)
Store(PX3S, Local1)
If(Local2) {
Store(0x00, Local1)
Store(TOML, Local0)
}
Store(TOML, BT1S)
Store(Subtract(Local0, 0x01, ), BT1M)
Subtract(Local0, TOML, BT1L)
Store(Add(Local0, Local1, ), BT2S)
Store(Add(Subtract(BT2M, BT2S, ), 0x01, ), BT2L)
Return(RSRC)
}
Device(MEMR) {
Name(_HID, 0x020cd041)
Name(MEM1, Buffer(0x26) {0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, =
0x0, 0x0, 0x0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x79, 0x0 })
Method(_CRS) {
CreateDWordField(MEM1, 0x04, MB01)
CreateDWordField(MEM1, 0x08, ML01)
CreateDWordField(MEM1, 0x10, MB02)
CreateDWordField(MEM1, 0x14, ML02)
CreateDWordField(MEM1, 0x1c, MB03)
CreateDWordField(MEM1, 0x20, ML03)
If(GPIC) {
Store(0xfec00000, MB01)
Store(0xfec10000, MB02)
Store(0xfee00000, MB03)
Store(0x1000, ML01)
Store(0x1000, ML02)
Store(0x1000, ML03)
}
Return(MEM1)
}
}
Method(_PRT) {
If(GPIC) {
Return(Package(0x16) {
Package(0x04) {
0x0001ffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0001ffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0x0002ffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0003ffff,
0x00,
0x00,
0x13,
},
Package(0x04) {
0x0004ffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x0005ffff,
0x00,
0x00,
0x11,
},
Package(0x04) {
0x0006ffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0007ffff,
0x00,
0x00,
0x13,
},
Package(0x04) {
0x0009ffff,
0x00,
0x00,
0x11,
},
Package(0x04) {
0x000affff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0011ffff,
0x00,
0x00,
0x16,
},
Package(0x04) {
0x0012ffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x0012ffff,
0x01,
0x00,
0x11,
},
Package(0x04) {
0x0012ffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0x0013ffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0013ffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0x0013ffff,
0x02,
0x00,
0x10,
},
Package(0x04) {
0x0014ffff,
0x05,
0x00,
0x11,
},
Package(0x04) {
0x0014ffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0x0014ffff,
0x01,
0x00,
0x11,
},
Package(0x04) {
0x0014ffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0x0014ffff,
0x03,
0x00,
0x13,
},
})
}
Else {
Return(Package(0x15) {
Package(0x04) {
0x0001ffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0001ffff,
0x01,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0x0002ffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0003ffff,
0x00,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0x0004ffff,
0x00,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0x0005ffff,
0x00,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0x0006ffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0007ffff,
0x00,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0x0009ffff,
0x00,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0x000affff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0011ffff,
0x00,
\_SB.PCI0.LPC0.LNKG,
0x00,
},
Package(0x04) {
0x0012ffff,
0x00,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0x0012ffff,
0x01,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0x0012ffff,
0x02,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0013ffff,
0x00,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0x0013ffff,
0x01,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0x0013ffff,
0x02,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0014ffff,
0x00,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0x0014ffff,
0x01,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0x0014ffff,
0x02,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0014ffff,
0x03,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
})
}
}
OperationRegion(BAR1, PCI_Config, 0x14, 0x04)
Field(BAR1, ByteAcc, NoLock, Preserve) {
Z00U, 32
}
Name(HTLV, 0x56)
Device(AMD3) {
Name(_ADR, 0x00180003)
OperationRegion(HTCR, PCI_Config, 0x64, 0x04)
Field(HTCR, ByteAcc, NoLock, Preserve) {
HTCE, 1,
Offset(0x2),
HTL, 7,
Offset(0x3),
HHL, 4
}
Method(HTCS) {
Store(HTLV, Local0)
Add(Local0, HHL, HTL)
Store(One, HTCE)
}
}
Device(PB2) {
Name(_ADR, 0x00020000)
OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
Field(XPCB, ByteAcc, NoLock, Preserve) {
Offset(0x10),
LKCN, 16,
LKST, 16,
Offset(0x1a),
SLST, 16
}
OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
Field(XPRI, ByteAcc, NoLock, Preserve) {
XPIR, 32,
XPID, 32
}
OperationRegion(XPEX, SystemMemory, 0xe0010100, 0x0100)
Field(XPEX, DWordAcc, NoLock, Preserve) {
Offset(0x28),
VC02, 32
}
Method(XPDL) {
If(And(VC02, 0x00020000, )) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Method(XPRD, 1) {
Store(Arg0, XPIR)
Store(XPID, Local0)
Store(0x00, XPIR)
Return(Local0)
}
Method(XPWR, 2) {
Store(Arg0, XPIR)
Store(Arg1, XPID)
Store(0x00, XPIR)
}
Method(XPRT) {
Store(XPRD(0xa2), Local0)
And(Local0, Not(0x07, ), Local0)
ShiftRight(Local0, 0x04, Local1)
And(Local1, 0x07, Local1)
Or(Local0, Local1, Local0)
Or(Local0, 0x0100, Local0)
XPWR(0xa2, Local0)
}
Method(XPLP, 1) {
Store(0x0101, Local1)
Store(\_SB.PCI0.NBXR(0x65), Local2)
If(Arg0) {
And(Local2, Not(Local1, ), Local2)
}
Else {
Or(Local2, Local1, Local2)
}
\_SB.PCI0.NBXW(0x65, Local2)
}
Method(XPR2) {
Store(LKCN, Local0)
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
Or(Local0, 0x20, Local0)
Store(Local0, LKCN)
Store(0x64, Local1)
Store(0x01, Local2)
While(LAnd(Local1, Local2)) {
Sleep(0x01)
Store(LKST, Local3)
If(And(Local3, 0x0800, )) {
Decrement(Local1)
}
Else {
Store(0x00, Local2)
}
}
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
If(LNot(Local2)) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Device(DGFX) {
Name(_ADR, 0x00)
OperationRegion(PCFG, PCI_Config, 0x00, 0x50)
Field(PCFG, DWordAcc, NoLock, Preserve) {
DVID, 32,
Offset(0x2c),
SVID, 32,
Offset(0x4c),
SMID, 32
}
Name(SWIT, 0x01)
Name(CRTA, 0x01)
Name(LCDA, 0x01)
Name(TVAA, 0x01)
Name(DVIA, 0x01)
Name(VLDF, 0x01)
Method(_STA) {
Return(0x0f)
}
Name(_PSC, 0x00)
Method(_PS0) {
Store(0x00, _PSC)
}
Method(_PS1) {
Store(0x01, _PSC)
}
Method(_PS3) {
Store(0x03, _PSC)
}
Method(_DOS, 1) {
Store(And(Arg0, 0x03, ), SWIT)
}
Method(_DOD) {
Return(Package(0x04) {
0x00010100,
0x00010110,
0x0200,
0x0210,
})
}
Device(CRT) {
Method(_ADR) {
Return(0x0100)
}
}
Device(LCD) {
Method(_ADR) {
Return(0x0110)
}
Method(_BCL) {
Store(0xc0, P80H)
Return(Package(0x0c) {
0x64,
0x46,
0x0a,
0x14,
0x1e,
0x28,
0x32,
0x3c,
0x46,
0x50,
0x5a,
0x64,
})
}
Method(_BCM, 1) {
Store(0xc1, P80H)
Divide(Arg0, 0x0a, Local0, Local1)
Decrement(Local1)
Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS)
}
Method(_BQC) {
Store(0xc2, P80H)
Multiply(\_SB.PCI0.LPC0.EC0.BRTS, 0x0a, Local0)
Add(Local0, 0x01, Local0)
Sleep(0x64)
Return(Local0)
}
}
Device(TV) {
Method(_ADR) {
Return(0x0200)
}
}
Device(DVI) {
Method(_ADR) {
Return(0x0210)
}
}
}
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x11,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
})
}
}
}
Device(PB3) {
Name(_ADR, 0x00030000)
OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
Field(XPCB, ByteAcc, NoLock, Preserve) {
Offset(0x10),
LKCN, 16,
LKST, 16,
Offset(0x1a),
SLST, 16
}
OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
Field(XPRI, ByteAcc, NoLock, Preserve) {
XPIR, 32,
XPID, 32
}
OperationRegion(XPEX, SystemMemory, 0xe0018100, 0x0100)
Field(XPEX, DWordAcc, NoLock, Preserve) {
Offset(0x28),
VC02, 32
}
Method(XPDL) {
If(And(VC02, 0x00020000, )) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Method(XPRD, 1) {
Store(Arg0, XPIR)
Store(XPID, Local0)
Store(0x00, XPIR)
Return(Local0)
}
Method(XPWR, 2) {
Store(Arg0, XPIR)
Store(Arg1, XPID)
Store(0x00, XPIR)
}
Method(XPRT) {
Store(XPRD(0xa2), Local0)
And(Local0, Not(0x07, ), Local0)
ShiftRight(Local0, 0x04, Local1)
And(Local1, 0x07, Local1)
Or(Local0, Local1, Local0)
Or(Local0, 0x0100, Local0)
XPWR(0xa2, Local0)
}
Method(XPLP, 1) {
Store(0x0101, Local1)
Store(\_SB.PCI0.NBXR(0x65), Local2)
If(Arg0) {
And(Local2, Not(Local1, ), Local2)
}
Else {
Or(Local2, Local1, Local2)
}
\_SB.PCI0.NBXW(0x65, Local2)
}
Method(XPR2) {
Store(LKCN, Local0)
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
Or(Local0, 0x20, Local0)
Store(Local0, LKCN)
Store(0x64, Local1)
Store(0x01, Local2)
While(LAnd(Local1, Local2)) {
Sleep(0x01)
Store(LKST, Local3)
If(And(Local3, 0x0800, )) {
Decrement(Local1)
}
Else {
Store(0x00, Local2)
}
}
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
If(LNot(Local2)) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Device(DGFX) {
Name(_ADR, 0x00)
OperationRegion(PCFG, PCI_Config, 0x00, 0x50)
Field(PCFG, DWordAcc, NoLock, Preserve) {
DVID, 32,
Offset(0x2c),
SVID, 32,
Offset(0x4c),
SMID, 32
}
}
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x11,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x12,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
})
}
}
}
Device(PB4) {
Name(_ADR, 0x00040000)
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x11,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x12,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x13,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
})
}
}
OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
Field(XPCB, ByteAcc, NoLock, Preserve) {
Offset(0x10),
LKCN, 16,
LKST, 16,
Offset(0x1a),
SLST, 16
}
OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
Field(XPRI, ByteAcc, NoLock, Preserve) {
XPIR, 32,
XPID, 32
}
OperationRegion(XPEX, SystemMemory, 0xe0020100, 0x0100)
Field(XPEX, DWordAcc, NoLock, Preserve) {
Offset(0x28),
VC0S, 32
}
Method(XPDL) {
Store(Zero, Local0)
If(And(VC0S, 0x00020000, )) {
Store(Ones, Local0)
}
Return(Local0)
}
Method(XPRD, 1) {
Store(Arg0, XPIR)
Store(XPID, Local0)
Store(0x00, XPIR)
Return(Local0)
}
Method(XPWR, 2) {
Store(Arg0, XPIR)
Store(Arg1, XPID)
Store(0x00, XPIR)
}
Method(XPRT) {
Store(XPRD(0xa2), Local0)
And(Local0, Not(0x07, ), Local0)
ShiftRight(Local0, 0x04, Local1)
And(Local1, 0x07, Local1)
Or(Local0, Local1, Local0)
Or(Local0, 0x0100, Local0)
XPWR(0xa2, Local0)
}
Method(XPLP, 1) {
Store(0x1010, Local1)
Store(\_SB.PCI0.NBXR(0x00010065), Local2)
If(Arg0) {
And(Local2, Not(Local1, ), Local2)
}
Else {
Or(Local2, Local1, Local2)
}
\_SB.PCI0.NBXW(0x00010065, Local2)
}
Method(XPR2) {
Store(LKCN, Local0)
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
Or(Local0, 0x20, Local0)
Store(Local0, LKCN)
Store(0x64, Local1)
Store(0x01, Local2)
While(LAnd(Local1, Local2)) {
Sleep(0x01)
Store(LKST, Local3)
If(And(Local3, 0x0800, )) {
Decrement(Local1)
}
Else {
Store(0x00, Local2)
}
}
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
If(LNot(Local2)) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Device(NCRD) {
Name(_ADR, 0x00)
OperationRegion(PCFG, PCI_Config, 0x00, 0x08)
Field(PCFG, DWordAcc, NoLock, Preserve) {
DVID, 32,
PCMS, 32
}
Method(_RMV) {
Return(0x01)
}
}
}
Device(PB5) {
Name(_ADR, 0x00050000)
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x11,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x12,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x10,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
})
}
}
}
Device(PB6) {
Name(_ADR, 0x00060000)
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x11,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
})
}
}
}
Device(PB7) {
Name(_ADR, 0x00070000)
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x11,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x12,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
})
}
}
}
Device(PB9) {
Name(_ADR, 0x00090000)
OperationRegion(XPCB, PCI_Config, 0x58, 0x24)
Field(XPCB, ByteAcc, NoLock, Preserve) {
Offset(0x10),
LKCN, 16,
LKST, 16,
Offset(0x1a),
SLST, 16
}
OperationRegion(XPRI, PCI_Config, 0xe0, 0x08)
Field(XPRI, ByteAcc, NoLock, Preserve) {
XPIR, 32,
XPID, 32
}
OperationRegion(XPEX, SystemMemory, 0xe0038100, 0x0100)
Field(XPEX, DWordAcc, NoLock, Preserve) {
Offset(0x28),
VC0S, 32
}
Method(XPDL) {
Store(Zero, Local0)
If(And(VC0S, 0x00020000, )) {
Store(Ones, Local0)
}
Return(Local0)
}
Method(XPRD, 1) {
Store(Arg0, XPIR)
Store(XPID, Local0)
Store(0x00, XPIR)
Return(Local0)
}
Method(XPWR, 2) {
Store(Arg0, XPIR)
Store(Arg1, XPID)
Store(0x00, XPIR)
}
Method(XPRT) {
Store(XPRD(0xa2), Local0)
And(Local0, Not(0x07, ), Local0)
ShiftRight(Local0, 0x04, Local1)
And(Local1, 0x07, Local1)
Or(Local0, Local1, Local0)
Or(Local0, 0x0100, Local0)
XPWR(0xa2, Local0)
}
Method(XPLP, 1) {
Store(0x8080, Local1)
Store(\_SB.PCI0.NBXR(0x00010065), Local2)
If(Arg0) {
And(Local2, Not(Local1, ), Local2)
}
Else {
Or(Local2, Local1, Local2)
}
\_SB.PCI0.NBXW(0x00010065, Local2)
}
Method(XPR2) {
Store(LKCN, Local0)
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
Or(Local0, 0x20, Local0)
Store(Local0, LKCN)
Store(0x64, Local1)
Store(0x01, Local2)
While(LAnd(Local1, Local2)) {
Sleep(0x01)
Store(LKST, Local3)
If(And(Local3, 0x0800, )) {
Decrement(Local1)
}
Else {
Store(0x00, Local2)
}
}
And(Local0, Not(0x20, ), Local0)
Store(Local0, LKCN)
If(LNot(Local2)) {
Return(Ones)
}
Else {
Return(Zero)
}
}
Device(J380) {
Name(_ADR, 0x00)
OperationRegion(PCFG, PCI_Config, 0x00, 0xff)
Field(PCFG, ByteAcc, NoLock, Preserve) {
DVID, 32,
Offset(0x2c),
SSID, 32,
Offset(0xac),
, 6,
D3EF, 1,
Offset(0xb2),
LAT0, 8,
Offset(0xcf),
ATRB, 8,
Offset(0xd3),
PMC0, 8
}
Method(_RMV) {
Return(0x01)
}
}
Device(J381) {
Name(_ADR, 0x01)
Method(_RMV) {
Return(0x01)
}
}
Device(J382) {
Name(_ADR, 0x02)
Method(_RMV) {
Return(0x01)
}
}
Device(J383) {
Name(_ADR, 0x03)
Method(_RMV) {
Return(0x01)
}
}
Device(J384) {
Name(_ADR, 0x04)
Method(_RMV) {
Return(0x01)
}
}
}
Device(PB10) {
Name(_ADR, 0x000a0000)
Name(_PRW, Package(0x02) {
0x18,
0x04,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0xffff,
0x01,
0x00,
0x13,
},
Package(0x04) {
0xffff,
0x02,
0x00,
0x10,
},
Package(0x04) {
0xffff,
0x03,
0x00,
0x11,
},
})
}
Else {
Return(Package(0x04) {
Package(0x04) {
0xffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0xffff,
0x01,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
Package(0x04) {
0xffff,
0x02,
\_SB.PCI0.LPC0.LNKA,
0x00,
},
Package(0x04) {
0xffff,
0x03,
\_SB.PCI0.LPC0.LNKB,
0x00,
},
})
}
}
}
Scope(\_GPE) {
Method(_L18) {
Notify(\_SB.PCI0.PB2, 0x02)
Notify(\_SB.PCI0.PB4, 0x02)
Notify(\_SB.PCI0.PB5, 0x02)
Notify(\_SB.PCI0.PB6, 0x02)
Notify(\_SB.PCI0.PB7, 0x02)
Notify(\_SB.PCI0.PB9, 0x02)
Notify(\_SB.PCI0.PB10, 0x02)
}
}
Device(OHC0) {
Name(_ADR, 0x00120000)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(OHC1) {
Name(_ADR, 0x00120001)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(OHC2) {
Name(_ADR, 0x00130000)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(OHC3) {
Name(_ADR, 0x00130001)
}
Device(OHC4) {
Name(_ADR, 0x00140005)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(EHC0) {
Name(_ADR, 0x00120002)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(EHC1) {
Name(_ADR, 0x00130002)
Name(_PRW, Package(0x02) {
0x0b,
0x03,
})
}
Device(SATA) {
Name(_ADR, 0x00110000)
Name(B5EN, 0x00)
Name(BA_5, 0x00)
Name(SBAR, 0xf0508000)
OperationRegion(SATX, PCI_Config, 0x00, 0x28)
Field(SATX, AnyAcc, NoLock, Preserve) {
VIDI, 32,
Offset(0x24),
BA05, 32
}
Method(GBAA, 0, Serialized) {
Store(BA05, BA_5)
If(LEqual(BA_5, 0xffffffff)) {
Store(0x00, B5EN)
Return(SBAR)
}
Else {
Store(0x01, B5EN)
Return(BA_5)
}
}
OperationRegion(BAR5, SystemMemory, GBAA, 0x1000)
Field(BAR5, AnyAcc, NoLock, Preserve) {
Offset(0x120),
, 7,
PMBY, 1,
Offset(0x128),
PMS0, 4,
Offset(0x129),
PMS1, 4,
Offset(0x12c),
DET0, 4,
Offset(0x130),
Offset(0x132),
PRC0, 1,
Offset(0x1a0),
, 7,
SMBY, 1,
Offset(0x1a8),
SMS0, 4,
Offset(0x1a9),
SMS1, 4,
Offset(0x1ac),
DET1, 4,
Offset(0x1b0),
Offset(0x1b2),
PRC1, 1,
Offset(0x220),
, 7,
PSBY, 1,
Offset(0x228),
PSS0, 4,
Offset(0x229),
PSS1, 4,
Offset(0x22c),
DET2, 4,
Offset(0x230),
Offset(0x232),
PRC2, 1,
Offset(0x2a0),
, 7,
SSBY, 1,
Offset(0x2a8),
SSS0, 4,
Offset(0x2a9),
SSS1, 4,
Offset(0x2ac),
DET3, 4,
Offset(0x2b0),
Offset(0x2b2),
PRC3, 1
}
Method(_INI) {
GBAA()
}
Device(PRID) {
Name(_ADR, 0x00)
Name(SPTM, Buffer(0x14) {0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0=
x0, 0x0, 0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x1f, 0x0, 0x0, 0x0 })
Method(_GTM) {
Return(SPTM)
}
Method(_STM, 3) {
Store(Arg0, SPTM)
}
Name(PRIS, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LOr(LEqual(TPOS, 0x40), LEqual(TPOS, 0x04)), =
\_SB.PCI0.SATA.B5EN)) {
If(\_SB.PCI0.SATA.PMS1) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.PMBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
If(\_SB.PCI0.SATA.PSS1) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.PSBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
}
Store(0x00, PRIS)
}
Method(_PS3) {
Store(0x03, PRIS)
}
Method(_PSC) {
Return(PRIS)
}
Device(P_D0) {
Name(_ADR, 0x00)
Method(_STA) {
GBAA()
If(LEqual(B5EN, 0x00)) {
Return(0x00)
}
If(Not(LEqual(\_SB.PCI0.SATA.PMS1, 0x00), )) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(S12P, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.PMBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
Store(0x00, S12P)
}
Method(_PS3) {
Store(0x03, S12P)
}
Method(_PSC) {
Return(S12P)
}
Method(_GTF) {
Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
0, 0xef }, Local0)
Return(Local0)
}
}
Device(P_D1) {
Name(_ADR, 0x01)
Method(_STA) {
GBAA()
If(LEqual(B5EN, 0x00)) {
Return(0x00)
}
If(Not(LEqual(\_SB.PCI0.SATA.SMS1, 0x00), )) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(S12P, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.PSBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
Store(0x00, S12P)
}
Method(_PS3) {
Store(0x03, S12P)
}
Method(_PSC) {
Return(S12P)
}
Method(_GTF) {
Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
0, 0xef }, Local0)
Return(Local0)
}
}
}
Device(SECD) {
Name(_ADR, 0x01)
Name(SPTM, Buffer(0x14) {0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0=
x0, 0x0, 0x78, 0x0, 0x0, 0x0, 0xf, 0x0, 0x0, 0x0, 0x1f, 0x0, 0x0, 0x0 })
Method(_GTM) {
Return(SPTM)
}
Method(_STM, 3) {
Store(Arg0, SPTM)
}
Name(SECS, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LOr(LEqual(TPOS, 0x40), LEqual(TPOS, 0x04)), =
\_SB.PCI0.SATA.B5EN)) {
If(\_SB.PCI0.SATA.SMS1) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.SMBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
If(\_SB.PCI0.SATA.SSS1) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.SSBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
}
Store(0x00, SECS)
}
Method(_PS3) {
Store(0x03, SECS)
}
Method(_PSC) {
Return(SECS)
}
Device(S_D0) {
Name(_ADR, 0x00)
Method(_STA) {
GBAA()
If(LEqual(B5EN, 0x00)) {
Return(0x00)
}
If(Not(LEqual(\_SB.PCI0.SATA.PSS1, 0x00), )) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(S12P, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.SMBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
Store(0x00, S12P)
}
Method(_PS3) {
Store(0x03, S12P)
}
Method(_PSC) {
Return(S12P)
}
Method(_GTF) {
Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
0, 0xef }, Local0)
Return(Local0)
}
}
Device(S_D1) {
Name(_ADR, 0x01)
Method(_STA) {
GBAA()
If(LEqual(B5EN, 0x00)) {
Return(0x00)
}
If(Not(LEqual(\_SB.PCI0.SATA.SSS0, 0x00), )) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(S12P, 0x00)
Method(_PS0) {
GBAA()
If(LAnd(LAnd(LNot(LEqual(TPOS, 0x40)), LNot(LEqua=
l(TPOS, 0x04))), \_SB.PCI0.SATA.B5EN)) {
Store(0x32, Local0)
While(LAnd(LEqual(\_SB.PCI0.SATA.SSBY, 0x01),=
Local0)) {
Sleep(0xfa)
Decrement(Local0)
}
}
Store(0x00, S12P)
}
Method(_PS3) {
Store(0x03, S12P)
}
Method(_PSC) {
Return(S12P)
}
Method(_GTF) {
Store(Buffer(0x07) {0x3, 0x46, 0x0, 0x0, 0x0, 0xa=
0, 0xef }, Local0)
Return(Local0)
}
}
}
}
Device(SMB) {
Name(_ADR, 0x00140000)
OperationRegion(Z00V, PCI_Config, 0x08, 0x0100)
Field(Z00V, AnyAcc, NoLock, Preserve) {
RVID, 8,
Offset(0xc),
HPBS, 32,
Offset(0x5a),
I1F, 1,
I12F, 1,
, 2,
MT3A, 1,
Offset(0x5c),
, 10,
HPET, 1,
Offset(0xf0),
EIDX, 8,
Offset(0xf4),
EDAT, 32
}
OperationRegion(WIDE, PCI_Config, 0xad, 0x01)
Field(WIDE, AnyAcc, NoLock, Preserve) {
DUM1, 4,
SOPT, 1
}
OperationRegion(SMB2, SystemIO, 0x8040, 0x06)
Field(SMB2, ByteAcc, NoLock, Preserve) {
Z00W, 8,
Z00X, 8,
Z00Y, 8,
Z00Z, 8,
Z010, 8,
Z011, 8
}
OperationRegion(PMIO, SystemIO, 0x0cd6, 0x02)
Field(PMIO, ByteAcc, NoLock, Preserve) {
INPM, 8,
DAPM, 8
}
IndexField(INPM, DAPM, ByteAcc, NoLock, Preserve) {
, 1,
TM1E, 1,
TM2E, 1,
Offset(0x1),
, 1,
TM1S, 1,
TM2S, 1,
Offset(0x2),
, 1,
IR9E, 1,
Offset(0x4),
, 7,
SLPS, 1,
, 1,
IR9S, 1,
Offset(0x7),
, 7,
CLPS, 1,
Offset(0xd),
EV0S, 1,
EV1S, 1,
Offset(0x10),
, 6,
PWDE, 1,
Offset(0x1c),
, 3,
MKME, 1,
PI3E, 1,
PI2E, 1,
PI1E, 1,
PI0E, 1,
, 3,
MKMS, 1,
PI3S, 1,
PI2S, 1,
PI1S, 1,
PI0S, 1,
Offset(0x20),
P1EB, 16,
Offset(0x36),
, 5,
GE5C, 1,
GE6C, 1,
Offset(0x37),
EV0C, 1,
EV1C, 1,
, 2,
GM1C, 1,
GM2C, 1,
GM3C, 1,
Offset(0x38),
, 1,
GM4C, 1,
GM5C, 1,
, 1,
GM6C, 1,
Offset(0x3a),
, 4,
GM1S, 1,
GM2S, 1,
GM3S, 1,
Offset(0x3b),
, 1,
GM4S, 1,
GM5S, 1,
, 1,
GM6S, 1,
Offset(0x55),
SPRE, 1,
, 1,
, 1,
EPNM, 1,
DPPF, 1,
FNGS, 1,
, 1,
HIHP, 1,
Offset(0x61),
, 7,
R617, 1,
Offset(0x65),
, 4,
RSTU, 1,
Offset(0x68),
, 3,
TPDE, 1,
, 1,
Offset(0x7c),
, 2,
BLNK, 2,
Offset(0x92),
, 5,
GE5S, 1,
GE6S, 1,
GV7S, 1,
Offset(0x94),
GP8O, 1,
GP9O, 1,
GP8E, 1,
GP9E, 1,
GP8I, 1,
GP9I, 1,
GP8L, 1,
GP9L, 1,
Offset(0x9a),
, 7,
HECO, 1,
Offset(0xa8),
PI4E, 1,
PI5E, 1,
PI6E, 1,
PI7E, 1,
Offset(0xa9),
PI4S, 1,
PI5S, 1,
PI6S, 1,
PI7S, 1
}
OperationRegion(P1E0, SystemIO, P1EB, 0x04)
Field(P1E0, ByteAcc, NoLock, Preserve) {
, 14,
PEWS, 1,
WSTA, 1,
, 14,
PEWD, 1
}
OperationRegion(GPIO, PCI_Config, 0x00, 0x0100)
Field(GPIO, AnyAcc, NoLock, Preserve) {
Offset(0x50),
G49O, 1,
G50O, 1,
G51O, 1,
G52O, 1,
G49E, 1,
G50E, 1,
G51E, 1,
G52E, 1,
Offset(0x52),
G53O, 1,
G54O, 1,
G55O, 1,
G56O, 1,
G53E, 1,
G54E, 1,
G55E, 1,
G56E, 1,
Offset(0x56),
, 3,
G64O, 1,
, 3,
G64E, 1,
Offset(0x5a),
G70O, 1,
G71O, 1,
G72O, 1,
G73O, 1,
G70E, 1,
G71E, 1,
G72E, 1,
G73E, 1,
G70S, 1,
G71S, 1,
G72S, 1,
G73S, 1,
G70F, 1,
G71F, 1,
G72F, 1,
G73F, 1,
Offset(0x7e),
, 1,
G66O, 1,
, 3,
G66E, 1,
Offset(0x7f),
, 1,
G66S, 1,
Offset(0x80),
, 3,
G03O, 1,
, 3,
G03E, 1,
, 3,
G03S, 1,
Offset(0x82),
G13O, 1,
, 3,
G13E, 1,
Offset(0xa6),
, 3,
G48O, 1,
, 3,
G48E, 1,
Offset(0xa8),
, 1,
G05O, 1,
, 1,
G07O, 1,
G08O, 1,
G09O, 1,
Offset(0xa9),
, 1,
G05E, 1,
, 1,
G07E, 1,
G08E, 1,
G09E, 1,
Offset(0xaa),
, 3,
G07S, 1,
Offset(0xbc),
G33O, 1,
G34O, 1,
G35O, 1,
G36O, 1,
G33E, 1,
G34E, 1,
G35E, 1,
G36E, 1,
G33S, 1,
G34S, 1,
G35S, 1,
G36S, 1,
G33F, 1,
G34F, 1,
G35F, 1,
G36F, 1
}
Method(TRMD) {
Store(Zero, SPRE)
Store(Zero, TPDE)
}
Method(HTCD) {
Store(Zero, PI2E)
Store(Zero, TM2E)
Store(PI2S, PI2S)
Store(TM2S, TM2S)
}
}
Device(IDE) {
Name(_ADR, 0x00140001)
Name(UDMT, Package(0x08) {
0x78,
0x5a,
0x3c,
0x2d,
0x1e,
0x14,
0x0f,
0x00,
})
Name(PIOT, Package(0x06) {
0x0258,
0x0186,
0x010e,
0xb4,
0x78,
0x00,
})
Name(PITR, Package(0x06) {
0x99,
0x47,
0x34,
0x22,
0x20,
0x99,
})
Name(MDMT, Package(0x04) {
0x01e0,
0x96,
0x78,
0x00,
})
Name(MDTR, Package(0x04) {
0x77,
0x21,
0x20,
0xff,
})
OperationRegion(IDE, PCI_Config, 0x40, 0x20)
Field(IDE, WordAcc, NoLock, Preserve) {
PPIT, 16,
SPIT, 16,
PMDT, 16,
SMDT, 16,
PPIC, 8,
SPIC, 8,
PPIM, 8,
SPIM, 8,
Offset(0x14),
PUDC, 2,
SUDC, 2,
Offset(0x16),
PUDM, 8,
SUDM, 8
}
Method(ATPI, 1) {
Store(Arg0, Local0)
And(Local0, 0xff, Local0)
Or(Local0, 0x41544900, Local0)
Store(Local0, \_SB.PCI0.LPC0.INFO)
}
Method(GETT, 1) {
Store(And(Arg0, 0x0f, ), Local0)
Store(ShiftRight(Arg0, 0x04, ), Local1)
Return(Multiply(0x1e, Add(Add(Local0, 0x01, ), Add(Local1=
, 0x01, ), ), ))
}
Method(GTM, 1) {
CreateByteField(Arg0, 0x00, PIT1)
CreateByteField(Arg0, 0x01, PIT0)
CreateByteField(Arg0, 0x02, MDT1)
CreateByteField(Arg0, 0x03, MDT0)
CreateByteField(Arg0, 0x04, PICX)
CreateByteField(Arg0, 0x05, UDCX)
CreateByteField(Arg0, 0x06, UDMX)
Name(BUF, Buffer(0x14) {0xff, 0xff, 0xff, 0xff, 0xff, 0xf=
f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, =
0x0, 0x0 })
CreateDWordField(BUF, 0x00, PIO0)
CreateDWordField(BUF, 0x04, DMA0)
CreateDWordField(BUF, 0x08, PIO1)
CreateDWordField(BUF, 0x0c, DMA1)
CreateDWordField(BUF, 0x10, FLAG)
If(And(PICX, 0x01, )) {
Return(BUF)
}
Store(GETT(PIT0), PIO0)
Store(GETT(PIT1), PIO1)
If(And(UDCX, 0x01, )) {
Or(FLAG, 0x01, FLAG)
Store(DerefOf(Index(^UDMT, And(UDMX, 0x0f, ), )), DMA=
0)
}
Else {
Store(GETT(MDT0), DMA0)
}
If(And(UDCX, 0x02, )) {
Or(FLAG, 0x04, FLAG)
Store(DerefOf(Index(^UDMT, ShiftRight(UDMX, 0x04, ), =
)), DMA1)
}
Else {
Store(GETT(MDT1), DMA1)
}
Or(FLAG, 0x1a, FLAG)
Return(BUF)
}
Method(STM, 3) {
CreateDWordField(Arg0, 0x00, PIO0)
CreateDWordField(Arg0, 0x04, DMA0)
CreateDWordField(Arg0, 0x08, PIO1)
CreateDWordField(Arg0, 0x0c, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0=
x0 })
CreateByteField(BUF, 0x00, PIT1)
CreateByteField(BUF, 0x01, PIT0)
CreateByteField(BUF, 0x02, MDT1)
CreateByteField(BUF, 0x03, MDT0)
CreateByteField(BUF, 0x04, PIMX)
CreateByteField(BUF, 0x05, UDCX)
CreateByteField(BUF, 0x06, UDMX)
Store(Match(^PIOT, MLE, PIO0, MTR, 0x00, 0x00), Local0)
Divide(Local0, 0x05, Local0, )
Store(Match(^PIOT, MLE, PIO1, MTR, 0x00, 0x00), Local1)
Divide(Local1, 0x05, Local1, )
Store(Or(ShiftLeft(Local1, 0x04, ), Local0, ), PIMX)
Store(DerefOf(Index(^PITR, Local0, )), PIT0)
Store(DerefOf(Index(^PITR, Local1, )), PIT1)
If(And(FLAG, 0x01, )) {
Store(Match(^UDMT, MLE, DMA0, MTR, 0x00, 0x00), Local=
0)
Divide(Local0, 0x07, Local0, )
Or(UDMX, Local0, UDMX)
Or(UDCX, 0x01, UDCX)
}
Else {
If(LNot(LEqual(DMA0, 0xffffffff))) {
Store(Match(^MDMT, MLE, DMA0, MTR, 0x00, 0x00), L=
ocal0)
Store(DerefOf(Index(^MDTR, Local0, )), MDT0)
}
}
If(And(FLAG, 0x04, )) {
Store(Match(^UDMT, MLE, DMA1, MTR, 0x00, 0x00), Local=
0)
Divide(Local0, 0x07, Local0, )
Or(UDMX, ShiftLeft(Local0, 0x04, ), UDMX)
Or(UDCX, 0x02, UDCX)
}
Else {
If(LNot(LEqual(DMA1, 0xffffffff))) {
Store(Match(^MDMT, MLE, DMA1, MTR, 0x00, 0x00), L=
ocal0)
Store(DerefOf(Index(^MDTR, Local0, )), MDT1)
}
}
Return(BUF)
}
Method(GTF, 2) {
CreateByteField(Arg1, 0x00, MDT1)
CreateByteField(Arg1, 0x01, MDT0)
CreateByteField(Arg1, 0x02, PIMX)
CreateByteField(Arg1, 0x03, UDCX)
CreateByteField(Arg1, 0x04, UDMX)
If(LEqual(Arg0, 0xa0)) {
Store(And(PIMX, 0x0f, ), Local0)
Store(MDT0, Local1)
And(UDCX, 0x01, Local2)
Store(And(UDMX, 0x0f, ), Local3)
}
Else {
Store(ShiftRight(PIMX, 0x04, ), Local0)
Store(MDT1, Local1)
And(UDCX, 0x02, Local2)
Store(ShiftRight(UDMX, 0x04, ), Local3)
}
Name(BUF, Buffer(0x15) {0x3, 0x0, 0x0, 0x0, 0x0, 0xff, 0x=
ef, 0x3, 0x0, 0x0, 0x0, 0x0, 0xff, 0xef, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
f5 })
CreateByteField(BUF, 0x01, PMOD)
CreateByteField(BUF, 0x08, DMOD)
CreateByteField(BUF, 0x05, CMDA)
CreateByteField(BUF, 0x0c, CMDB)
CreateByteField(BUF, 0x13, CMDC)
Store(Arg0, CMDA)
Store(Arg0, CMDB)
Store(Arg0, CMDC)
Or(Local0, 0x08, PMOD)
If(Local2) {
Or(Local3, 0x40, DMOD)
}
Else {
Store(Match(^MDMT, MLE, GETT(Local1), MTR, 0x00, 0x00=
), Local4)
If(LLess(Local4, 0x03)) {
Or(0x20, Local4, DMOD)
}
}
Return(BUF)
}
Device(PRID) {
Name(_ADR, 0x00)
Method(_GTM) {
Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x=
0, 0x0 })
CreateWordField(BUF, 0x00, VPIT)
CreateWordField(BUF, 0x02, VMDT)
CreateByteField(BUF, 0x04, VPIC)
CreateByteField(BUF, 0x05, VUDC)
CreateByteField(BUF, 0x06, VUDM)
If(\_SB.PCI0.SMB.SOPT) {
Store(^^PPIT, VPIT)
Store(^^PMDT, VMDT)
Store(^^PPIC, VPIC)
Store(^^PUDC, VUDC)
Store(^^PUDM, VUDM)
}
Else {
Store(^^SPIT, VPIT)
Store(^^SMDT, VMDT)
Store(^^SPIC, VPIC)
Store(^^SUDC, VUDC)
Store(^^SUDM, VUDM)
}
Return(GTM(BUF))
}
Method(_STM, 3) {
Name(BUF, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x0 })
CreateWordField(BUF, 0x00, VPIT)
CreateWordField(BUF, 0x02, VMDT)
CreateByteField(BUF, 0x04, VPIM)
CreateByteField(BUF, 0x05, VUDC)
CreateByteField(BUF, 0x06, VUDM)
Store(STM(Arg0, Arg1, Arg2), BUF)
If(\_SB.PCI0.SMB.SOPT) {
Store(VPIT, ^^PPIT)
Store(VMDT, ^^PMDT)
Store(VPIM, ^^PPIM)
Store(VUDC, ^^PUDC)
Store(VUDM, ^^PUDM)
}
Else {
Store(VPIT, ^^SPIT)
Store(VMDT, ^^SMDT)
Store(VPIM, ^^SPIM)
Store(VUDC, ^^SUDC)
Store(VUDM, ^^SUDM)
}
}
Device(P_D0) {
Name(_ADR, 0x00)
Method(_GTF) {
Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
)
CreateWordField(BUF, 0x00, VMDT)
CreateByteField(BUF, 0x02, VPIM)
CreateByteField(BUF, 0x03, VUDC)
CreateByteField(BUF, 0x04, VUDM)
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
Else {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
Return(GTF(0xa0, BUF))
}
}
Device(P_D1) {
Name(_ADR, 0x01)
Method(_GTF) {
Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
)
CreateWordField(BUF, 0x00, VMDT)
CreateByteField(BUF, 0x02, VPIM)
CreateByteField(BUF, 0x03, VUDC)
CreateByteField(BUF, 0x04, VUDM)
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
Else {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
Return(GTF(0xb0, BUF))
}
}
Method(_STA) {
And(PPIC, 0x01, Local0)
If(LAnd(Local0, 0x01)) {
Return(Z008)
}
Else {
Return(Z005)
}
}
}
Device(SECD) {
Name(_ADR, 0x01)
Method(_GTM) {
Name(BUF, Buffer(0x07) {0x0, 0x0, 0xff, 0xff, 0x0, 0x=
0, 0x0 })
CreateWordField(BUF, 0x00, VPIT)
CreateWordField(BUF, 0x02, VMDT)
CreateByteField(BUF, 0x04, VPIC)
CreateByteField(BUF, 0x05, VUDC)
CreateByteField(BUF, 0x06, VUDM)
If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^PPIT, VPIT)
Store(^^PMDT, VMDT)
Store(^^PPIC, VPIC)
Store(^^PUDC, VUDC)
Store(^^PUDM, VUDM)
}
Else {
Store(^^SPIT, VPIT)
Store(^^SMDT, VMDT)
Store(^^SPIC, VPIC)
Store(^^SUDC, VUDC)
Store(^^SUDM, VUDM)
}
}
Else {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^SPIT, VPIT)
Store(^^SMDT, VMDT)
Store(^^SPIC, VPIC)
Store(^^SUDC, VUDC)
Store(^^SUDM, VUDM)
}
Else {
Store(^^PPIT, VPIT)
Store(^^PMDT, VMDT)
Store(^^PPIC, VPIC)
Store(^^PUDC, VUDC)
Store(^^PUDM, VUDM)
}
}
Return(GTM(BUF))
}
Method(_STM, 3) {
Name(BUF, Buffer(0x07) {0x0, 0x0, 0x0, 0x0, 0x0, 0x0,=
0x0 })
CreateWordField(BUF, 0x00, VPIT)
CreateWordField(BUF, 0x02, VMDT)
CreateByteField(BUF, 0x04, VPIM)
CreateByteField(BUF, 0x05, VUDC)
CreateByteField(BUF, 0x06, VUDM)
Store(STM(Arg0, Arg1, Arg2), BUF)
If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
If(\_SB.PCI0.SMB.SOPT) {
Store(VPIT, ^^PPIT)
Store(VMDT, ^^PMDT)
Store(VPIM, ^^PPIM)
Store(VUDC, ^^PUDC)
Store(VUDM, ^^PUDM)
}
Else {
Store(VPIT, ^^SPIT)
Store(VMDT, ^^SMDT)
Store(VPIM, ^^SPIM)
Store(VUDC, ^^SUDC)
Store(VUDM, ^^SUDM)
}
}
Else {
If(\_SB.PCI0.SMB.SOPT) {
Store(VPIT, ^^SPIT)
Store(VMDT, ^^SMDT)
Store(VPIM, ^^SPIM)
Store(VUDC, ^^SUDC)
Store(VUDM, ^^SUDM)
}
Else {
Store(VPIT, ^^PPIT)
Store(VMDT, ^^PMDT)
Store(VPIM, ^^PPIM)
Store(VUDC, ^^PUDC)
Store(VUDM, ^^PUDM)
}
}
}
Device(S_D0) {
Name(_ADR, 0x00)
Method(_GTF) {
Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
)
CreateWordField(BUF, 0x00, VMDT)
CreateByteField(BUF, 0x02, VPIM)
CreateByteField(BUF, 0x03, VUDC)
CreateByteField(BUF, 0x04, VUDM)
If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
Else {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
}
Else {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
Else {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
}
Return(GTF(0xa0, BUF))
}
}
Device(S_D1) {
Name(_ADR, 0x01)
Method(_GTF) {
Name(BUF, Buffer(0x05) {0x0, 0x0, 0x0, 0x0, 0x0 }=
)
CreateWordField(BUF, 0x00, VMDT)
CreateByteField(BUF, 0x02, VPIM)
CreateByteField(BUF, 0x03, VUDC)
CreateByteField(BUF, 0x04, VUDM)
If(LNot(LLess(\_SB.PCI0.SMB.RVID, 0x3a))) {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
Else {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
}
Else {
If(\_SB.PCI0.SMB.SOPT) {
Store(^^^SMDT, VMDT)
Store(^^^SPIM, VPIM)
Store(^^^SUDC, VUDC)
Store(^^^SUDM, VUDM)
}
Else {
Store(^^^PMDT, VMDT)
Store(^^^PPIM, VPIM)
Store(^^^PUDC, VUDC)
Store(^^^PUDM, VUDM)
}
}
Return(GTF(0xb0, BUF))
}
}
Method(_STA) {
And(SPIC, 0x01, Local0)
If(LAnd(Local0, 0x01)) {
Return(Z008)
}
Else {
Return(Z005)
}
}
}
}
Device(HDA) {
Name(_ADR, 0x00140002)
Name(_PRW, Package(0x02) {
0x1b,
0x03,
})
}
Device(LPC0) {
Name(_ADR, 0x00140003)
Mutex(PSMX, 0)
OperationRegion(PIRQ, SystemIO, 0x0c00, 0x02)
Field(PIRQ, ByteAcc, NoLock, Preserve) {
PIID, 8,
PIDA, 8
}
IndexField(PIID, PIDA, ByteAcc, NoLock, Preserve) {
PIRA, 8,
PIRB, 8,
PIRC, 8,
PIRD, 8,
PIRS, 8,
Offset(0x9),
PIRE, 8,
PIRF, 8,
PIRG, 8,
PIRH, 8
}
Name(IPRS, Buffer(0x06) {0x23, 0x0, 0xc, 0x18, 0x79, 0x0 })
Name(UPRS, Buffer(0x06) {0x23, 0xb8, 0x0, 0x8, 0x79, 0x0 })
Method(DSPI) {
Store(0x00, PIRA)
Store(0x00, PIRB)
Store(0x00, PIRC)
Store(0x00, PIRD)
Store(0x00, PIRE)
Store(0x00, PIRF)
Store(0x00, PIRG)
Store(0x00, PIRH)
}
Device(LNKA) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x01)
Method(_STA) {
If(PIRA) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRA)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRA, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRA)
}
}
Device(LNKB) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x02)
Method(_STA) {
If(PIRB) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRB)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRB, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRB)
}
}
Device(LNKC) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x03)
Method(_STA) {
If(PIRC) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRC)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRC, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRC)
}
}
Device(LNKD) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x04)
Method(_STA) {
If(PIRD) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRD)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRD, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRD)
}
}
Device(LNKE) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x05)
Method(_STA) {
If(PIRE) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRE)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRE, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRE)
}
}
Device(LNKF) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x06)
Method(_STA) {
If(PIRF) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRF)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRF, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRF)
}
}
Device(LNKG) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x07)
Method(_STA) {
If(PIRG) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRG)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRG, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRG)
}
}
Device(LNKH) {
Name(_HID, 0x0f0cd041)
Name(_UID, 0x08)
Method(_STA) {
If(PIRH) {
Return(Z007)
}
Else {
Return(Z008)
}
}
Method(_PRS) {
Return(IPRS)
}
Method(_DIS) {
Store(0x00, PIRH)
}
Method(_CRS) {
Store(IPRS, Local0)
CreateWordField(Local0, 0x01, IRQ0)
ShiftLeft(0x01, PIRH, IRQ0)
Return(Local0)
}
Method(_SRS, 1) {
CreateWordField(Arg0, 0x01, IRQ0)
FindSetRightBit(IRQ0, Local0)
Decrement(Local0)
Store(Local0, PIRH)
}
}
OperationRegion(LCLM, SystemIO, 0x0c50, 0x03)
Field(LCLM, ByteAcc, NoLock, Preserve) {
CLMI, 8,
CLMD, 8,
CLGP, 8
}
OperationRegion(ECTH, SystemIO, 0x68, 0x06)
Field(ECTH, ByteAcc, NoLock, Preserve) {
ECPI, 8,
Offset(0x2),
Offset(0x3),
Offset(0x4),
ECPD, 8
}
IndexField(CLMI, CLMD, ByteAcc, NoLock, Preserve) {
IDRG, 8,
Offset(0x2),
TSTS, 8,
TINT, 8,
Offset(0x12),
I2CC, 8,
GPIO, 8
}
Method(RGPM) {
Store(\_SB.PCI0.LPC0.GPIO, Local0)
And(Local0, Not(0xc0, ), Local0)
Store(Local0, \_SB.PCI0.LPC0.GPIO)
Store(\_SB.PCI0.LPC0.CLGP, Local1)
Return(Local1)
}
OperationRegion(LPCR, PCI_Config, 0x00, 0x7f)
Field(LPCR, ByteAcc, NoLock, Preserve) {
Offset(0x44),
CMA0, 1,
CMA1, 1,
CMA2, 1,
CMA3, 1,
CMA4, 1,
CMA5, 1,
CMA6, 1,
CMA7, 1,
CMB0, 1,
CMB1, 1,
CMB2, 1,
CMB3, 1,
CMB4, 1,
CMB5, 1,
CMB6, 1,
CMB7, 1,
Offset(0x48),
, 2,
ENW0, 1,
Offset(0x4a),
IOP0, 1,
IOP1, 1,
IOP2, 1,
IOP3, 1,
Offset(0x4b),
ENW1, 1,
Offset(0x64),
IOB1, 16,
IOB2, 16,
Offset(0x74),
AWR0, 1,
, 1,
AWR1, 1
}
Device(DMAC) {
Name(_HID, 0x0002d041)
Name(_CRS, Buffer(0x1d) {0x47, 0x1, 0x0, 0x0, 0x0, 0x0, 0=
x1, 0x20, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1, 0x10, 0x47, 0x1, 0xc0, 0x=
0, 0xc0, 0x0, 0x1, 0x20, 0x2a, 0x10, 0x1, 0x79, 0x0 })
}
Device(MATH) {
Name(_HID, 0x040cd041)
Name(_CRS, Buffer(0x0e) {0x47, 0x1, 0xf0, 0x0, 0xf0, 0x0,=
0x1, 0xf, 0x23, 0x0, 0x20, 0x1, 0x79, 0x0 })
}
Device(PIC) {
Name(_HID, 0xd041)
Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x20, 0x0, 0x20, 0x0,=
0x1, 0x2, 0x47, 0x1, 0xa0, 0x0, 0xa0, 0x0, 0x1, 0x2, 0x23, 0x4, 0x0, 0x1=
, 0x79, 0x0 })
}
Device(RTC) {
Name(_HID, 0x000bd041)
Name(_CRS, Buffer(0x0e) {0x47, 0x1, 0x70, 0x0, 0x70, 0x0,=
0x1, 0x2, 0x23, 0x0, 0x1, 0x1, 0x79, 0x0 })
}
Device(SPKR) {
Name(_HID, 0x0008d041)
Name(_CRS, Buffer(0x0a) {0x47, 0x1, 0x61, 0x0, 0x61, 0x0,=
0x1, 0x1, 0x79, 0x0 })
}
Device(TIME) {
Name(_HID, 0x0001d041)
Name(_CRS, Buffer(0x0e) {0x47, 0x1, 0x40, 0x0, 0x40, 0x0,=
0x1, 0x4, 0x23, 0x1, 0x0, 0x1, 0x79, 0x0 })
}
Device(KBC0) {
Name(_HID, 0x0303d041)
Method(_STA) {
If(LEqual(OSYS, 0x40)) {
If(LEqual(KBTP, 0x4a)) {
Return(0x00)
}
Else {
Return(0x0f)
}
}
Else {
Return(0x0f)
}
}
Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0,=
0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x23, 0x2, 0x0, 0x1=
, 0x79, 0x0 })
}
Device(KBCJ) {
Name(_HID, 0x2003d041)
Method(_STA) {
If(LEqual(OSYS, 0x40)) {
If(LEqual(KBTP, 0x4a)) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Else {
Return(0x00)
}
}
Name(_CRS, Buffer(0x16) {0x47, 0x1, 0x60, 0x0, 0x60, 0x0,=
0x1, 0x1, 0x47, 0x1, 0x64, 0x0, 0x64, 0x0, 0x1, 0x1, 0x23, 0x2, 0x0, 0x1=
, 0x79, 0x0 })
}
Device(MSE0) {
Name(_HID, 0x130fd041)
Name(_CRS, Buffer(0x06) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 =
})
Method(_STA) {
If(LOr(LEqual(PTYP, 0x02), LEqual(PTYP, 0x04))) {
Return(0x0f)
}
Else {
If(LEqual(PTYP, 0x01)) {
Return(0x00)
}
Else {
Return(0x0f)
}
}
}
Method(_PSW, 1) {
}
}
Device(MSS0) {
Name(_HID, 0x171b2e4f)
Name(_CID, Package(0x03) {
0x00072e4f,
0x02002e4f,
0x130fd041,
})
Method(_STA) {
If(LEqual(PTYP, 0x01)) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(_CRS, Buffer(0x06) {0x23, 0x0, 0x10, 0x1, 0x79, 0x0 =
})
Method(_PSW, 1) {
}
}
Device(SYSR) {
Name(_HID, 0x020cd041)
Method(_STA) {
If(PJID) {
Return(0x00)
}
Else {
Return(0x0f)
}
}
Name(_CRS, Buffer(0xfa) {0x47, 0x1, 0x22, 0x0, 0x22, 0x0,=
0x1, 0x2, 0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x68, 0x=
0, 0x68, 0x0, 0x1, 0x1, 0x47, 0x1, 0x6c, 0x0, 0x6c, 0x0, 0x1, 0x1, 0x47, =
0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x2, 0x47, 0x1, 0x80, 0x0, 0x80, 0x0, 0x1=
, 0x2, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb8, 0x0, 0=
xb8, 0x0, 0x1, 0x1, 0x47, 0x1, 0x92, 0x0, 0x92, 0x0, 0x1, 0x1, 0x47, 0x1,=
0x20, 0x2, 0x20, 0x2, 0x1, 0x10, 0x47, 0x1, 0xb, 0x4, 0xb, 0x4, 0x1, 0x1=
, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0xd6, 0x4, 0xd6, =
0x4, 0x1, 0x1, 0x47, 0x1, 0x30, 0x5, 0x30, 0x5, 0x8, 0x8, 0x47, 0x1, 0x0,=
0xc, 0x0, 0xc, 0x1, 0x2, 0x47, 0x1, 0x14, 0xc, 0x14, 0xc, 0x1, 0x1, 0x47=
, 0x1, 0x50, 0xc, 0x50, 0xc, 0x1, 0x3, 0x47, 0x1, 0x6c, 0xc, 0x6c, 0xc, 0=
x1, 0x1, 0x47, 0x1, 0x6f, 0xc, 0x6f, 0xc, 0x1, 0x1, 0x47, 0x1, 0xd0, 0xc,=
0xd0, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd2, 0xc, 0xd2, 0xc, 0x1, 0x2, 0x47, 0x=
1, 0xd4, 0xc, 0xd4, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd6, 0xc, 0xd6, 0xc, 0x1, =
0x2, 0x47, 0x1, 0xd8, 0xc, 0xd8, 0xc, 0x1, 0x8, 0x47, 0x1, 0x0, 0x80, 0x0=
, 0x80, 0x1, 0x60, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x81, 0x=
ff, 0x81, 0x0, 0x0, 0x0, 0x1, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x=
0, 0x82, 0xff, 0x82, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0x40, 0xf, 0x40, 0xf,=
0x1, 0x8, 0x47, 0x1, 0x7f, 0x8, 0x7f, 0x8, 0x1, 0x1, 0x79, 0x0 })
}
Device(SYSC) {
Name(_HID, 0x020cd041)
Method(_STA) {
If(PJID) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Name(_CRS, Buffer(0x0102) {0x47, 0x1, 0x22, 0x0, 0x22, 0x=
0, 0x1, 0x2, 0x47, 0x1, 0x2e, 0x0, 0x2e, 0x0, 0x1, 0x2, 0x47, 0x1, 0x68, =
0x0, 0x68, 0x0, 0x1, 0x1, 0x47, 0x1, 0x6c, 0x0, 0x6c, 0x0, 0x1, 0x1, 0x47=
, 0x1, 0x72, 0x0, 0x72, 0x0, 0x1, 0x2, 0x47, 0x1, 0x80, 0x10, 0x80, 0x10,=
0x1, 0x1, 0x47, 0x1, 0xb0, 0x0, 0xb0, 0x0, 0x1, 0x2, 0x47, 0x1, 0xb8, 0x=
0, 0xb8, 0x0, 0x1, 0x1, 0x47, 0x1, 0x92, 0x0, 0x92, 0x0, 0x1, 0x1, 0x47, =
0x1, 0x20, 0x2, 0x20, 0x2, 0x1, 0x10, 0x47, 0x1, 0xb, 0x4, 0xb, 0x4, 0x1,=
0x1, 0x47, 0x1, 0xd0, 0x4, 0xd0, 0x4, 0x1, 0x2, 0x47, 0x1, 0xd6, 0x4, 0x=
d6, 0x4, 0x1, 0x1, 0x47, 0x1, 0x30, 0x5, 0x30, 0x5, 0x8, 0x8, 0x47, 0x1, =
0x0, 0xc, 0x0, 0xc, 0x1, 0x2, 0x47, 0x1, 0x14, 0xc, 0x14, 0xc, 0x1, 0x1, =
0x47, 0x1, 0x50, 0xc, 0x50, 0xc, 0x1, 0x3, 0x47, 0x1, 0x6c, 0xc, 0x6c, 0x=
c, 0x1, 0x1, 0x47, 0x1, 0x6f, 0xc, 0x6f, 0xc, 0x1, 0x1, 0x47, 0x1, 0xd0, =
0xc, 0xd0, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd2, 0xc, 0xd2, 0xc, 0x1, 0x2, 0x47=
, 0x1, 0xd4, 0xc, 0xd4, 0xc, 0x1, 0x2, 0x47, 0x1, 0xd6, 0xc, 0xd6, 0xc, 0=
x1, 0x2, 0x47, 0x1, 0xd8, 0xc, 0xd8, 0xc, 0x1, 0x8, 0x47, 0x1, 0x0, 0x80,=
0x0, 0x80, 0x1, 0x60, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0, 0x0, 0x81=
, 0xff, 0x81, 0x0, 0x0, 0x0, 0x1, 0x88, 0xd, 0x0, 0x1, 0xc, 0x3, 0x0, 0x0=
, 0x0, 0x82, 0xff, 0x82, 0x0, 0x0, 0x0, 0x1, 0x47, 0x1, 0x40, 0xf, 0x40, =
0xf, 0x1, 0x8, 0x47, 0x1, 0x7f, 0x8, 0x7f, 0x8, 0x1, 0x1, 0x47, 0x1, 0x60=
, 0xfd, 0x60, 0xfd, 0x1, 0x4, 0x79, 0x0 })
}
Device(MEM) {
Name(_HID, 0x010cd041)
Name(MSRC, Buffer(0x26) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0=
xe, 0x0, 0x0, 0x0, 0x2, 0x0, 0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xff, 0=
x0, 0x0, 0x10, 0x0, 0x86, 0x9, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x=
0, 0x0, 0x79, 0x0 })
Method(_CRS) {
CreateDWordField(MSRC, 0x1c, BARX)
CreateDWordField(MSRC, 0x20, GALN)
Store(\_SB.PCI0.Z00U, Local0)
If(Local0) {
Store(0x1000, GALN)
And(Local0, 0xfffffff0, BARX)
}
Return(MSRC)
}
Method(_STA) {
Return(0x0f)
}
}
OperationRegion(SMI0, SystemIO, 0x00000f40, 0x00000002)
Field(SMI0, AnyAcc, NoLock, Preserve) {
SMIC, 8
}
OperationRegion(SMI1, SystemMemory, 0xafeddcdc, 0x00000120)
Field(SMI1, AnyAcc, NoLock, Preserve) {
BCMD, 8,
DID, 32,
INFO, 1024
}
Field(SMI1, AnyAcc, NoLock, Preserve) {
AccessAs(ByteAcc, 0),
Offset(0x5),
INF, 8,
INF1, 32
}
Method(PHSS, 1) {
Acquire(PSMX, 0xffff)
Store(0xa0, BCMD)
Store(Arg0, DID)
Store(Zero, SMIC)
Release(PSMX)
}
Device(HPET) {
Name(_HID, 0x0301d041)
Name(CRS, Buffer(0x0e) {0x86, 0x9, 0x0, 0x0, 0x0, 0x0, 0x=
d0, 0xfe, 0x0, 0x4, 0x0, 0x0, 0x79, 0x0 })
Method(_STA) {
If(LEqual(\_SB.PCI0.SMB.HPET, One)) {
Return(0x0f)
}
Else {
Return(0x00)
}
}
Mutex(HPSM, 0)
Method(_CRS) {
CreateDWordField(CRS, 0x04, HPT)
Acquire(HPSM, 0xffff)
Store(\_SB.PCI0.SMB.HIHP, Local0)
Store(Zero, \_SB.PCI0.SMB.HIHP)
If(LNot(LEqual(\_SB.PCI0.SMB.HPBS, 0x00))) {
Store(\_SB.PCI0.SMB.HPBS, HPT)
}
Store(Local0, \_SB.PCI0.SMB.HIHP)
Release(HPSM)
And(HPT, 0xffffffc0, HPT)
Return(CRS)
}
}
Method(ECOK) {
If(LEqual(\_SB.PCI0.LPC0.EC0.Z012, 0x01)) {
If(LEqual(OSYS, 0x40)) {
Store(0x01, \_SB.PCI0.LPC0.EC0.OSIF)
}
Else {
Store(0x00, \_SB.PCI0.LPC0.EC0.OSIF)
}
Return(0x01)
}
Else {
Return(0x00)
}
}
Device(EC0) {
Name(_HID, 0x090cd041)
Name(_GPE, 0x03)
Name(Z012, Zero)
Name(_CRS, Buffer(0x12) {0x47, 0x1, 0x62, 0x0, 0x62, 0x0,=
0x1, 0x1, 0x47, 0x1, 0x66, 0x0, 0x66, 0x0, 0x1, 0x1, 0x79, 0x0 })
Method(_REG, 2) {
If(LEqual(Arg0, 0x03)) {
Store(Arg1, Z012)
}
}
OperationRegion(ERAM, EmbeddedControl, 0x00, 0xff)
Field(ERAM, ByteAcc, Lock, Preserve) {
Offset(0x8),
BATM, 16,
Offset(0x19),
BATD, 56,
Offset(0x60),
SMPR, 8,
SMST, 8,
SMAD, 8,
SMCM, 8,
SMDR, 32,
BCNT, 8,
SMAA, 8,
SMD0, 8,
SMD1, 8,
Offset(0x90),
Offset(0x91),
Offset(0x92),
Offset(0x93),
Offset(0x94),
ERIB, 16,
ERBD, 8,
Offset(0x98),
Offset(0x99),
OSIF, 1,
Offset(0x9a),
BAL1, 1,
BAL2, 1,
BAL3, 1,
BAL4, 1,
BCL1, 1,
BCL2, 1,
BCL3, 1,
BCL4, 1,
BPU1, 1,
BPU2, 1,
BPU3, 1,
BPU4, 1,
BOS1, 1,
BOS2, 1,
BOS3, 1,
BOS4, 1,
PHDD, 1,
IFDD, 1,
IODD, 1,
SHDD, 1,
LS20, 1,
EFDD, 1,
ECRT, 1,
LANC, 1,
SBTN, 1,
VIDO, 1,
VOLD, 1,
VOLU, 1,
MUTE, 1,
CONT, 1,
BRGT, 1,
HBTN, 1,
S4SE, 1,
SKEY, 1,
BKEY, 1,
TKEY, 1,
FKEY, 1,
DVDM, 1,
DIGM, 1,
CDLK, 1,
, 1,
LIDO, 1,
PMEE, 1,
PBET, 1,
RIIN, 1,
BTWK, 1,
DKIN, 1,
Offset(0xa0),
, 6,
SWTH, 1,
HWTH, 1,
DKT0, 1,
DKT1, 1,
, 2,
OSUD, 1,
OSDK, 1,
OSSU, 1,
DKCG, 1,
ODTS, 8,
S1LD, 1,
S3LD, 1,
VGAQ, 1,
PCMQ, 1,
PCMR, 1,
ADPT, 1,
SYS6, 1,
SYS7, 1,
PWAK, 1,
MWAK, 1,
LWAK, 1,
RWAK, 1,
, 2,
KWAK, 1,
MSWK, 1,
CCAC, 1,
AOAC, 1,
BLAC, 1,
PSRC, 1,
BOAC, 1,
LCAC, 1,
AAAC, 1,
ACAC, 1,
PCEC, 8,
THON, 8,
THSD, 8,
Offset(0xaa),
TCON, 8,
THRS, 8,
THSE, 8,
FSSN, 4,
FANU, 4,
PTVL, 3,
, 3,
TTSR, 1,
TTHR, 1,
TSTH, 1,
TSBC, 1,
TSBF, 1,
TSPL, 1,
TSBT, 1,
, 2,
THTA, 1,
CTMP, 8,
LTMP, 8,
SKTA, 8,
SKTB, 8,
SKTC, 8,
SKTD, 8,
NBTP, 8,
LANP, 1,
LCDS, 1,
Offset(0xb8),
BTPV, 8,
BRTS, 8,
CTRS, 8,
WLAT, 1,
BTAT, 1,
WLEX, 1,
BTEX, 1,
KLSW, 1,
WLOK, 1,
Offset(0xbc),
PJID, 8,
CPUN, 8,
THFN, 8,
MLED, 1,
SCHG, 1,
SCCF, 1,
SCPF, 1,
ACIS, 1,
Offset(0xc0),
, 4,
BTMF, 3,
BTY0, 1,
BST0, 8,
BRC0, 16,
BSN0, 16,
BPV0, 16,
BDV0, 16,
BDC0, 16,
BFC0, 16,
GAU0, 8,
BSCY, 8,
BSCU, 16,
BAC0, 16,
BTW0, 8,
BATV, 8,
BPTC, 8,
BTTC, 8,
BTMA, 16,
BTSC, 8,
BCIX, 8,
CCBA, 8,
CBOT, 8,
BTSS, 16,
OVCC, 8,
CCFC, 8,
BADC, 8,
BSC1, 16,
BSC2, 16,
BSC3, 16,
BSC4, 16,
BDME, 16,
Offset(0xee),
Offset(0xef),
Offset(0xf0),
BTS1, 8,
BTS2, 8,
BSCS, 16,
BDAD, 16,
BACV, 16,
BDFC, 16
}
Method(PCLK) {
Store(PTVL, Local0)
Store(Local0, P80H)
Store(0x04, Local1)
If(LGreater(Local1, 0x00)) {
Decrement(Local1)
}
If(LNot(LGreater(Local0, Local1))) {
Store(Local0, \_PR.CPU0._PPC)
If(LEqual(CPUS, 0x00)) {
Store(Local0, \_PR.CPU1._PPC)
}
}
Else {
Store(Local1, \_PR.CPU0._PPC)
If(LEqual(CPUS, 0x00)) {
Store(Local1, \_PR.CPU1._PPC)
}
}
Notify(\_PR.CPU0, 0x80)
If(LEqual(CPUS, 0x00)) {
Notify(\_PR.CPU1, 0x80)
}
}
Method(_Q11) {
If(LEqual(OSYS, 0x40)) {
Store(0x87, P80H)
If(UMAS) {
Notify(\_SB.PCI0.AGP.VGA.LCD, 0x87)
}
Else {
Notify(\_SB.PCI0.PB2.DGFX.LCD, 0x87)
}
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
Store(\_SB.WMID.LBL0, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
Else {
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
Store(\_SB.WMID.LBL0, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
}
Method(_Q12) {
If(LEqual(OSYS, 0x40)) {
Store(0x86, P80H)
If(UMAS) {
Notify(\_SB.PCI0.AGP.VGA.LCD, 0x86)
}
Else {
Notify(\_SB.PCI0.PB2.DGFX.LCD, 0x86)
}
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
Store(\_SB.WMID.LBL0, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
Else {
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.BRTS, Local1)
Store(\_SB.WMID.LBL0, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
}
Method(_Q15) {
Store(0x15, P80H)
Notify(\_SB.LID, 0x80)
}
Method(_Q16) {
Store(0x16, P80H)
Notify(\_SB.LID, 0x80)
}
Method(_Q1D) {
Store(0x1d, P80H)
\_SB.PCI0.LPC0.EC0.PCLK()
Notify(\_TZ.THRM, 0x80)
Sleep(0x1e)
Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
}
Method(_Q22) {
Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
}
Method(_Q25) {
Store(0x25, P80H)
Notify(\_SB.PCI0.LPC0.BAT1, 0x81)
Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
}
Method(_Q27) {
Notify(\_TZ.THRM, 0x80)
}
Method(_Q2A) {
Store(0x1f, \_SB.PCI0.SMB.Z00W)
Sleep(0x32)
Store(0xc0, \_SB.PCI0.SMB.Z010)
Sleep(0x32)
Store(0x01, \_SB.PCI0.SMB.Z00Z)
Sleep(0x32)
Store(0x00, \_SB.PCI0.SMB.Z011)
Sleep(0x32)
Store(0x4c, \_SB.PCI0.SMB.Z00Y)
Sleep(0x32)
Store(0x1f, \_SB.PCI0.SMB.Z00W)
Sleep(0x32)
}
Method(_Q2B) {
Store(0x1f, \_SB.PCI0.SMB.Z00W)
Sleep(0x32)
Store(0xc0, \_SB.PCI0.SMB.Z010)
Sleep(0x32)
Store(0x03, \_SB.PCI0.SMB.Z00Z)
Sleep(0x32)
Store(0x01, \_SB.PCI0.SMB.Z011)
Sleep(0x32)
Store(0x4c, \_SB.PCI0.SMB.Z00Y)
Sleep(0x32)
Store(0x1f, \_SB.PCI0.SMB.Z00W)
Sleep(0x32)
}
Method(_Q34) {
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.BTAT, Local1)
Store(\_SB.WMID.BLTD, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
Method(_Q37) {
Store(0x37, P80H)
Notify(\_SB.PCI0.LPC0.ACAD, 0x80)
Sleep(0x03e8)
Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
Notify(\_PR.CPU0, 0x80)
If(LEqual(CPUS, 0x00)) {
Notify(\_PR.CPU1, 0x80)
}
}
Method(_Q38) {
Store(0x38, P80H)
Notify(\_SB.PCI0.LPC0.ACAD, 0x80)
Sleep(0x03e8)
Notify(\_SB.PCI0.LPC0.BAT1, 0x80)
Notify(\_PR.CPU0, 0x80)
If(LEqual(CPUS, 0x00)) {
Notify(\_PR.CPU1, 0x80)
}
}
Method(_Q4F) {
If(LEqual(\_SB.WMID.BAEF, One)) {
Store(0x01, Local1)
If(LEqual(\_SB.PCI0.LPC0.EC0.LANC, 0x01)) {
Store(0x00, Local1)
}
Store(\_SB.WMID.LANI, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(WMID, 0x80)
}
}
Method(_Q50) {
If(LEqual(\_SB.WMID.BAEF, One)) {
Store(0x00, Local1)
If(LEqual(\_SB.PCI0.LPC0.EC0.LCDS, 0x01)) {
Store(0x01, Local1)
}
Store(\_SB.WMID.LDOF, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(WMID, 0x80)
}
}
Method(_Q60) {
If(LEqual(\_SB.WMID.BAEF, 0x01)) {
Store(\_SB.PCI0.LPC0.EC0.WLAT, Local1)
Store(\_SB.WMID.WLSD, Local2)
Add(Local2, Local1, Local2)
Store(Local2, \_SB.WMID.NTDC)
Notify(\_SB.WMID, 0x80)
}
}
Method(_Q43) {
}
OperationRegion(CCLK, SystemIO, 0x8010, 0x04)
Field(CCLK, DWordAcc, NoLock, Preserve) {
, 1,
DUTY, 3,
THEN, 1,
Offset(0x1),
, 9,
TSTS, 1
}
Mutex(FAMX, 0)
Method(FANG, 1) {
Acquire(FAMX, 0xffff)
Store(Arg0, ERIB)
Store(ERBD, Local0)
Release(FAMX)
Return(Local0)
}
Method(FANW, 2) {
Acquire(FAMX, 0xffff)
Store(Arg0, ERIB)
Store(Arg1, ERBD)
Release(FAMX)
Return(Arg1)
}
Method(TUVR, 1) {
Return(0x03)
}
Method(THRO, 1) {
If(LEqual(Arg0, 0x00)) {
Return(THEN)
}
Else {
If(LEqual(Arg0, 0x01)) {
Return(DUTY)
}
Else {
If(LEqual(Arg0, 0x02)) {
Return(TTHR)
}
Else {
Return(0xff)
}
}
}
}
Method(CLCK, 1) {
If(LEqual(Arg0, 0x00)) {
Store(0x00, THEN)
}
Else {
Store(Arg0, DUTY)
Store(0x01, THEN)
}
Return(THEN)
}
}
Device(MIR) {
Name(_HID, 0x0001c515)
Method(_STA) {
If(PJID) {
Return(0x00)
}
Else {
Return(0x0f)
}
}
Method(_CRS) {
Name(BUF0, Buffer(0x0d) {0x47, 0x1, 0x60, 0xfd, 0x60,=
0xfd, 0x1, 0x4, 0x22, 0x10, 0x0, 0x79, 0x0 })
Return(BUF0)
}
Name(_PRS, Buffer(0x0d) {0x47, 0x1, 0x60, 0xfd, 0x60, 0xf=
d, 0x1, 0x4, 0x22, 0x10, 0x0, 0x79, 0x0 })
}
Device(ACAD) {
Name(_HID, "ACPI0003")
Name(_PCL, Package(0x01) {
\_SB,
})
Method(_PSR) {
If(ECOK()) {
Store(\_SB.PCI0.LPC0.EC0.ADPT, Local0)
If(UMAS) {
If(Local0) {
\_SB.PCI0.AGP.VGA.AFN4(0x01)
}
Else {
\_SB.PCI0.AGP.VGA.AFN4(0x02)
}
}
Return(Local0)
}
Return(0x01)
}
}
Device(BAT1) {
Name(_HID, 0x0a0cd041)
Name(_UID, 0x01)
Name(_PCL, Package(0x01) {
\_SB,
})
Name(PBIF, Package(0x0d) {
0x01,
0x19c8,
0x19c8,
0x01,
0x39d0,
0x0294,
0xc6,
0x0108,
0x0ec4,
"Primary\x20",
"",
"Lion",
"Acer",
})
Name(PBST, Package(0x04) {
0x01,
0xffffffff,
0xffffffff,
0x39d0,
})
Method(_STA) {
If(ECOK()) {
If(\_SB.PCI0.LPC0.EC0.BAL1) {
Sleep(0x14)
Return(0x1f)
}
Else {
Sleep(0x14)
Return(0x0f)
}
}
Else {
Sleep(0x14)
Return(0x1f)
}
}
Method(_BIF) {
If(ECOK()) {
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BDC0, Index(PBIF, 0x01, =
))
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BFC0, Index(PBIF, 0x02, =
))
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BDV0, Index(PBIF, 0x04, =
))
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BDC0, Local2)
Divide(Local2, 0x64, Local6, Local2)
Multiply(Local2, 0x05, Local3)
Store(Local3, Index(PBIF, 0x05, ))
Multiply(Local2, 0x03, Local4)
Store(Local4, Index(PBIF, 0x06, ))
If(LNot(LLess(OSYS, 0x40))) {
ToHexString(\_SB.PCI0.LPC0.EC0.BSN0, Local2)
Mid(Local2,0x02,0x04,Local3)
Store(Local3, Index(PBIF, 0x0a, ))
Sleep(0x14)
}
Store(\_SB.PCI0.LPC0.EC0.BATD, Index(PBIF, 0x09, =
))
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BTMF, Local1)
Sleep(0x14)
If(LEqual(Local1, 0x01)) {
Store("SANYO\x20", Index(PBIF, 0x0c, ))
}
Else {
If(LEqual(Local1, 0x02)) {
Store("SONY\x20", Index(PBIF, 0x0c, ))
}
Else {
If(LEqual(Local1, 0x04)) {
Store("PANASONIC\x20", Index(PBIF, 0x=
0c, ))
}
Else {
If(LEqual(Local1, 0x03)) {
Store("Simplo\x20", Index(PBIF, 0=
x0c, ))
}
Else {
Store("COMPAL\x20", Index(PBIF, 0=
x0c, ))
}
}
}
}
}
Return(PBIF)
}
Method(_BST) {
If(ECOK()) {
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BST0, Local0)
And(Local0, 0x07, Local0)
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.GAU0, Local2)
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BPV0, Local3)
Sleep(0x14)
Store(\_SB.PCI0.LPC0.EC0.BFC0, Local1)
If(Local2) {
Multiply(Local2, Local1, Local2)
Divide(Local2, 0x64, Local6, Local2)
If(Local6) {
Increment(Local2)
}
}
Store(\_SB.PCI0.LPC0.EC0.BAC0, Local1)
If(And(Local1, 0x8000, Local1)) {
Store(\_SB.PCI0.LPC0.EC0.BAC0, Local1)
Subtract(0xffff, Local1, Local1)
}
Else {
Store(0x00, Local1)
}
Store(Local0, Index(PBST, 0x00, ))
Store(Local1, Index(PBST, 0x01, ))
Store(Local2, Index(PBST, 0x02, ))
Store(Local3, Index(PBST, 0x03, ))
}
Return(PBST)
}
}
}
Device(P2P) {
Name(_ADR, 0x00140004)
Name(_PRW, Package(0x02) {
0x04,
0x05,
})
Method(_PRT) {
If(GPIC) {
Return(Package(0x01) {
Package(0x04) {
0x0001ffff,
0x00,
0x00,
0x14,
},
})
}
Else {
Return(Package(0x01) {
Package(0x04) {
0x0001ffff,
0x00,
\_SB.PCI0.LPC0.LNKE,
0x00,
},
})
}
}
}
Device(AGP) {
Name(_ADR, 0x00010000)
Method(_PRT) {
If(GPIC) {
Return(Package(0x02) {
Package(0x04) {
0x0005ffff,
0x00,
0x00,
0x12,
},
Package(0x04) {
0x0005ffff,
0x01,
0x00,
0x13,
},
})
}
Else {
Return(Package(0x02) {
Package(0x04) {
0x0005ffff,
0x00,
\_SB.PCI0.LPC0.LNKC,
0x00,
},
Package(0x04) {
0x0005ffff,
0x01,
\_SB.PCI0.LPC0.LNKD,
0x00,
},
})
}
}
Device(VGA) {
Name(_ADR, 0x00050000)
Method(_STA) {
Return(0x0f)
}
Name(ATIB, Buffer(0x0100) { })
Name(SWIT, 0x01)
Name(CRTA, 0x01)
Name(LCDA, 0x01)
Name(TVAA, 0x01)
Name(VLDF, 0x01)
OperationRegion(VIDS, PCI_Config, 0x00, 0xc8)
Field(VIDS, DWordAcc, NoLock, Preserve) {
VID0, 16,
DID0, 16
}
Name(_PSC, 0x00)
Method(_PS0) {
Store(0x00, _PSC)
}
Method(_PS1) {
Store(0x01, _PSC)
}
Method(_PS3) {
Store(0x03, _PSC)
}
Method(_DOS, 1) {
Store(And(Arg0, 0x03, ), SWIT)
}
Method(_DOD) {
Return(Package(0x03) {
0x00010100,
0x00010110,
0x0200,
})
}
Device(CRT) {
Method(_ADR) {
Return(0x0100)
}
}
Device(LCD) {
Method(_ADR) {
Return(0x0110)
}
Method(_BCL) {
Store(0xc0, P80H)
Return(Package(0x0c) {
0x64,
0x46,
0x0a,
0x14,
0x1e,
0x28,
0x32,
0x3c,
0x46,
0x50,
0x5a,
0x64,
})
}
Method(_BCM, 1) {
Store(0xc1, P80H)
Divide(Arg0, 0x0a, Local0, Local1)
Decrement(Local1)
Store(Local1, \_SB.PCI0.LPC0.EC0.BRTS)
}
Method(_BQC) {
Store(0xc2, P80H)
Multiply(\_SB.PCI0.LPC0.EC0.BRTS, 0x0a, Local0)
Add(Local0, 0x01, Local0)
Sleep(0x64)
Return(Local0)
}
}
Device(TV) {
Method(_ADR) {
Return(0x0200)
}
}
Method(ATIF, 2, Serialized) {
If(LEqual(Arg0, 0x00)) {
Return(AF00())
}
If(LEqual(Arg0, 0x01)) {
Return(AF01())
}
If(LEqual(Arg0, 0x02)) {
Return(AF02())
}
If(LEqual(Arg0, 0x03)) {
Return(AF03(DerefOf(Index(Arg1, 0x02, )), DerefOf=
(Index(Arg1, 0x04, ))))
}
Else {
CreateWordField(ATIB, 0x00, SSZE)
CreateWordField(ATIB, 0x02, VERN)
CreateDWordField(ATIB, 0x04, NMSK)
CreateDWordField(ATIB, 0x08, SFUN)
Store(0x00, SSZE)
Store(0x00, VERN)
Store(0x00, NMSK)
Store(0x00, SFUN)
Return(ATIB)
}
}
Method(AF00) {
Store(0xf0, P80H)
CreateWordField(ATIB, 0x00, SSZE)
CreateWordField(ATIB, 0x02, VERN)
CreateDWordField(ATIB, 0x04, NMSK)
CreateDWordField(ATIB, 0x08, SFUN)
Store(0x0c, SSZE)
Store(0x01, VERN)
If(CondRefOf(\_SB.PCI0.AGP.VGA.XTPX, Local4)) {
Store(0x11, NMSK)
}
Else {
Store(0x51, NMSK)
}
Store(NMSK, MSKN)
Store(0x07, SFUN)
Return(ATIB)
}
Name(NCOD, 0x81)
Method(AF01) {
Store(0xf1, P80H)
CreateWordField(ATIB, 0x00, SSZE)
CreateDWordField(ATIB, 0x02, VMSK)
CreateDWordField(ATIB, 0x06, FLGS)
Store(0x03, VMSK)
Store(0x0a, SSZE)
Store(0x01, FLGS)
Store(0x81, NCOD)
Return(ATIB)
}
Name(PSBR, Buffer(0x04) {0x0, 0x0, 0x0, 0x0 })
Name(MSKN, 0x00)
Name(SEXM, 0x00)
Name(STHG, 0x00)
Name(STHI, 0x00)
Name(SFPG, 0x00)
Name(SFPI, 0x00)
Name(SSPS, 0x00)
Name(SSDM, 0x0a)
Name(SCDY, 0x00)
Name(SACT, Buffer(0x06) {0x1, 0x2, 0x8, 0x3, 0x9, 0xa })
Method(AF02) {
Store(0xf2, P80H)
CreateBitField(PSBR, 0x00, PDSW)
CreateBitField(PSBR, 0x01, PEXM)
CreateBitField(PSBR, 0x02, PTHR)
CreateBitField(PSBR, 0x03, PFPS)
CreateBitField(PSBR, 0x04, PSPS)
CreateBitField(PSBR, 0x05, PDCC)
CreateBitField(PSBR, 0x06, PXPS)
CreateWordField(ATIB, 0x00, SSZE)
CreateDWordField(ATIB, 0x02, PSBI)
CreateByteField(ATIB, 0x06, EXPM)
CreateByteField(ATIB, 0x07, THRM)
CreateByteField(ATIB, 0x08, THID)
CreateByteField(ATIB, 0x09, FPWR)
CreateByteField(ATIB, 0x0a, FPID)
CreateByteField(ATIB, 0x0b, SPWR)
Store(0x0c, SSZE)
Store(PSBR, PSBI)
If(PDSW) {
Store(0x82, P80H)
Store(Zero, PDSW)
}
If(PEXM) {
Store(SEXM, EXPM)
Store(Zero, SEXM)
Store(Zero, PEXM)
}
If(PTHR) {
Store(STHG, THRM)
Store(STHI, THID)
Store(Zero, STHG)
Store(Zero, STHI)
Store(Zero, PTHR)
}
If(PFPS) {
Store(SFPG, FPWR)
Store(SFPI, FPWR)
Store(Zero, SFPG)
Store(Zero, SFPI)
Store(Zero, PFPS)
}
If(PSPS) {
Store(SSPS, SPWR)
Store(Zero, PSPS)
}
If(PXPS) {
Store(0xa2, P80H)
Store(Zero, PXPS)
}
Return(ATIB)
}
Method(AF03, 2) {
Store(0xf3, P80H)
CreateWordField(ATIB, 0x00, SSZE)
CreateWordField(ATIB, 0x02, SSDP)
CreateWordField(ATIB, 0x04, SCDP)
Store(Arg0, SSDP)
Store(Arg1, SCDP)
Name(NXTD, 0x06)
Name(CIDX, 0x06)
Store(SSDP, Local1)
And(Local1, 0x0b, Local1)
Store(SCDP, Local2)
If(CondRefOf(\_SB.LID._LID, Local4)) {
And(Local2, Not(0x01, ), Local2)
Or(Local2, \_SB.LID._LID(), Local2)
}
Else {
Or(Local2, 0x01, Local2)
}
Store(Local2, P80H)
Store(Zero, Local0)
While(LLess(Local0, SizeOf(SACT))) {
Store(DerefOf(Index(SACT, Local0, )), Local3)
If(LEqual(Local3, Local1)) {
Store(Local0, CIDX)
Store(SizeOf(SACT), Local0)
}
Else {
Increment(Local0)
}
}
Store(CIDX, Local0)
While(LLess(Local0, SizeOf(SACT))) {
Increment(Local0)
If(LEqual(Local0, SizeOf(SACT))) {
Store(0x00, Local0)
}
Store(DerefOf(Index(SACT, Local0, )), Local3)
If(LEqual(And(Local3, Local2, ), Local3)) {
Store(Local0, NXTD)
Store(SizeOf(SACT), Local0)
}
}
If(LEqual(NXTD, SizeOf(SACT))) {
Store(Zero, SSDP)
}
Else {
Store(NXTD, Local0)
Store(DerefOf(Index(SACT, Local0, )), Local3)
And(SSDP, Not(0x0b, ), SSDP)
Or(SSDP, Local3, SSDP)
}
Store(0x04, SSZE)
Store(SSDP, P80H)
Return(ATIB)
}
Method(AFN0, 0, Serialized) {
If(And(MSKN, 0x01, )) {
CreateBitField(PSBR, 0x00, PDSW)
Store(One, PDSW)
Notify(VGA, NCOD)
}
}
Method(AFN3, 2, Serialized) {
If(And(MSKN, 0x08, )) {
Store(Arg0, Local0)
Store(Local0, SFPI)
Store(Arg1, Local0)
Store(And(Local0, 0x03, Local0), SFPG)
CreateBitField(PSBR, 0x03, PFPS)
Store(One, PFPS)
Notify(VGA, NCOD)
}
}
Method(AFN4, 1, Serialized) {
If(And(MSKN, 0x10, )) {
Store(Arg0, Local0)
Store(SSPS, Local1)
Store(Local0, SSPS)
If(LEqual(Local0, Local1)) {
}
Else {
CreateBitField(PSBR, 0x04, PSPS)
Store(One, PSPS)
Notify(VGA, NCOD)
}
}
}
Method(AFN5, 0, Serialized) {
If(And(MSKN, 0x20, )) {
CreateBitField(PSBR, 0x05, PDCC)
Store(One, PDCC)
Notify(VGA, NCOD)
}
}
Method(AFN6, 0, Serialized) {
If(And(MSKN, 0x40, )) {
CreateBitField(PSBR, 0x06, PXPS)
Store(One, PXPS)
Notify(VGA, NCOD)
}
}
}
}
Scope(\_SB.PCI0.AGP.VGA) {
Name(ATPB, Buffer(0x0100) { })
Name(DSID, 0xffffffff)
Method(XTPX, 2, Serialized) {
If(LEqual(Arg0, 0x00)) {
Return(PX00())
}
If(LEqual(Arg0, 0x01)) {
Return(PX01())
}
If(LEqual(Arg0, 0x02)) {
Return(PX02(DerefOf(Index(Arg1, 0x02, ))))
}
If(LEqual(Arg0, 0x03)) {
Return(PX03(DerefOf(Index(Arg1, 0x02, ))))
}
CreateWordField(ATPB, 0x00, SSZE)
CreateWordField(ATPB, 0x02, VERN)
CreateDWordField(ATPB, 0x04, SFUN)
Store(0x00, SSZE)
Store(0x00, VERN)
Store(0x00, SFUN)
Return(ATPB)
}
Method(PX00) {
Store(0xe0, P80H)
CreateWordField(ATPB, 0x00, SSZE)
CreateWordField(ATPB, 0x02, VERN)
CreateDWordField(ATPB, 0x04, SFUN)
Store(0x08, SSZE)
Store(0x01, VERN)
Store(0x07, SFUN)
Store(\_SB.PCI0.PB2.DGFX.SVID, Local0)
If(LNot(LEqual(Local0, 0xffffffff))) {
Store(Local0, \_SB.PCI0.AGP.VGA.DSID)
}
Return(ATPB)
}
Method(PX01) {
Store(0xe1, P80H)
CreateWordField(ATPB, 0x00, SSZE)
CreateDWordField(ATPB, 0x02, VMSK)
CreateDWordField(ATPB, 0x06, FLGS)
Store(0x0a, SSZE)
Store(0x0f, VMSK)
Store(0x0f, FLGS)
Return(ATPB)
}
Method(PX02, 1) {
CreateWordField(ATPB, 0x00, SSZE)
CreateByteField(ATPB, 0x02, PWST)
Store(0x03, SSZE)
And(Arg0, 0x01, PWST)
Name(HPOK, 0x00)
Store(0x01, \_SB.PCI0.SMB.G72F)
Store(0x01, \_SB.PCI0.SMB.G36F)
If(PWST) {
Store(0x11e2, P80H)
Store(One, \_SB.PCI0.SMB.G72O)
Store(Zero, \_SB.PCI0.SMB.G72E)
Sleep(0x32)
Store(One, \_SB.PCI0.SMB.G36O)
Store(Zero, \_SB.PCI0.SMB.G36E)
Store(0x12e2, P80H)
Store(0x00, HPOK)
Sleep(0x64)
Sleep(0x64)
\_SB.PCI0.XPTR(0x02, 0x01)
Sleep(0x14)
Store(0x00, Local2)
While(LLess(Local2, 0x0f)) {
Store(0x08, \_SB.PCI0.PB2.SLST)
Store(0x01, Local4)
Store(0xc8, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LAnd(LNot(LLess(Local6, 0x10)), LNot(LEqua=
l(Local6, 0x7f)))) {
Store(0x00, Local4)
}
Else {
Sleep(0x05)
Decrement(Local5)
}
}
If(LNot(Local4)) {
Store(\_SB.PCI0.PB2.XPDL(), Local5)
If(Local5) {
\_SB.PCI0.PB2.XPRT()
Sleep(0x05)
Increment(Local2)
}
Else {
Store(0x10, \_SB.PCI0.LPC0.INFO)
Store(0x87, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
If(LEqual(\_SB.PCI0.PB2.XPR2(), Ones)) {
Store(0x01, HPOK)
Store(0x10, Local2)
}
Else {
Store(0x00, HPOK)
Store(0x10, Local2)
}
}
}
Else {
Store(0x10, Local2)
}
}
If(LNot(HPOK)) {
Store(0x13e2, P80H)
Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
Sleep(0x0a)
Store(0x01, Local4)
Store(0x05, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LNot(LGreater(Local6, 0x04))) {
Store(0x00, Local4)
}
Else {
Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
Sleep(0x05)
Decrement(Local5)
}
}
\_SB.PCI0.XPTR(0x02, 0x00)
}
Store(0x14e2, P80H)
}
Else {
Store(0x02e2, P80H)
Store(Zero, \_SB.PCI0.SMB.G36O)
Store(Zero, \_SB.PCI0.SMB.G36E)
Store(Zero, \_SB.PCI0.SMB.G72O)
Store(Zero, \_SB.PCI0.SMB.G72E)
Store(0x03e2, P80H)
Store(0x08, \_SB.PCI0.PB2.SLST)
Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
Sleep(0x0a)
Store(0x01, Local4)
Store(0x05, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB2.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LNot(LGreater(Local6, 0x04))) {
Store(0x00, Local4)
}
Else {
Store(\_SB.PCI0.PB2.DGFX.DVID, Local7)
Sleep(0x05)
Decrement(Local5)
}
}
\_SB.PCI0.XPTR(0x02, 0x00)
Store(0x02, HPOK)
Store(0x04e2, P80H)
}
If(HPOK) {
If(LAnd(LEqual(HPOK, 0x01), LNot(LEqual(\_SB.PCI0.AGP=
=2EVGA.DSID, 0xffffffff)))) {
Store(\_SB.PCI0.AGP.VGA.DSID, Local7)
Store(Local7, \_SB.PCI0.PB2.DGFX.SMID)
Sleep(0x0a)
}
Notify(\_SB.PCI0.PB2, 0x00)
}
}
Method(PX03, 1) {
CreateWordField(ATPB, 0x00, SSZE)
CreateWordField(ATPB, 0x02, DPSW)
Store(0x04, SSZE)
And(Arg0, 0x01, DPSW)
If(DPSW) {
Store(0x02e3, P80H)
Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
Store(0x02, \_SB.PCI0.LPC0.INFO)
Store(0x85, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Release(\_SB.PCI0.LPC0.PSMX)
}
Else {
Store(0x01e3, P80H)
Acquire(\_SB.PCI0.LPC0.PSMX, 0xffff)
Store(0x01, \_SB.PCI0.LPC0.INFO)
Store(0x85, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Release(\_SB.PCI0.LPC0.PSMX)
}
}
}
Scope(\_SB.PCI0.AGP.VGA) {
OperationRegion(REVD, SystemMemory, 0xafedde6c, 0x00000008)
Field(REVD, AnyAcc, NoLock, Preserve) {
SROM, 32,
VROM, 32
}
Name(TVGA, Buffer(0x0004) {0x0 })
Method(XTRM, 2, Serialized) {
Add(Arg0, Arg1, Local0)
If(LNot(LGreater(Local0, SROM))) {
Multiply(Arg1, 0x08, Local1)
Multiply(Arg0, 0x08, Local2)
Store(VROM, TVGA)
CreateField(TVGA, Local2, Local1, TEMP)
Name(RETB, Buffer(Arg1) { })
Store(TEMP, RETB)
Return(RETB)
}
Else {
If(LLess(Arg0, SROM)) {
Subtract(SROM, Arg0, Local3)
Multiply(Local3, 0x08, Local1)
Multiply(Arg0, 0x08, Local2)
Store(VROM, TVGA)
CreateField(TVGA, Local2, Local1, TEM)
Name(RETC, Buffer(Local3) { })
Store(TEM, RETC)
Return(RETC)
}
Else {
Name(RETD, Buffer(0x01) { })
Return(RETD)
}
}
}
}
}
}
Scope(\_GPE) {
Method(_L04) {
Notify(\_SB.PCI0.P2P, 0x02)
}
Method(_L0B) {
Notify(\_SB.PCI0.OHC0, 0x02)
Notify(\_SB.PCI0.OHC1, 0x02)
Notify(\_SB.PCI0.OHC2, 0x02)
Notify(\_SB.PCI0.OHC3, 0x02)
Notify(\_SB.PCI0.OHC4, 0x02)
Notify(\_SB.PCI0.EHC0, 0x02)
Notify(\_SB.PCI0.EHC1, 0x02)
}
Method(_L0E) {
If(LEqual(\_SB.WMID.BGEF, 0x01)) {
If(LNot(LEqual(CRTS, 0x01))) {
Store(0x01, CRTS)
Store(\_SB.WMID.VAPI, Local0)
}
Else {
Store(0x00, CRTS)
Store(\_SB.WMID.VAPO, Local0)
}
Store(Local0, \_SB.WMID.NTDV)
Notify(\_SB.WMID, 0x82)
}
}
Method(_L19) {
Store(\_SB.PCI0.SMB.GM4C, Local0)
Not(Local0, Local0)
And(Local0, 0x01, \_SB.PCI0.SMB.GM4C)
Store(0x01, \_SB.PCI0.SMB.GM4S)
If(LAnd(LNot(LLess(\_SB.TPOS, 0x04)), LLess(\_SB.TPOS, 0x40))) {
Store(And(\_SB.PCI0.SMB.GM4C, 0x01, ), Local0)
Store(Local0, \_SB.PCI0.LPC0.INFO)
Store(0x8f, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
}
Notify(\_SB.LID, 0x80)
}
Mutex(Z013, 0)
Method(_L1A) {
Name(HPOK, 0x00)
Acquire(Z013, 0xffff)
If(\_SB.PCI0.SMB.GM5C) {
Sleep(0x14)
Store(\_SB.PCI0.LPC0.RGPM(), Local0)
If(And(Local0, 0x20, )) {
Store(0x00, \_SB.PCI0.SMB.GM5C)
Store("HotPlug\x3a04\x3a\x20Removal\x20Event", Debug)
Store(0x08, \_SB.PCI0.PB4.SLST)
Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
Sleep(0x0a)
Store(0x01, Local4)
Store(0x05, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LNot(LGreater(Local6, 0x04))) {
Store(0x00, Local4)
}
Else {
Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
Sleep(0x05)
Decrement(Local5)
}
}
\_SB.PCI0.XPTR(0x04, 0x00)
\_SB.PCI0.PB4.XPLP(0x00)
Sleep(0x1388)
Store(0x01, HPOK)
}
}
Else {
Sleep(0x14)
Store(\_SB.PCI0.LPC0.RGPM(), Local0)
If(LNot(And(Local0, 0x20, ))) {
Store(0x01, \_SB.PCI0.SMB.GM5C)
Store("HotPlug\x3a04\x3a\x20Insertion\x20Event", Debug)
Store(0x00, HPOK)
\_SB.PCI0.PB4.XPLP(0x01)
Sleep(0xc8)
\_SB.PCI0.XPTR(0x04, 0x01)
Sleep(0x14)
Store(0x00, Local2)
While(LLess(Local2, 0x0f)) {
Store(0x08, \_SB.PCI0.PB4.SLST)
Store(0x01, Local4)
Store(0xc8, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LAnd(LNot(LLess(Local6, 0x10)), LNot(LEqual(Lo=
cal6, 0x7f)))) {
Store("HotPlug\x3a04\x3a\x20TrainingState\x3d=
0x10", Debug)
Store(0x00, Local4)
}
Else {
Sleep(0x05)
Decrement(Local5)
}
}
If(LNot(Local4)) {
Store("HotPlug\x3a04\x3a\x20Check\x20VC\x20Negoti=
ation\x20Pending", Debug)
Store(\_SB.PCI0.PB4.XPDL(), Local5)
If(Local5) {
Store("HotPlug\x3a04\x3a\x20Retraining\x20Lin=
k", Debug)
\_SB.PCI0.PB4.XPRT()
Sleep(0x05)
Increment(Local2)
}
Else {
Store("HotPlug\x3a04\x3a\x20Device\x20OK", De=
bug)
Store(0x20, \_SB.PCI0.LPC0.INFO)
Store(0x87, \_SB.PCI0.LPC0.BCMD)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
If(LEqual(\_SB.PCI0.PB4.XPR2(), Ones)) {
Store(0x01, HPOK)
Store(0x10, Local2)
}
Else {
Store("HotPlug\x3a04\x3a\x20Common\x20Clo=
ck\x20Retraining\x20Failed", Debug)
Store(0x00, HPOK)
Store(0x10, Local2)
}
}
}
Else {
Store("HotPlug\x3a04\x3a\x20TrainingState\x20Time=
out", Debug)
Store(0x10, Local2)
}
}
If(LNot(HPOK)) {
Store("HotPlug\x3a04\x3a\x20Insertion\x20Failed\x3a\x=
20Disable\x20Training\x20\x26\x20PowerDown", Debug)
Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
Sleep(0x0a)
Store(0x01, Local4)
Store(0x05, Local5)
While(LAnd(Local4, Local5)) {
Store(\_SB.PCI0.PB4.XPRD(0xa5), Local6)
And(Local6, 0x7f, Local6)
If(LNot(LGreater(Local6, 0x04))) {
Store(0x00, Local4)
}
Else {
Store(\_SB.PCI0.PB4.NCRD.DVID, Local7)
Sleep(0x05)
Decrement(Local5)
}
}
\_SB.PCI0.XPTR(0x04, 0x00)
\_SB.PCI0.PB4.XPLP(0x00)
}
}
}
If(HPOK) {
Notify(\_SB.PCI0.PB4, 0x00)
}
Release(Z013)
}
Method(_L1B) {
Notify(\_SB.PCI0.HDA, 0x02)
}
Method(_L1C) {
Name(HPOK, 0x00)
Store(0xca, P80H)
If(LNot(LEqual(PJID, 0x03))) {
If(LOr(LEqual(EBID, 0x03), LNot(LEqual(PJID, 0x01)))) {
If(\_SB.PCI0.SMB.GM6C) {
Store(0xcb, P80H)
Sleep(0x14)
Store(\_SB.PCI0.LPC0.RGPM(), Local0)
If(And(Local0, 0x40, )) {
Store(0x00, \_SB.PCI0.SMB.GM6C)
Store(0x08, \_SB.PCI0.PB9.SLST)
Store(0x01, HPOK)
}
}
Else {
Store(0xcc, P80H)
Sleep(0x14)
Store(\_SB.PCI0.LPC0.RGPM(), Local0)
If(LNot(And(Local0, 0x40, ))) {
Store(0x01, \_SB.PCI0.SMB.GM6C)
Store(0x08, \_SB.PCI0.PB9.SLST)
Store(0x01, HPOK)
}
}
If(HPOK) {
If(And(\_SB.PCI0.PB9.SLST, 0x40, )) {
Store(0xcd, P80H)
\_SB.PCI0.LPC0.PHSS(0x5a)
Stall(0xff)
}
Notify(\_SB.PCI0.PB9, 0x00)
}
}
}
}
}
Scope(_TZ) {
Name(DTMP, 0x0bba)
Name(DAC0, 0x0ca0)
Name(DPSV, 0x0e30)
Name(TBSE, 0x0aac)
Name(DCRT, 0x127c)
ThermalZone(THRM) {
Method(_TMP) {
If(\_SB.PCI0.LPC0.ECOK()) {
Multiply(\_SB.PCI0.LPC0.EC0.CTMP, 0x0a, Local0)
Add(Local0, 0x0aac, Local0)
Return(Local0)
}
Return(DTMP)
}
Method(_AC0) {
Return(DAC0)
}
Method(_CRT) {
Return(DCRT)
}
Method(_PSV) {
Return(DPSV)
}
Method(_PSL, 0, Serialized) {
If(CPUS) {
Return(Package(0x01) {
\_PR.CPU0,
})
}
Else {
Return(Package(0x02) {
\_PR.CPU0,
\_PR.CPU1,
})
}
}
Name(_TC1, 0x02)
Name(_TC2, 0x05)
Name(_TSP, 0x012c)
}
ThermalZone(Z014) {
Method(_TMP) {
If(\_SB.PCI0.LPC0.ECOK()) {
Multiply(\_SB.PCI0.LPC0.EC0.SKTA, 0x0a, Local0)
Add(Local0, 0x0aac, Local0)
Return(Local0)
}
Return(DTMP)
}
Method(_AC0) {
Return(DAC0)
}
Method(_CRT) {
Return(DCRT)
}
Method(_PSV) {
Return(DPSV)
}
Method(_PSL, 0, Serialized) {
If(CPUS) {
Return(Package(0x01) {
\_PR.CPU0,
})
}
Else {
Return(Package(0x02) {
\_PR.CPU0,
\_PR.CPU1,
})
}
}
Name(_TC1, 0x02)
Name(_TC2, 0x05)
Name(_TSP, 0x012c)
}
}
Scope(\_SB.PCI0.SMB) {
Mutex(SBX0, 0)
OperationRegion(SMB1, SystemIO, 0x8050, 0x10)
Field(SMB1, ByteAcc, NoLock, Preserve) {
HSTS, 8,
SLVS, 8,
HCNT, 8,
HCMD, 8,
HADD, 8,
DAT0, 8,
DAT1, 8,
BLKD, 8,
PECR, 8,
CAUX, 8,
ASFS, 8,
SMK0, 8,
SMK1, 8,
SLMC, 8,
RADD, 8,
SADD, 8
}
Method(SBI) {
Store(Package(0x02) {
0x10,
0x00,
}, Local0)
Store(Buffer(0x05) {0x10, 0x20, 0x3, 0xa, 0x0 }, Index(Local0, 0x=
01, ))
Return(Local0)
}
Method(SWBD, 1) {
Store(Arg0, Local0)
Store(0x00, Local2)
Store(HSTS, Local3)
Store(And(Local3, 0x80, ), Local1)
While(LNot(LEqual(Local1, 0x80))) {
If(LLess(Local0, 0x0a)) {
Store(0x18, Local2)
Store(0x00, Local1)
}
Else {
Sleep(0x0a)
Subtract(Local0, 0x0a, Local0)
Store(HSTS, Local3)
Store(And(Local3, 0x80, ), Local1)
}
}
If(LNot(LEqual(Local2, 0x18))) {
Store(And(HSTS, 0x1c, ), Local1)
If(Local1) {
Store(0x07, Local2)
}
}
Return(Local2)
}
Method(SWTC, 1) {
Store(Arg0, Local0)
Store(0x07, Local2)
Store(0x01, Local1)
While(LEqual(Local1, 0x01)) {
Store(And(HSTS, 0x1f, ), Local3)
If(LNot(LEqual(Local3, 0x00))) {
If(LEqual(Local3, 0x01)) {
If(LLess(Local0, 0x0a)) {
Store(0x18, Local2)
Store(0x00, Local1)
}
Else {
Sleep(0x0a)
Subtract(Local0, 0x0a, Local0)
}
}
Else {
Store(0x07, Local2)
Store(0x00, Local1)
}
}
Else {
Store(0x00, Local2)
Store(0x00, Local1)
}
}
Store(Or(HSTS, 0x1f, ), HSTS)
Return(Local2)
}
Method(SBR, 3) {
Store(Package(0x22) {
0x07,
0x00,
0x00,
}, Local0)
Store(And(Arg0, 0x5f, ), Local4)
If(LNot(LEqual(Local4, 0x03))) {
If(LNot(LEqual(Local4, 0x05))) {
If(LNot(LEqual(Local4, 0x07))) {
If(LNot(LEqual(Local4, 0x09))) {
If(LNot(LEqual(Local4, 0x0b))) {
Store(0x19, Index(Local0, 0x00, ))
Return(Local0)
}
}
}
}
}
If(LEqual(Acquire(SBX0, 0xffff), 0x00)) {
Store(Or(ShiftLeft(Arg1, 0x01, ), 0x01, ), HADD)
Store(Arg2, HCMD)
Store(Or(HSTS, 0x1f, ), HSTS)
Store(And(Arg0, 0xa0, ), Local1)
Store(Or(And(HCNT, 0x5f, ), Local1, ), HCNT)
If(LEqual(Local4, 0x03)) {
Store(Or(And(HCNT, 0xa0, ), 0x40, ), HCNT)
}
If(LEqual(Local4, 0x05)) {
Store(Or(And(HCNT, 0xa0, ), 0x44, ), HCNT)
}
If(LEqual(Local4, 0x07)) {
Store(Or(And(HCNT, 0xa0, ), 0x48, ), HCNT)
}
If(LEqual(Local4, 0x09)) {
Store(Or(And(HCNT, 0xa0, ), 0x4c, ), HCNT)
}
If(LEqual(Local4, 0x0b)) {
Store(Or(HSTS, 0x80, ), HSTS)
Store(0x00, DAT0)
Store(Or(And(HCNT, 0xa0, ), 0x54, ), HCNT)
}
Store(SWTC(0x03e8), Local1)
Store(Local1, Index(Local0, 0x00, ))
If(LEqual(Local1, 0x00)) {
If(LEqual(Local4, 0x05)) {
Store(0x01, Index(Local0, 0x01, ))
Store(DAT0, Index(Local0, 0x02, ))
}
If(LEqual(Local4, 0x07)) {
Store(0x01, Index(Local0, 0x01, ))
Store(DAT0, Index(Local0, 0x02, ))
}
If(LEqual(Local4, 0x09)) {
Store(0x02, Index(Local0, 0x01, ))
Store(DAT1, Local2)
ShiftLeft(Local2, 0x08, Local2)
Add(Local2, DAT0, Local2)
Store(Local2, Index(Local0, 0x02, ))
}
If(LEqual(Local4, 0x0b)) {
Store(SWBD(0x01f4), Local1)
If(LNot(LEqual(Local1, 0x00))) {
Store(Local1, Index(Local0, 0x00, ))
}
Else {
Store(DAT0, Index(Local0, 0x01, ))
Store(DAT0, Local1)
Store(HCNT, Local2)
Store(0x00, Local2)
While(LLess(Local2, Local1)) {
Add(0x02, Local2, Local3)
Store(BLKD, Index(Local0, Local3, ))
Add(0x01, Local2, Local2)
}
Store(Or(HSTS, 0x80, ), HSTS)
}
}
}
Store(And(HCNT, 0x5f, ), HCNT)
Release(SBX0)
}
Return(Local0)
}
Method(SBW, 5) {
Store(Package(0x01) {
0x07,
}, Local0)
Store(And(Arg0, 0x5f, ), Local4)
If(LNot(LEqual(Local4, 0x02))) {
If(LNot(LEqual(Local4, 0x04))) {
If(LNot(LEqual(Local4, 0x06))) {
If(LNot(LEqual(Local4, 0x08))) {
If(LNot(LEqual(Local4, 0x0a))) {
Store(0x19, Index(Local0, 0x00, ))
Return(Local0)
}
}
}
}
}
If(LEqual(Acquire(SBX0, 0xffff), 0x00)) {
Store(ShiftLeft(Arg1, 0x01, ), HADD)
Store(Arg2, HCMD)
Store(Or(HSTS, 0x1f, ), HSTS)
Store(And(Arg0, 0xa0, ), Local1)
Store(Or(And(HCNT, 0x5f, ), Local1, ), HCNT)
If(LEqual(Local4, 0x02)) {
Store(Or(And(HCNT, 0xa0, ), 0x40, ), HCNT)
}
If(LEqual(Local4, 0x04)) {
Store(Or(And(HCNT, 0xa0, ), 0x44, ), HCNT)
}
If(LEqual(Local4, 0x06)) {
Store(Arg4, DAT0)
Store(Or(And(HCNT, 0xa0, ), 0x48, ), HCNT)
}
If(LEqual(Local4, 0x08)) {
And(Arg4, 0xff, DAT0)
ShiftRight(Arg4, 0x08, DAT1)
Store(Or(And(HCNT, 0xa0, ), 0x4c, ), HCNT)
}
If(LEqual(Local4, 0x0a)) {
Store(Or(HSTS, 0x80, ), HSTS)
Store(HCNT, Local1)
Store(Arg3, DAT0)
Store(0x00, Local2)
While(LLess(Local2, Arg3)) {
Store(Index(Arg4, Local2, ), BLKD)
Add(0x01, Local2, Local2)
}
Store(Or(And(HCNT, 0xa0, ), 0x54, ), HCNT)
}
Store(SWTC(0x03e8), Index(Local0, 0x00, ))
Store(And(HCNT, 0x5f, ), HCNT)
Release(SBX0)
}
Return(Local0)
}
}
Scope(\_SB.PCI0.SMB) {
Name(ASD, Buffer(0x04) {0xff, 0xff, 0xff, 0xff })
Device(OW00) {
Name(_HID, "MGMT201")
Name(_UID, 0x02010300)
Method(_STA) {
Return(ASFE)
}
Method(INFO) {
Name(BUFF, Buffer(0x1a) {0x2, 0x10, 0x1, 0x3, 0x0, 0x4, 0x1, =
0x0, 0x0, 0x0, 0x1, 0x2, 0x0, 0x0, 0x0, 0x1, 0x3, 0x0, 0x0, 0x0, 0x0, 0x4=
, 0x0, 0x0, 0x0, 0x1 })
Store(WTQ(), Local0)
Store(Local0, Index(BUFF, 0x14, ))
Return(BUFF)
}
Method(WTV) {
Return(0x80000000)
}
Method(WTR) {
}
Method(WTQ) {
Store(0xaf, \_SB.PCI0.LPC0.BCMD)
Store(0x02, \_SB.PCI0.LPC0.DID)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Return(\_SB.PCI0.LPC0.INFO)
}
Method(WTC, 1) {
Store(0x00, Local1)
Store(0x01, Local2)
While(LNot(LEqual(Local2, 0xff))) {
Store(Index(\_SB.PCI0.SMB.ASD, Local1, ), Local2)
If(LNot(LEqual(Local2, 0xff))) {
STOP(Local2)
STRT(Local2, Arg0)
Add(Local1, 0x01, Local1)
}
}
}
Method(WAQ) {
Return(0x01)
}
Method(WAC, 1) {
If(LEqual(Arg0, 0x00)) {
Store(0x00, Local1)
Store(0x01, Local2)
While(LNot(LEqual(Local2, 0xff))) {
Store(Index(\_SB.PCI0.SMB.ASD, Local1, ), Local2)
If(LNot(LEqual(Local2, 0xff))) {
STOP(Local2)
Add(Local1, 0x01, Local1)
}
}
}
}
Name(MSG, Buffer(0x20) { })
Method(STRT, 2) {
Store(0x13, Index(MSG, 0x00, ))
Store(0x10, Index(MSG, 0x01, ))
Store(And(Arg1, 0xff, ), Index(MSG, 0x02, ))
Store(ShiftRight(Arg1, 0x08, ), Index(MSG, 0x03, ))
Store(0x20, Index(MSG, 0x04, ))
Store(0x6f, Index(MSG, 0x05, ))
Store(0x10, Index(MSG, 0x06, ))
Store(0x68, Index(MSG, 0x07, ))
Store(0x10, Index(MSG, 0x08, ))
Store(0xff, Index(MSG, 0x09, ))
Store(0xff, Index(MSG, 0x0a, ))
Store(0x23, Index(MSG, 0x0b, ))
Store(0x00, Index(MSG, 0x0c, ))
\_SB.PCI0.SMB.SBW(0x0a, Arg0, 0x02, 0x0d, MSG)
}
Method(STOP, 1) {
Store(0x14, Index(MSG, 0x00, ))
Store(0x10, Index(MSG, 0x01, ))
\_SB.PCI0.SMB.SBW(0x0a, Arg0, 0x02, 0x02, MSG)
}
}
Device(OW01) {
Name(_HID, "MGMT201")
Name(_UID, 0x02010400)
Method(_STA) {
Return(ASFE)
}
Method(INFO) {
Name(BUFF, Buffer(0x1a) {0x2, 0x10, 0x1, 0x4, 0x0, 0x4, 0x1, =
0x0, 0x0, 0x0, 0x1, 0x2, 0x0, 0x0, 0x0, 0x1, 0x3, 0x0, 0x0, 0x0, 0x0, 0x4=
, 0x0, 0x0, 0x0, 0x1 })
Store(WTQ(), Local0)
Store(Local0, Index(BUFF, 0x14, ))
Return(BUFF)
}
Method(WTV) {
Return(\_SB.PCI0.SMB.OW00.WTV())
}
Method(WTR) {
Return(\_SB.PCI0.SMB.OW00.WTR())
}
Method(WTQ) {
Return(\_SB.PCI0.SMB.OW00.WTQ())
}
Method(WTC, 1) {
Return(\_SB.PCI0.SMB.OW00.WTC(Arg0))
}
Method(WAQ) {
Return(\_SB.PCI0.SMB.OW00.WAQ())
}
Method(WAC, 1) {
Return(\_SB.PCI0.SMB.OW00.WAC(Arg0))
}
}
}
Scope(\_SB) {
Name(ASFE, 0x00)
Device(ASF) {
Name(_HID, "ASF0001")
Method(_STA) {
Return(ASFE)
}
Method(GPWT) {
Store(0xaf, \_SB.PCI0.LPC0.BCMD)
Store(0x01, \_SB.PCI0.LPC0.DID)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
Return(\_SB.PCI0.LPC0.INFO)
}
Method(SPWT, 1) {
Store(0xaf, \_SB.PCI0.LPC0.BCMD)
Store(0x02, \_SB.PCI0.LPC0.DID)
Store(Arg0, \_SB.PCI0.LPC0.INFO)
Store(Zero, \_SB.PCI0.LPC0.SMIC)
}
}
}
}
/*
SLIC: Length=3D374, Revision=3D1, Checksum=3D158,
OEMID=3DACRSYS, OEM Table ID=3DACRPRDCT, OEM Revision=3D0x6040000,
Creator ID=3DLOHR, Creator Revision=3D0x0
*/
/*
SSDT: Length=3D692, Revision=3D1, Checksum=3D43,
OEMID=3DPTLTD, OEM Table ID=3DPOWERNOW, OEM Revision=3D0x6040000,
Creator ID=3D LTP, Creator Revision=3D0x1
*/
/*
APIC: Length=3D94, Revision=3D1, Checksum=3D62,
OEMID=3DPTLTD, OEM Table ID=3D APIC, OEM Revision=3D0x6040000,
Creator ID=3D LTP, Creator Revision=3D0x0
*/
/*
MCFG: Length=3D60, Revision=3D1, Checksum=3D94,
OEMID=3DPTLTD, OEM Table ID=3D MCFG, OEM Revision=3D0x6040000,
Creator ID=3D LTP, Creator Revision=3D0x0
*/
/*
HPET: Length=3D56, Revision=3D1, Checksum=3D154,
OEMID=3DPTLTD, OEM Table ID=3DHPETTBL, OEM Revision=3D0x6040000,
Creator ID=3D LTP, Creator Revision=3D0x1
*/
/*
ASF!: Length=3D299, Revision=3D32, Checksum=3D75,
OEMID=3D DMA, OEM Table ID=3DAMDTBL, OEM Revision=3D0x6040000,
Creator ID=3DPTL, Creator Revision=3D0x1
*/
--------------020902030803040906090409
Content-Type: text/plain;
name="acer5530.dmesg"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="acer5530.dmesg"
Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008, 2009
The NetBSD Foundation, Inc. All rights reserved.
Copyright (c) 1982, 1986, 1989, 1991, 1993
The Regents of the University of California. All rights reserved.
NetBSD 5.99.16 (MONOLITHAMD64) #1: Fri Sep 11 21:45:24 EEST 2009
root%maailma.local@localhost:/local/scratch/build/nbsd-current/amd64/obj/sys/arch/amd64/compile/MONOLITHAMD64
total memory = 2814 MB
avail memory = 2714 MB
timecounter: Timecounters tick every 10.000 msec
timecounter: Timecounter "i8254" frequency 1193182 Hz quality 100
Acer Aspire 5530 (V1.11 )
mainbus0 (root)
cpu0 at mainbus0 apid 0: AMD 686-class, 1900MHz, id 0x200f31
cpu1 at mainbus0 apid 1: AMD 686-class, 1900MHz, id 0x200f31
ioapic0 at mainbus0 apid 2: pa 0xfec00000, version 21, 24 pins
acpi0 at mainbus0: Intel ACPICA 20090730
acpi0: X/RSDT: OemId <ACRSYS,ACRPRDCT,06040000>, AslId < LTP,00000000>
acpi0: SCI interrupting at int 9
acpi0: fixed-feature power button present
timecounter: Timecounter "ACPI-Fast" frequency 3579545 Hz quality 1000
ACPI-Fast 32-bit timer
acpibut0 at acpi0 (PWRB, PNP0C0C): ACPI Power Button
acpibut1 at acpi0 (SLPB, PNP0C0E): ACPI Sleep Button
acpilid0 at acpi0 (LID, PNP0C0D): ACPI Lid Switch
WMID (PNP0C14) at acpi0 not configured
pcppi1 at acpi0 (SPKR, PNP0800): io 0x61
sysbeep0 at pcppi1
attimer1 at acpi0 (TIME, PNP0100): io 0x40-0x43 irq 0
pckbc1 at acpi0 (KBC0, PNP0303) (kbd port): io 0x60,0x64 irq 1
pckbc2 at acpi0 (MSE0, PNP0F13) (aux port): irq 12
hpet0 at acpi0 (HPET, PNP0103): mem 0xfed00000-0xfed003ff
timecounter: Timecounter "hpet0" frequency 14282292 Hz quality 2000
acpiec0 at acpi0 (EC0, PNP0C09): io 0x62,0x66
MIR (ENE0100) at acpi0 not configured
acpiacad0 at acpi0 (ACAD, ACPI0003): ACPI AC Adapter
acpibat0 at acpi0 (BAT1, PNP0C0A-1): ACPI Battery (Control Method)
ACPI Warning for \_SB_.PCI0.LPC0.BAT1._BIF: Converted Buffer to expected
String at index 9 (20090730/nsrepair-215)
acpibat0: battery info: SANYO , Lion, AS07B31 0098
acpitz0 at acpi0 (THRM): passive 42.0C, passive cooling
acpitz1 at acpi0 (Z014): passive 0.0C, passive cooling
attimer1: attached to pcppi1
pckbd0 at pckbc1 (kbd slot)
pckbc1: using irq 1 for kbd slot
wskbd0 at pckbd0: console keyboard
pms0 at pckbc1 (aux slot)
pckbc1: using irq 12 for aux slot
wsmouse0 at pms0 mux 0
pci0 at mainbus0 bus 0: configuration mode 1
pci0: i/o space, memory space enabled, rd/line, rd/mult, wr/inv ok
pchb0 at pci0 dev 0 function 0: vendor 0x1022 product 0x9600 (rev. 0x00)
ppb0 at pci0 dev 1 function 0: vendor 0x1025 product 0x9602 (rev. 0x00)
pci1 at ppb0 bus 1
pci1: i/o space, memory space enabled
vga0 at pci1 dev 5 function 0: vendor 0x1002 product 0x9612 (rev. 0x00)
wsdisplay0 at vga0 kbdmux 1: console (80x25, vt100 emulation), using wskbd0
wsmux1: connecting to wsdisplay0
radeondrm0 at vga0: ATI Radeon HD 3200 Graphics
radeondrm0: Initialized radeon 1.29.0 20080613
azalia0 at pci1 dev 5 function 1: Generic High Definition Audio Controller
azalia0: interrupting at ioapic0 pin 19
azalia0: host: 0x1002/0x960f (rev. 0), HDA rev. 1.0
ppb1 at pci0 dev 4 function 0: vendor 0x1022 product 0x9604 (rev. 0x00)
ppb1: unsupported PCI Express version
pci2 at ppb1 bus 2
pci2: no spaces enabled!
ppb2 at pci0 dev 6 function 0: vendor 0x1022 product 0x9606 (rev. 0x00)
ppb2: unsupported PCI Express version
pci3 at ppb2 bus 5
pci3: i/o space, memory space enabled, rd/line, wr/inv ok
ath0 at pci3 dev 0 function 0
ath0: interrupting at ioapic0 pin 18
ath0: 11b rates: 1Mbps 2Mbps 5.5Mbps 11Mbps
ath0: 11g rates: 1Mbps 2Mbps 5.5Mbps 11Mbps 6Mbps 9Mbps 12Mbps 18Mbps 24Mbps
36Mbps 48Mbps 54Mbps
ath0: mac 14.2 phy 7.0 radio 10.2
ppb3 at pci0 dev 7 function 0: vendor 0x1022 product 0x9607 (rev. 0x00)
ppb3: unsupported PCI Express version
pci4 at ppb3 bus 6
pci4: i/o space, memory space enabled, rd/line, wr/inv ok
bge0 at pci4 dev 0 function 0: Broadcom BCM5764 Gigabit Ethernet
bge0: interrupting at ioapic0 pin 19
bge0: chip id 5784100
bge0: ASIC BCM5784 A1 (0x0578), Ethernet address 00:1e:ec:4a:5b:d1
bge0: setting short Tx thresholds
brgphy0 at bge0 phy 1: Broadcom BCM5764, rev. 4
brgphy0: 10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, 1000baseT,
1000baseT-FDX, auto
ppb4 at pci0 dev 9 function 0: vendor 0x1022 product 0x9608 (rev. 0x00)
ppb4: unsupported PCI Express version
pci5 at ppb4 bus 7
pci5: i/o space, memory space enabled, rd/line, wr/inv ok
ahcisata0 at pci0 dev 17 function 0: vendor 0x1002 product 0x4391
ahcisata0: interrupting at ioapic0 pin 22
ahcisata0: AHCI revision 1.1, 6 ports, 32 command slots, features 0xf722e080
atabus0 at ahcisata0 channel 0
atabus1 at ahcisata0 channel 1
atabus2 at ahcisata0 channel 2
atabus3 at ahcisata0 channel 3
atabus4 at ahcisata0 channel 4
atabus5 at ahcisata0 channel 5
ohci0 at pci0 dev 18 function 0: vendor 0x1002 product 0x4397 (rev. 0x00)
ohci0: interrupting at ioapic0 pin 16
ohci0: OHCI version 1.0, legacy support
usb0 at ohci0: USB revision 1.0
ohci1 at pci0 dev 18 function 1: vendor 0x1002 product 0x4398 (rev. 0x00)
ohci1: interrupting at ioapic0 pin 16
ohci1: OHCI version 1.0, legacy support
usb1 at ohci1: USB revision 1.0
ehci0 at pci0 dev 18 function 2: vendor 0x1002 product 0x4396 (rev. 0x00)
ehci0: applying AMD SB600/SB700 USB freeze workaround
ehci0: interrupting at ioapic0 pin 17
ehci0: dropped intr workaround enabled
ehci0: EHCI version 1.0
ehci0: companion controllers, 3 ports each: ohci0 ohci1
usb2 at ehci0: USB revision 2.0
ohci2 at pci0 dev 19 function 0: vendor 0x1002 product 0x4397 (rev. 0x00)
ohci2: interrupting at ioapic0 pin 18
ohci2: OHCI version 1.0, legacy support
usb3 at ohci2: USB revision 1.0
ohci3 at pci0 dev 19 function 1: vendor 0x1002 product 0x4398 (rev. 0x00)
ohci3: interrupting at ioapic0 pin 18
ohci3: OHCI version 1.0, legacy support
usb4 at ohci3: USB revision 1.0
ehci1 at pci0 dev 19 function 2: vendor 0x1002 product 0x4396 (rev. 0x00)
ehci1: applying AMD SB600/SB700 USB freeze workaround
ehci1: interrupting at ioapic0 pin 19
ehci1: dropped intr workaround enabled
ehci1: EHCI version 1.0
ehci1: companion controllers, 3 ports each: ohci2 ohci3
usb5 at ehci1: USB revision 2.0
piixpm0 at pci0 dev 20 function 0
piixpm0: vendor 0x1002 product 0x4385 (rev. 0x3a)
piixpm0: interrupting at SMI, polling
iic0 at piixpm0: I2C bus
azalia1 at pci0 dev 20 function 2: Generic High Definition Audio Controller
azalia1: interrupting at ioapic0 pin 16
azalia1: host: 0x1002/0x4383 (rev. 0), HDA rev. 1.0
pcib0 at pci0 dev 20 function 3: vendor 0x1002 product 0x439d (rev. 0x00)
ppb5 at pci0 dev 20 function 4: vendor 0x1002 product 0x4384 (rev. 0x00)
pci6 at ppb5 bus 8
pci6: i/o space, memory space enabled
pchb1 at pci0 dev 24 function 0: vendor 0x1022 product 0x1300 (rev. 0x40)
pchb2 at pci0 dev 24 function 1: vendor 0x1022 product 0x1301 (rev. 0x00)
pchb3 at pci0 dev 24 function 2: vendor 0x1022 product 0x1302 (rev. 0x00)
amdtemp0 at pci0 dev 24 function 3: AMD CPU Temperature Sensors (Family10h /
Family11h)
pchb4 at pci0 dev 24 function 4: vendor 0x1022 product 0x1304 (rev. 0x00)
isa0 at pcib0
timecounter: Timecounter "clockinterrupt" frequency 100 Hz quality 0
timecounter: Timecounter "TSC" frequency 1900853000 Hz quality 3000
azalia0: codec[0]: ATI RS690/780 HDMI (rev. 0.0), HDA rev. 1.0
audio0 at azalia0: full duplex, independent
azalia1: codec[0]: Realtek ALC888 (rev. 2.2), HDA rev. 1.0
azalia1: codec[1]: 0x14f1/0x2c06 (rev. 0.0), HDA rev. 1.0
azalia1: codec[1]: No support for modem function groups
azalia1: codec[1] has no audio function groups
audio1 at azalia1: full duplex, independent
uhub0 at usb0: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub0: 3 ports with 3 removable, self powered
uhub1 at usb1: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub1: 3 ports with 3 removable, self powered
uhub2 at usb2: vendor 0x1002 EHCI root hub, class 9/0, rev 2.00/1.00, addr 1
uhub2: 6 ports with 6 removable, self powered
uhub3 at usb3: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub3: 3 ports with 3 removable, self powered
uhub4 at usb4: vendor 0x1002 OHCI root hub, class 9/0, rev 1.00/1.00, addr 1
uhub4: 3 ports with 3 removable, self powered
uhub5 at usb5: vendor 0x1002 EHCI root hub, class 9/0, rev 2.00/1.00, addr 1
uhub5: 6 ports with 6 removable, self powered
acpiacad0: AC adapter online.
ahcisata0 port 1: device present, speed: 1.5Gb/s
ahcisata0 port 0: device present, speed: 1.5Gb/s
wd0 at atabus0 drive 0: <WDC WD2500BEVS-22UST0>
wd0: drive supports 16-sector PIO transfers, LBA48 addressing
wd0: 232 GB, 484521 cyl, 16 head, 63 sec, 512 bytes/sect x 488397168 sectors
wd0: drive supports PIO mode 4, DMA mode 2, Ultra-DMA mode 6 (Ultra/133)
wd0(ahcisata0:0:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 6 (Ultra/133)
(using DMA)
atapibus0 at atabus1: 1 targets
cd0 at atapibus0 drive 0: <Optiarc DVD RW AD-7560S, 30652610 1075062Q11, SX07>
cdrom removable
cd0: drive supports PIO mode 4, DMA mode 2, Ultra-DMA mode 5 (Ultra/100)
cd0(ahcisata0:1:0): using PIO mode 4, DMA mode 2, Ultra-DMA mode 5 (Ultra/100)
(using DMA)
boot device: wd0
root on wd0a dumps on wd0b
root file system type: ffs
WARNING: clock gained 2 days
wsdisplay0: screen 1 added (80x25, vt100 emulation)
wsdisplay0: screen 2 added (80x25, vt100 emulation)
wsdisplay0: screen 3 added (80x25, vt100 emulation)
wsdisplay0: screen 4 added (80x25, vt100 emulation)
info: [drm] Setting GART location based on new memory map
info: [drm] Loading RS780 Microcode
info: [drm] Resetting GPU
info: [drm] writeback test failed ffffffff deadbeef
radeondrm0: interrupting at ioapic0 pin 18
set{u,g}id pid 688 (gnome-pty-helper) was invoked by uid 1000 ppid 623
(Terminal) with fd 2 closed
--------------020902030803040906090409--