Ich werde aus dem Code nicht schlau.. Wobei handelt es sich hier?

Knogle

Knogle

Volt-Modder(in)
Hallo liebe Community ,

Ich beschaeftige mich immernoch mit BIOS Modding , jedoch habe ich rausgefunden das das BIOS in C geschrieben sein soll zumindest teilweise da dort im BIOS einige Pfade mit .c Dateien vermekt sind

Worum handelt es sich hier eigentlich???
Also was ist das fuer ein Code und was macht der?
Signature "DSDT"
Length 0x00006531 (25905)
Revision 0x02 (2)
Checksum 0xA8 (168)
OEM ID "INTEL "
OEM Table ID "S5520HC "
OEM Revision 0x00000003 (3)
Creator ID "MSFT"
Creator Revision 0x0100000D (16777229)
DefinitionBlock ("DSDT.AML", "DSDT", 0x02, "INTEL ", "S5520HC ", 0x00000003)
{
Scope(\_PR)
{
Processor(CPU0,0x00,0x00000410,0x06) {}
Processor(CPU1,0x01,0x00000410,0x06) {}
Processor(CPU2,0x02,0x00000410,0x06) {}
Processor(CPU3,0x03,0x00000410,0x06) {}
Processor(CPU4,0x04,0x00000410,0x06) {}
Processor(CPU5,0x05,0x00000410,0x06) {}
Processor(CPU6,0x06,0x00000410,0x06) {}
Processor(CPU7,0x07,0x00000410,0x06) {}
Processor(CPU8,0x08,0x00000410,0x06) {}
Processor(CPU9,0x09,0x00000410,0x06) {}
Processor(CPUA,0x0A,0x00000410,0x06) {}
Processor(CPUB,0x0B,0x00000410,0x06) {}
Processor(CPUC,0x0C,0x00000410,0x06) {}
Processor(CPUD,0x0D,0x00000410,0x06) {}
Processor(CPUE,0x0E,0x00000410,0x06) {}
Processor(CPUF,0x0F,0x00000410,0x06) {}
Processor(CPUG,0x10,0x00000410,0x06) {}
Processor(CPUH,0x11,0x00000410,0x06) {}
Processor(CPUI,0x12,0x00000410,0x06) {}
Processor(CPUJ,0x13,0x00000410,0x06) {}
Processor(CPUK,0x14,0x00000410,0x06) {}
Processor(CPUL,0x15,0x00000410,0x06) {}
Processor(CPUM,0x16,0x00000410,0x06) {}
Processor(CPUN,0x17,0x00000410,0x06) {}
}
Name(\_S0, Package(4) {0x00, 0x00, 0x00, 0x00})
Name(\_S1, Package(4) {0x01, 0x00, 0x00, 0x00})
Name(\_S5, Package(4) {0x07, 0x00, 0x00, 0x00})
Name(\OSHF, 0x00)
Scope(\_SB)
{
Method(MIN, 2, NotSerialized)
{
If(LLess(Arg0, Arg1))
{
Return(Arg0)
}
Else
{
Return(Arg1)
}
}
Method(SLEN, 1, NotSerialized)
{
Return(SizeOf(Arg0))
}
Method(S2BF, 1, Serialized)
{
Add(SLEN(Arg0), One, Local0)
Name(BUFF, Buffer(Local0){})
Store(Arg0, BUFF)
Return(BUFF)
}
Method(SCMP, 2, NotSerialized)
{
Store(SLEN(Arg0), Local5)
Store(SLEN(Arg1), Local6)
Store(MIN(Local5, Local6), Local7)
If(LNotEqual(Local5, Local6))
{
If(LGreater(Local5, Local6))
{
Return(One)
}
Else
{
Return(Ones)
}
}
Store(S2BF(Arg0), Local0)
Store(S2BF(Arg1), Local1)
Store(Zero, Local4)
While(LLess(Local4, Local7))
{
Store(DerefOf(Index(Local0, Local4)), Local2)
Store(DerefOf(Index(Local1, Local4)), Local3)
If(LGreater(Local2, Local3))
{
Return(One)
}
Else
{
If(LLess(Local2, Local3))
{
Return(Ones)
}
}
Increment(Local4)
}
Return(Zero)
}
Method(BITS, 3, NotSerialized)
{
If(LLessEqual(Arg1, Arg2))
{
ShiftRight(Arg0, Arg1, Local0)
Subtract(0x1F, Arg2, Local1)
}
Else
{
ShiftRight(Arg0, Arg2, Local0)
Subtract(0x1F, Arg1, Local1)
}
ShiftRight(0xFFFFFFFF, Local1, Local1)
And(Local0, Local1, Local0)
Return(Local0)
}
Name(\OSFL, Zero)
Method(_INI, 0, NotSerialized)
{
Store(0x00, \OSFL)
If(CondRefOf(_OSI, Local0))
{
If(\_OSI("Windows 2008"))
{
Store(0x0A, \OSFL)
}
Else
{
If(\_OSI("Windows 2007"))
{
Store(0x0A, \OSFL)
}
Else
{
If(\_OSI("Windows 2006"))
{
Store(0x0B, \OSFL)
If(\_OSI("Windows 2006.1"))
{
Store(0x0A, \OSFL)
}
}
Else
{
If(\_OSI("Windows 2001.1"))
{
Store(0x05, \OSFL)
}
Else
{
If(\_OSI("Windows 2001"))
{
Store(0x04, \OSFL)
}
Else
{
If(\_OSI("Windows 2000"))
{
Store(0x03, \OSFL)
}
Else
{
If(\_OSI("FreeBSD"))
{
Store(0x06, \OSFL)
}
Else
{
If(\_OSI("HP-UX"))
{
Store(0x07, \OSFL)
}
Else
{
If(\_OSI("OpenVMS"))
{
Store(0x08, \OSFL)
}
}
}
}
}
}
}
}
}
}
Else
{
If(LEqual(\OSFL, 0x00))
{
Store(\_OS, Local0)
Store(SCMP(Local0, "Microsoft Windows NT"), Local1)
If(Not(Local1))
{
Store(0x03, \OSFL)
}
Else
{
Store(SCMP(Local0, "Microsoft WindowsNT"), Local2)
If(Not(Local2))
{
Store(0x01, \OSFL)
}
Else
{
Store(SCMP(Local0, "Microsoft WindowsME:Millennium Edition"), Local3)
If(Not(Local3))
{
Store(0x02, \OSFL)
}
}
}
}
}
}
}
Name(\PICM, Zero)
Method(\_PIC, 1, NotSerialized)
{
Store(Arg0, \PICM)
}
OperationRegion(DBG0, SystemIO, 0x80, 0x02)
Field(DBG0, ByteAcc, NoLock, Preserve)
{
IO80, 8,
IO81, 8,
}
OperationRegion(ACMS, SystemIO, 0x72, 0x02)
Field(ACMS, ByteAcc, NoLock, Preserve)
{
INDX, 8,
DATA, 8,
}
OperationRegion(PSYS, SystemMemory, 0x8F7CEE18, 0x0100)
Field(PSYS, ByteAcc, NoLock, Preserve)
{
PLAT, 32,
APC0, 1,
APC1, 1,
APC2, 1,
APC3, 1,
APCA, 1,
, 3,
NMEN, 8,
TPME, 1,
CSEN, 1,
CXOS, 2,
C6EN, 1,
C7EN, 1,
MWOS, 1,
PSEN, 1,
PSDT, 2,
SBS1, 1,
KPRS, 1,
MPRS, 1,
DIOH, 1,
C7SE, 1,
SOLE, 1,
PAER, 1,
}
OperationRegion(GSTS, SystemIO, 0x0422, 0x02)
Field(GSTS, ByteAcc, NoLock, Preserve)
{
Offset(0x1), //Offset(1),
, 5,
GP13, 1,
}
OperationRegion(GPE0, SystemIO, 0x0428, 0x08)
Field(GPE0, ByteAcc, NoLock, Preserve)
{
, 1,
GPEH, 1,
, 1,
USB1, 1,
USB2, 1,
USB5, 1,
, 3,
PCIE, 1,
, 1,
PMEE, 1,
USB3, 1,
PMB0, 1,
USB4, 1,
Offset(0x3), //Offset(3),
, 1,
, 7,
USB6, 1,
Offset(0x6), //Offset(6),
}
OperationRegion(GPES, SystemIO, 0x0420, 0x04)
Field(GPES, ByteAcc, NoLock, Preserve)
{
, 1,
GPSH, 1,
, 7,
, 1,
, 1,
, 1,
Offset(0x3), //Offset(3),
, 1,
, 7,
}
Method(_PTS, 1, NotSerialized)
{
Store(0x72, IO80)
\_SB.PCI0.HEC2.PTS()
Store(0x01, GPEH)
Store(0x01, USB1)
Store(0x01, USB2)
Store(0x01, USB5)
Store(0x01, PCIE)
Store(0x01, PMEE)
Store(0x01, USB3)
Store(0x01, PMB0)
Store(0x01, USB4)
Store(0x01, USB6)
If(LEqual(Arg0, 0x01))
{
\_SB.SWAF(0x51)
}
If(LEqual(Arg0, 0x04))
{
\_SB.SWAF(0x54)
}
If(LEqual(Arg0, 0x05))
{
If(LEqual(\OSFL, 0x03))
{
\_SB.SWAF(0x56)
}
Else
{
\_SB.SWAF(0x55)
}
}
}
Name(\PSTE, 0x00)
Name(\TSTE, 0x00)
Scope(\_SB)
{
Name(PR00, Package(69)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0001FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0001FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0001FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0001FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0002FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0002FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0002FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0002FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0003FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0003FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0003FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0003FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0004FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0004FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0004FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0004FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0005FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0005FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0005FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0005FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0006FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0006FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0006FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0006FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0007FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0007FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0007FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0007FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0008FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0008FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0008FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0008FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0009FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0009FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0009FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0009FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x000AFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000AFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x000AFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x000AFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x000DFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000DFFFF, 0x01, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000DFFFF, 0x02, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000DFFFF, 0x03, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000EFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000EFFFF, 0x01, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000EFFFF, 0x02, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x000EFFFF, 0x03, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0012FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0012FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x0012FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0012FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0016FFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x0016FFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x0016FFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x0016FFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x001AFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x001CFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x001CFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0x001CFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x001CFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00},
Package(4) {0x001DFFFF, 0x03, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x001FFFFF, 0x01, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0x001FFFFF, 0x02, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0x001FFFFF, 0x03, \_SB.PCI0.LPC0.LNKF, 0x00}
})
Name(AR00, Package(69)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13},
Package(4) {0x0001FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0001FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0001FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0001FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0002FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0002FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0002FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0002FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0003FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0003FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0003FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0003FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0004FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0004FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0004FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0004FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0005FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0005FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0005FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0005FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0006FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0006FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0006FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0006FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0007FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0007FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0007FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0007FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0008FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0008FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0008FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0008FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0009FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0009FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0009FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0009FFFF, 0x03, 0x00, 0x13},
Package(4) {0x000AFFFF, 0x00, 0x00, 0x10},
Package(4) {0x000AFFFF, 0x01, 0x00, 0x11},
Package(4) {0x000AFFFF, 0x02, 0x00, 0x12},
Package(4) {0x000AFFFF, 0x03, 0x00, 0x13},
Package(4) {0x000DFFFF, 0x00, 0x00, 0x10},
Package(4) {0x000DFFFF, 0x01, 0x00, 0x10},
Package(4) {0x000DFFFF, 0x02, 0x00, 0x10},
Package(4) {0x000DFFFF, 0x03, 0x00, 0x10},
Package(4) {0x000EFFFF, 0x00, 0x00, 0x10},
Package(4) {0x000EFFFF, 0x01, 0x00, 0x10},
Package(4) {0x000EFFFF, 0x02, 0x00, 0x10},
Package(4) {0x000EFFFF, 0x03, 0x00, 0x10},
Package(4) {0x0012FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0012FFFF, 0x03, 0x00, 0x13},
Package(4) {0x0012FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0012FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0016FFFF, 0x00, 0x00, 0x10},
Package(4) {0x0016FFFF, 0x01, 0x00, 0x11},
Package(4) {0x0016FFFF, 0x02, 0x00, 0x12},
Package(4) {0x0016FFFF, 0x03, 0x00, 0x13},
Package(4) {0x001AFFFF, 0x03, 0x00, 0x13},
Package(4) {0x001CFFFF, 0x00, 0x00, 0x10},
Package(4) {0x001CFFFF, 0x01, 0x00, 0x11},
Package(4) {0x001CFFFF, 0x02, 0x00, 0x12},
Package(4) {0x001CFFFF, 0x03, 0x00, 0x13},
Package(4) {0x001DFFFF, 0x03, 0x00, 0x10},
Package(4) {0x001FFFFF, 0x01, 0x00, 0x12},
Package(4) {0x001FFFFF, 0x02, 0x00, 0x10},
Package(4) {0x001FFFFF, 0x03, 0x00, 0x15}
})
Name(AH00, Package(69)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x2F},
Package(4) {0xFFFF, 0x01, 0x00, 0x2E},
Package(4) {0xFFFF, 0x02, 0x00, 0x2E},
Package(4) {0xFFFF, 0x03, 0x00, 0x2D},
Package(4) {0x0001FFFF, 0x00, 0x00, 0x1C},
Package(4) {0x0001FFFF, 0x01, 0x00, 0x28},
Package(4) {0x0001FFFF, 0x02, 0x00, 0x29},
Package(4) {0x0001FFFF, 0x03, 0x00, 0x2F},
Package(4) {0x0002FFFF, 0x00, 0x00, 0x1D},
Package(4) {0x0002FFFF, 0x01, 0x00, 0x29},
Package(4) {0x0002FFFF, 0x02, 0x00, 0x28},
Package(4) {0x0002FFFF, 0x03, 0x00, 0x2A},
Package(4) {0x0003FFFF, 0x00, 0x00, 0x18},
Package(4) {0x0003FFFF, 0x01, 0x00, 0x22},
Package(4) {0x0003FFFF, 0x02, 0x00, 0x23},
Package(4) {0x0003FFFF, 0x03, 0x00, 0x24},
Package(4) {0x0004FFFF, 0x00, 0x00, 0x19},
Package(4) {0x0004FFFF, 0x01, 0x00, 0x23},
Package(4) {0x0004FFFF, 0x02, 0x00, 0x24},
Package(4) {0x0004FFFF, 0x03, 0x00, 0x22},
Package(4) {0x0005FFFF, 0x00, 0x00, 0x1A},
Package(4) {0x0005FFFF, 0x01, 0x00, 0x19},
Package(4) {0x0005FFFF, 0x02, 0x00, 0x1B},
Package(4) {0x0005FFFF, 0x03, 0x00, 0x1D},
Package(4) {0x0006FFFF, 0x00, 0x00, 0x1B},
Package(4) {0x0006FFFF, 0x01, 0x00, 0x26},
Package(4) {0x0006FFFF, 0x02, 0x00, 0x25},
Package(4) {0x0006FFFF, 0x03, 0x00, 0x27},
Package(4) {0x0007FFFF, 0x00, 0x00, 0x1E},
Package(4) {0x0007FFFF, 0x01, 0x00, 0x25},
Package(4) {0x0007FFFF, 0x02, 0x00, 0x27},
Package(4) {0x0007FFFF, 0x03, 0x00, 0x26},
Package(4) {0x0008FFFF, 0x00, 0x00, 0x1F},
Package(4) {0x0008FFFF, 0x01, 0x00, 0x27},
Package(4) {0x0008FFFF, 0x02, 0x00, 0x26},
Package(4) {0x0008FFFF, 0x03, 0x00, 0x25},
Package(4) {0x0009FFFF, 0x00, 0x00, 0x20},
Package(4) {0x0009FFFF, 0x01, 0x00, 0x2A},
Package(4) {0x0009FFFF, 0x02, 0x00, 0x2F},
Package(4) {0x0009FFFF, 0x03, 0x00, 0x29},
Package(4) {0x000AFFFF, 0x00, 0x00, 0x21},
Package(4) {0x000AFFFF, 0x01, 0x00, 0x1F},
Package(4) {0x000AFFFF, 0x02, 0x00, 0x2E},
Package(4) {0x000AFFFF, 0x03, 0x00, 0x2D},
Package(4) {0x000DFFFF, 0x00, 0x00, 0x21},
Package(4) {0x000DFFFF, 0x01, 0x00, 0x21},
Package(4) {0x000DFFFF, 0x02, 0x00, 0x21},
Package(4) {0x000DFFFF, 0x03, 0x00, 0x21},
Package(4) {0x000EFFFF, 0x00, 0x00, 0x21},
Package(4) {0x000EFFFF, 0x01, 0x00, 0x21},
Package(4) {0x000EFFFF, 0x02, 0x00, 0x21},
Package(4) {0x000EFFFF, 0x03, 0x00, 0x21},
Package(4) {0x0012FFFF, 0x00, 0x00, 0x2D},
Package(4) {0x0012FFFF, 0x03, 0x00, 0x2E},
Package(4) {0x0012FFFF, 0x02, 0x00, 0x2F},
Package(4) {0x0012FFFF, 0x01, 0x00, 0x2E},
Package(4) {0x0016FFFF, 0x00, 0x00, 0x2B},
Package(4) {0x0016FFFF, 0x01, 0x00, 0x2C},
Package(4) {0x0016FFFF, 0x02, 0x00, 0x2D},
Package(4) {0x0016FFFF, 0x03, 0x00, 0x2E},
Package(4) {0x001AFFFF, 0x03, 0x00, 0x13},
Package(4) {0x001CFFFF, 0x00, 0x00, 0x10},
Package(4) {0x001CFFFF, 0x01, 0x00, 0x11},
Package(4) {0x001CFFFF, 0x02, 0x00, 0x12},
Package(4) {0x001CFFFF, 0x03, 0x00, 0x13},
Package(4) {0x001DFFFF, 0x03, 0x00, 0x10},
Package(4) {0x001FFFFF, 0x01, 0x00, 0x12},
Package(4) {0x001FFFFF, 0x02, 0x00, 0x10},
Package(4) {0x001FFFFF, 0x03, 0x00, 0x15}
})
Name(PR01, Package(2)
{
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00}
})
Name(AR01, Package(2)
{
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x00, 0x00, 0x10}
})
Name(AH01, Package(2)
{
Package(4) {0xFFFF, 0x01, 0x00, 0x28},
Package(4) {0xFFFF, 0x00, 0x00, 0x1C}
})
Name(PR02, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR02, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Name(AH02, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x18},
Package(4) {0xFFFF, 0x01, 0x00, 0x22},
Package(4) {0xFFFF, 0x02, 0x00, 0x23},
Package(4) {0xFFFF, 0x03, 0x00, 0x24}
})
Name(PR03, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR03, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Name(AH03, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x1A},
Package(4) {0xFFFF, 0x01, 0x00, 0x19},
Package(4) {0xFFFF, 0x02, 0x00, 0x1B},
Package(4) {0xFFFF, 0x03, 0x00, 0x1D}
})
Name(PR04, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR04, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Name(AH04, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x1E},
Package(4) {0xFFFF, 0x01, 0x00, 0x25},
Package(4) {0xFFFF, 0x02, 0x00, 0x27},
Package(4) {0xFFFF, 0x03, 0x00, 0x26}
})
Name(PR05, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR05, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Name(AH05, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x20},
Package(4) {0xFFFF, 0x01, 0x00, 0x2A},
Package(4) {0xFFFF, 0x02, 0x00, 0x2F},
Package(4) {0xFFFF, 0x03, 0x00, 0x29}
})
Name(PR06, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR06, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Name(PR07, Package(1)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00}
})
Name(AR07, Package(1)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10}
})
Name(PR08, Package(4)
{
Package(4) {0xFFFF, 0x00, \_SB.PCI0.LPC0.LNKA, 0x00},
Package(4) {0xFFFF, 0x01, \_SB.PCI0.LPC0.LNKB, 0x00},
Package(4) {0xFFFF, 0x02, \_SB.PCI0.LPC0.LNKC, 0x00},
Package(4) {0xFFFF, 0x03, \_SB.PCI0.LPC0.LNKD, 0x00}
})
Name(AR08, Package(4)
{
Package(4) {0xFFFF, 0x00, 0x00, 0x10},
Package(4) {0xFFFF, 0x01, 0x00, 0x11},
Package(4) {0xFFFF, 0x02, 0x00, 0x12},
Package(4) {0xFFFF, 0x03, 0x00, 0x13}
})
Device(PCI0)
{
Name(_HID, EISAID("PNP0A08"))
Name(_CID, EISAID("PNP0A03"))
Name(_UID, 0x00)
Name(_BBN, 0x00)
Name(_ADR, 0x00)
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR00)
}
If(LEqual(APC1, One))
{
Return(AH00)
}
Return(AR00)
}
Name(SUPP, 0x00)
Name(CTRL, 0x00)
Method(_OSC, 4, NotSerialized)
{
CreateDWordField(Arg3, 0x00, CDW1)
CreateDWordField(Arg3, 0x04, CDW2)
CreateDWordField(Arg3, 0x08, CDW3)
Store(CDW2, SUPP)
Store(CDW3, CTRL)
If(LEqual(Arg0, ToUUID("33DB4D5B-1FF7401C-96577441C03DD766")}))
{
If(LNotEqual(And(SUPP, 0x16), 0x16))
{
And(CTRL, 0x1E)
}
And(CTRL, 0x1D, CTRL)
If(LNotEqual(Arg1, One))
{
Or(CDW1, 0x08, CDW1)
}
If(LNotEqual(CDW3, CTRL))
{
Or(CDW1, 0x10, CDW1)
}
If(LEqual(PAER, 0x01))
{
If(LEqual(\OSFL, 0x0A))
{
And(CTRL, 0x1E, CTRL)
}
}
Store(CTRL, CDW3)
Return(Arg3)
}
Else
{
Or(CDW1, 0x04, CDW1)
Return(Arg3)
}
}
Device(APIC)
{
Name(_HID, EISAID("PNP0003"))
Name(_CRS, ResourceTemplate()
{
Memory32Fixed(ReadOnly, 0xFEC00000, 0x00100000)
})
}
Device(SPFN)
{
Name(_ADR, 0x00140001)
OperationRegion(SPAD, PCI_Config, 0x00, 0xF0)
Field(SPAD, DWordAcc, NoLock, Preserve)
{
Offset(0x9C), //Offset(156),
SR08, 32,
SR09, 32,
SR10, 32,
SR11, 32,
SR12, 32,
SR13, 32,
SR14, 32,
SR15, 32,
SR16, 32,
SR17, 32,
SR18, 32,
SR19, 32,
SR20, 32,
SR21, 32,
SR22, 32,
SR23, 32,
}
}
Name(PBRS, ResourceTemplate()
{
WordBusNumber(ResourceProducer, MinFixed, MaxFixed, PosDecode,
0x0000,
0x0000,
0x00FD,
0x0000,
0x00FE
)
IO(Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08)
WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000,
0x0000,
0x0CF7,
0x0000,
0x0CF8
)
WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
0x0000,
0x0D00,
0xFFFF,
0x0000,
0xF300
)
DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000,
0x000A0000,
0x000BFFFF,
0x00000000,
0x00020000
)
DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000
)
DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x00000000,
0xFED40000,
0xFEDFFFFF,
0x00000000,
0x000C0000
)
DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x00000000,
0xB0000000,
0xFDFFFFFF,
0x00000000,
0x4E000000
)
QWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000
)
})
Method(_CRS, 0, NotSerialized)
{
EROM()
Return(PBRS)
}
OperationRegion(TMEM, PCI_Config, 0x52, 0x03)
Field(TMEM, ByteAcc, NoLock, Preserve)
{
DIM0, 4,
DIM1, 4,
, 8,
DIM2, 4,
}
Name(MTBL, Package(16)
{
0x00, 0x20, 0x20, 0x30, 0x40, 0x40, 0x60, 0x80, 0x80, 0x80, 0x80,
0xC0, 0x0100, 0x0100, 0x0100, 0x0200
})
OperationRegion(PAMX, PCI_Config, 0x90, 0x07)
Field(PAMX, ByteAcc, NoLock, Preserve)
{
, 4,
BSEG, 4,
PAMS, 48,
}
Name(ERNG, Package(13)
{
0x000C0000, 0x000C4000, 0x000C8000, 0x000CC000, 0x000D0000, 0x000D4000,
0x000D8000, 0x000DC000, 0x000E0000, 0x000E4000, 0x000E8000, 0x000EC000,
0x000F0000
})
Name(PAMB, Buffer(0x07){})
Method(EROM, 0, NotSerialized)
{
CreateDWordField(PBRS, 0x5C, RMIN)
CreateDWordField(PBRS, 0x60, RMAX)
CreateDWordField(PBRS, 0x68, RLEN)
CreateByteField(PAMB,0x06,BREG)
Store(PAMS, PAMB)
Store(BSEG, BREG)
Store(0x00, RMIN)
Store(0x00, RMAX)
Store(0x00, RLEN)
Store(0x00, Local0)
While(LLess(Local0, 0x0D))
{
ShiftRight(Local0, 0x01, Local1)
Store(DerefOf(Index(PAMB, Local1)), Local2)
If(And(Local0, 0x01))
{
ShiftRight(Local2, 0x04, Local2)
}
And(Local2, 0x03, Local2)
If(RMIN)
{
If(Local2)
{
Add(DerefOf(Index(ERNG, Local0)), 0x3FFF, RMAX)
If(LEqual(RMAX, 0x000F3FFF))
{
Store(0x000FFFFF, RMAX)
}
Subtract(RMAX, RMIN, RLEN)
Increment(RLEN)
}
Else
{
Store(0x0C, Local0)
}
}
Else
{
If(Local2)
{
Store(DerefOf(Index(ERNG, Local0)), RMIN)
Add(DerefOf(Index(ERNG, Local0)), 0x3FFF, RMAX)
If(LEqual(RMAX, 0x000F3FFF))
{
Store(0x000FFFFF, RMAX)
}
Subtract(RMAX, RMIN, RLEN)
Increment(RLEN)
}
Else {}
}
Increment(Local0)
}
}
Device(DMI0)
{
Name(_ADR, 0x00)
}
Device(MRP1)
{
Name(_ADR, 0x00010000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR01)
}
If(LEqual(APC1, One))
{
Return(AH01)
}
Return(AR01)
}
Device(ZOR1)
{
Name(_ADR, 0x00)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
Device(ZOR2)
{
Name(_ADR, 0x01)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
}
Device(MRP2)
{
Name(_ADR, 0x00020000)
}
Device(MRP3)
{
Name(_ADR, 0x00030000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR02)
}
If(LEqual(APC1, One))
{
Return(AH02)
}
Return(AR02)
}
Device(S6F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x06)
}
Device(S6F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x06)
}
Device(S6F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x06)
}
Device(S6F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x06)
}
Device(S6F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x06)
}
Device(S6F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x06)
}
Device(S6F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x06)
}
Device(S6F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x06)
}
}
Device(MRP4)
{
Name(_ADR, 0x00040000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
Device(MRP5)
{
Name(_ADR, 0x00050000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR03)
}
If(LEqual(APC1, One))
{
Return(AH03)
}
Return(AR03)
}
Device(S5F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x05)
}
Device(S5F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x05)
}
Device(S5F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x05)
}
Device(S5F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x05)
}
Device(S5F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x05)
}
Device(S5F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x05)
}
Device(S5F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x05)
}
Device(S5F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x05)
}
}
Device(MRP6)
{
Name(_ADR, 0x00060000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
Device(MRP7)
{
Name(_ADR, 0x00070000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR04)
}
If(LEqual(APC1, One))
{
Return(AH04)
}
Return(AR04)
}
Device(S4F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x04)
}
Device(S4F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x04)
}
Device(S4F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x04)
}
Device(S4F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x04)
}
Device(S4F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x04)
}
Device(S4F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x04)
}
Device(S4F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x04)
}
Device(S4F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x04)
}
}
Device(MRP8)
{
Name(_ADR, 0x00080000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
Device(MRP9)
{
Name(_ADR, 0x00090000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR05)
}
If(LEqual(APC1, One))
{
Return(AH05)
}
Return(AR05)
}
Device(S3F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x03)
}
Device(S3F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x03)
}
Device(S3F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x03)
}
Device(S3F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x03)
}
Device(S3F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x03)
}
Device(S3F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x03)
}
Device(S3F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x03)
}
Device(S3F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x03)
}
}
Device(MRPA)
{
Name(_ADR, 0x000A0000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x04})
}
}
Device(DFX1)
{
Name(_ADR, 0x000D0000)
}
Device(DFX2)
{
Name(_ADR, 0x000E0000)
}
Device(HECI)
{
Name(_ADR, 0x00120000)
}
Device(HEC2)
{
Name(_ADR, 0x00120001)
OperationRegion(HCSR, SystemMemory, 0xFEA00000, 0x10)
Field(HCSR, DWordAcc, NoLock, Preserve)
{
CBWW, 32,
HIE, 1,
HIS, 1,
HIG, 1,
HRD, 1,
HRS, 1,
, 3,
HRP, 8,
HWP, 8,
HBD, 8,
CBRW, 32,
MIE, 1,
MIS, 1,
MIG, 1,
MRD, 1,
MRS, 1,
, 3,
MRP, 8,
MWP, 8,
MBD, 8,
}
Method(_INI, 0, Serialized)
{
WAK()
}
Method(WAK, 0, Serialized)
{
If(NMEN)
{
Store(0x01, HRD)
Store(0x01, HIS)
Store(0x01, HIE)
Store(0x01, HIG)
}
}
Method(PTS, 0, Serialized)
{
If(NMEN)
{
Store(0x00, HIE)
Store(0x00, HRD)
Store(0x01, HIG)
}
}
Method(HSCI, 0, Serialized)
{
If(NMEN)
{
If(HIS)
{
Store(0x01, HIS)
If(MRS)
{
Store(0x01, HRS)
Store(0x01, HIG)
}
Else
{
If(MRD)
{
If(LNot(HRD))
{
Store(0x00, HRS)
Store(0x01, HRD)
Store(0x01, HIG)
}
If(LNotEqual(MWP, MRP))
{
Store(CBRW, Local0)
Store(CBRW, Local0)
If(LEqual(And(Local0, 0xFF), 0x00))
{
Store(And(ShiftRight(Local0, 0x10), 0xFF), \PSTE)
Store(And(ShiftRight(Local0, 0x18), 0xFF), \TSTE)
Notify(\_PR.CPU0, 0x80)
Notify(\_PR.CPU0, 0x82)
Notify(\_PR.CPU1, 0x80)
Notify(\_PR.CPU1, 0x82)
Notify(\_PR.CPU2, 0x80)
Notify(\_PR.CPU2, 0x82)
Notify(\_PR.CPU3, 0x80)
Notify(\_PR.CPU3, 0x82)
Notify(\_PR.CPU4, 0x80)
Notify(\_PR.CPU4, 0x82)
Notify(\_PR.CPU5, 0x80)
Notify(\_PR.CPU5, 0x82)
Notify(\_PR.CPU6, 0x80)
Notify(\_PR.CPU6, 0x82)
Notify(\_PR.CPU7, 0x80)
Notify(\_PR.CPU7, 0x82)
Notify(\_PR.CPU8, 0x80)
Notify(\_PR.CPU8, 0x82)
Notify(\_PR.CPU9, 0x80)
Notify(\_PR.CPU9, 0x82)
Notify(\_PR.CPUA, 0x80)
Notify(\_PR.CPUA, 0x82)
Notify(\_PR.CPUB, 0x80)
Notify(\_PR.CPUB, 0x82)
Notify(\_PR.CPUC, 0x80)
Notify(\_PR.CPUC, 0x82)
Notify(\_PR.CPUD, 0x80)
Notify(\_PR.CPUD, 0x82)
Notify(\_PR.CPUE, 0x80)
Notify(\_PR.CPUE, 0x82)
Notify(\_PR.CPUF, 0x80)
Notify(\_PR.CPUF, 0x82)
Notify(\_PR.CPUG, 0x80)
Notify(\_PR.CPUG, 0x82)
Notify(\_PR.CPUH, 0x80)
Notify(\_PR.CPUH, 0x82)
Notify(\_PR.CPUI, 0x80)
Notify(\_PR.CPUI, 0x82)
Notify(\_PR.CPUJ, 0x80)
Notify(\_PR.CPUJ, 0x82)
Notify(\_PR.CPUK, 0x80)
Notify(\_PR.CPUK, 0x82)
Notify(\_PR.CPUL, 0x80)
Notify(\_PR.CPUL, 0x82)
Notify(\_PR.CPUM, 0x80)
Notify(\_PR.CPUM, 0x82)
Notify(\_PR.CPUN, 0x80)
Notify(\_PR.CPUN, 0x82)
}
}
}
}
}
}
}
}
Device(MEID)
{
Name(_ADR, 0x00120002)
}
Device(MEKT)
{
Name(_ADR, 0x00120003)
}
Device(CB3)
{
Name(_ADR, 0x00160000)
}
Device(UHC4)
{
Name(_ADR, 0x001A0000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x0E, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(UHC5)
{
Name(_ADR, 0x001A0001)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x05, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(UHC6)
{
Name(_ADR, 0x001A0002)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x20, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(EHC2)
{
Name(_ADR, 0x001A0007)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x0D, 0x01})
}
OperationRegion(USBR, PCI_Config, 0x62, 0x02)
Field(USBR, WordAcc, NoLock, Preserve)
{
URE2, 7,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URE2)
}
If(LEqual(Arg0, One))
{
Store(0x7F, URE2)
}
}
}
Device(PEX0)
{
Name(_ADR, 0x001C0000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR06)
}
Return(AR06)
}
Device(S2F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x02)
}
Device(S2F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x02)
}
Device(S2F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x02)
}
Device(S2F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x02)
}
Device(S2F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x02)
}
Device(S2F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x02)
}
Device(S2F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x02)
}
Device(S2F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x02)
}
}
Device(PEX1)
{
Name(_ADR, 0x001C0001)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
}
Device(PEX2)
{
Name(_ADR, 0x001C0002)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
}
Device(PEX3)
{
Name(_ADR, 0x001C0003)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
}
Device(PEX4)
{
Name(_ADR, 0x001C0004)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x09, 0x05})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR07)
}
Return(AR07)
}
Device(BMCV)
{
Name(_ADR, 0x00)
}
}
Device(UHC1)
{
Name(_ADR, 0x001D0000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x03, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(UHC2)
{
Name(_ADR, 0x001D0001)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x04, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(UHC3)
{
Name(_ADR, 0x001D0002)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x0C, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(UHCI)
{
Name(_ADR, 0x001D0003)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x20, 0x01})
}
OperationRegion(USBR, PCI_Config, 0xC4, 0x01)
Field(USBR, AnyAcc, NoLock, Preserve)
{
URES, 8,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URES)
}
If(LEqual(Arg0, One))
{
Store(0x03, URES)
}
}
}
Device(EHC1)
{
Name(_ADR, 0x001D0007)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x0D, 0x01})
}
OperationRegion(USBR, PCI_Config, 0x62, 0x02)
Field(USBR, WordAcc, NoLock, Preserve)
{
URE2, 9,
}
Method(_PSW, 1, NotSerialized)
{
If(LEqual(Arg0, Zero))
{
Store(0x00, URE2)
}
If(LEqual(Arg0, One))
{
Store(0x01FF, URE2)
}
}
}
Device(IP2P)
{
Name(_ADR, 0x001E0000)
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x0B, 0x05})
}
Method(_PRT, 0, NotSerialized)
{
If(LEqual(PICM, Zero))
{
Return(PR08)
}
Return(AR08)
}
Device(S1F0)
{
Name(_ADR, 0x00)
Name(_SUN, 0x01)
}
Device(S1F1)
{
Name(_ADR, 0x01)
Name(_SUN, 0x01)
}
Device(S1F2)
{
Name(_ADR, 0x02)
Name(_SUN, 0x01)
}
Device(S1F3)
{
Name(_ADR, 0x03)
Name(_SUN, 0x01)
}
Device(S1F4)
{
Name(_ADR, 0x04)
Name(_SUN, 0x01)
}
Device(S1F5)
{
Name(_ADR, 0x05)
Name(_SUN, 0x01)
}
Device(S1F6)
{
Name(_ADR, 0x06)
Name(_SUN, 0x01)
}
Device(S1F7)
{
Name(_ADR, 0x07)
Name(_SUN, 0x01)
}
}
Device(LPC0)
{
Name(_ADR, 0x001F0000)
OperationRegion(PRR0, PCI_Config, 0x60, 0x04)
Field(PRR0, AnyAcc, NoLock, Preserve)
{
PIRA, 8,
PIRB, 8,
PIRC, 8,
PIRD, 8,
}
OperationRegion(PRR1, PCI_Config, 0x68, 0x04)
Field(PRR1, AnyAcc, NoLock, Preserve)
{
PIRE, 8,
PIRF, 8,
PIRG, 8,
PIRH, 8,
}
Device(LNKA)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRA, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRA, 0x80, PIRA)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRA, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRA, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRA)
}
}
Device(LNKB)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRB, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRB, 0x80, PIRB)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRB, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRB, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRB)
}
}
Device(LNKC)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRC, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRC, 0x80, PIRC)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRC, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRC, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRC)
}
}
Device(LNKD)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRD, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRD, 0x80, PIRD)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRD, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRD, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRD)
}
}
Device(LNKE)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRE, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRE, 0x80, PIRE)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRE, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRE, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRE)
}
}
Device(LNKF)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRF, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRB, 0x80, PIRF)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRF, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRF, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRF)
}
}
Device(LNKG)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRG, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRG, 0x80, PIRG)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRG, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRG, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRG)
}
}
Device(LNKH)
{
Name(_HID, EISAID("PNP0C0F"))
Method(_STA, 0, NotSerialized)
{
If(And(PIRH, 0x80))
{
Return(0x09)
}
Else
{
Return(0x0B)
}
}
Method(_DIS, 0, NotSerialized)
{
Or(PIRH, 0x80, PIRH)
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {0}
})
CreateWordField(BUF0, 0x01, IRQW)
If(And(PIRH, 0x80))
{
Store(Zero, Local0)
}
Else
{
Store(One, Local0)
}
ShiftLeft(Local0, And(PIRH, 0x0F), IRQW)
Return(BUF0)
}
Name(_PRS, ResourceTemplate()
{
IRQ(Level, ActiveLow, Shared) {3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15}
})
Method(_SRS, 1, NotSerialized)
{
CreateWordField(Arg0, 0x01, IRQW)
FindSetRightBit(IRQW, Local0)
If(LNotEqual(IRQW, Zero))
{
And(Local0, 0x7F, Local0)
Decrement(Local0)
}
Else
{
Or(Local0, 0x80, Local0)
}
Store(Local0, PIRH)
}
}
Device(DMAC)
{
Name(_HID, EISAID("PNP0200"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0000, 0x0000, 0x00, 0x10)
IO(Decode16, 0x0081, 0x0081, 0x00, 0x03)
IO(Decode16, 0x0087, 0x0087, 0x00, 0x01)
IO(Decode16, 0x0089, 0x0089, 0x00, 0x03)
IO(Decode16, 0x008F, 0x008F, 0x00, 0x01)
IO(Decode16, 0x00C0, 0x00C0, 0x00, 0x20)
DMA(Compatibility, NotBusMaster, Transfer8) {4}
})
}
Device(RTC)
{
Name(_HID, EISAID("PNP0B00"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0070, 0x0070, 0x01, 0x02)
IO(Decode16, 0x0074, 0x0074, 0x01, 0x04)
IRQNoFlags() {8}
})
}
Device(PIC)
{
Name(_HID, EISAID("PNP0000"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0020, 0x0020, 0x01, 0x1E)
IO(Decode16, 0x00A0, 0x00A0, 0x01, 0x1E)
IO(Decode16, 0x04D0, 0x04D0, 0x01, 0x02)
})
}
Device(FPU)
{
Name(_HID, EISAID("PNP0C04"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x00F0, 0x00F0, 0x01, 0x01)
IRQNoFlags() {13}
})
}
Device(TMR)
{
Name(_HID, EISAID("PNP0100"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0040, 0x0040, 0x01, 0x04)
IO(Decode16, 0x0050, 0x0050, 0x01, 0x04)
IRQNoFlags() {0}
})
}
Device(SPKR)
{
Name(_HID, EISAID("PNP0800"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0061, 0x0061, 0x01, 0x01)
})
}
Device(HPET)
{
Name(_HID, EISAID("PNP0103"))
OperationRegion(HPTC, SystemMemory, 0xFED1F404, 0x04)
Field(HPTC, AnyAcc, NoLock, Preserve)
{
HPTS, 2,
, 5,
HPTE, 1,
Offset(0x4), //Offset(4),
}
Method(_STA, 0, NotSerialized)
{
And(HPTE, 0x01, Local0)
If(Local0)
{
Return(0x0F)
}
Return(0x00)
}
Name(CRS0, ResourceTemplate()
{
Memory32Fixed(ReadOnly, 0xFED00000, 0x00000400)
})
Name(CRS1, ResourceTemplate()
{
Memory32Fixed(ReadOnly, 0xFED10000, 0x00000400)
})
Name(CRS2, ResourceTemplate()
{
Memory32Fixed(ReadOnly, 0xFED20000, 0x00000400)
})
Name(CRS3, ResourceTemplate()
{
Memory32Fixed(ReadOnly, 0xFED30000, 0x00000400)
})
Method(_CRS, 0, NotSerialized)
{
Name(_T_0, Zero)
Store(HPTS, _T_0)
If(LEqual(_T_0, 0x00))
{
Return(CRS0)
}
Else
{
If(LEqual(_T_0, 0x01))
{
Return(CRS1)
}
Else
{
If(LEqual(_T_0, 0x02))
{
Return(CRS2)
}
Else
{
If(LEqual(_T_0, 0x03))
{
Return(CRS3)
}
}
}
}
Return(CRS0)
}
}
Device(XTRA)
{
Name(_HID, EISAID("PNP0C02"))
Name(_CRS, ResourceTemplate()
{
IO(Decode16, 0x0500, 0x0500, 0x01, 0x80)
IO(Decode16, 0x0400, 0x0400, 0x01, 0x80)
IO(Decode16, 0x0092, 0x0092, 0x01, 0x01)
IO(Decode16, 0x0010, 0x0010, 0x01, 0x10)
IO(Decode16, 0x0072, 0x0072, 0x01, 0x02)
IO(Decode16, 0x0080, 0x0080, 0x01, 0x01)
IO(Decode16, 0x0084, 0x0084, 0x01, 0x03)
IO(Decode16, 0x0088, 0x0088, 0x01, 0x01)
IO(Decode16, 0x008C, 0x008C, 0x01, 0x03)
IO(Decode16, 0x0090, 0x0090, 0x01, 0x10)
IO(Decode16, 0x0800, 0x0800, 0x01, 0x20)
IO(Decode16, 0x0CA2, 0x0CA2, 0x00, 0x02)
IO(Decode16, 0x0600, 0x0600, 0x01, 0x20)
IO(Decode16, 0x0880, 0x0880, 0x01, 0x04)
IO(Decode16, 0x0CA4, 0x0CA4, 0x00, 0x02)
Memory32Fixed(ReadOnly, 0xFED1C000, 0x00023FFF)
Memory32Fixed(ReadOnly, 0xFF000000, 0x01000000)
Memory32Fixed(ReadOnly, 0xFEE00000, 0x00100000)
Memory32Fixed(ReadWrite, 0xFE900000, 0x00000020)
Memory32Fixed(ReadWrite, 0xFEA00000, 0x00000020)
Memory32Fixed(ReadOnly, 0xFED1B000, 0x00001000)
})
}
OperationRegion(SMCF, SystemIO, 0x4E, 0x02)
Field(SMCF, ByteAcc, NoLock, Preserve)
{
INXF, 8,
DATF, 8,
}
IndexField(INXF, DATF, ByteAcc, NoLock, Preserve)
{
Offset(0x7), //Offset(7),
LDNF, 8,
Offset(0x20), //Offset(32),
DIDF, 8,
Offset(0x30), //Offset(48),
ACTF, 8,
Offset(0x60), //Offset(96),
AHFF, 8,
ALFF, 8,
Offset(0x70), //Offset(112),
INTF, 8,
INSF, 8,
Offset(0x74), //Offset(116),
DMCF, 8,
}
Method(ENFF, 1, NotSerialized)
{
Store(0x5A, INXF)
Store(Arg0, LDNF)
}
Method(EXFF, 0, NotSerialized)
{
Store(0xA5, INXF)
}
OperationRegion(SWCR, SystemIO, 0x0680, 0x02)
Field(SWCR, ByteAcc, NoLock, Preserve)
{
SWCI, 8,
SWCD, 8,
}
IndexField(SWCI, SWCD, ByteAcc, NoLock, Preserve)
{
RIS1, 1,
RIS2, 1,
, 6,
, 8,
RIE1, 1,
RIE2, 1,
, 6,
}
Method(PTS2, 1, NotSerialized)
{
Store(0x01, RIS2)
Store(0x01, RIE2)
}
Method(WAK2, 1, NotSerialized)
{
Store(0x00, RIE2)
Store(0x01, RIS2)
}
Device(UAR1)
{
Name(_HID, EISAID("PNP0501"))
Name(_UID, 0x01)
Method(_STA, 0, NotSerialized)
{
If(SOLE)
{
Return(0x00)
}
ENFF(0x02)
If(ACTF)
{
EXFF()
Return(0x0F)
}
Else
{
If(LOr(AHFF, ALFF))
{
EXFF()
Return(0x0D)
}
Else
{
EXFF()
Return(0x00)
}
}
}
Method(_DIS, 0, NotSerialized)
{
ENFF(0x02)
Store(0x00, ACTF)
EXFF()
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IO(Decode16, 0x03F8, 0x03F8, 0x08, 0x08)
IRQNoFlags() {4}
})
CreateByteField(BUF0,0x02,IOLO)
CreateByteField(BUF0,0x03,IOHI)
CreateByteField(BUF0,0x04,IORL)
CreateByteField(BUF0,0x05,IORH)
CreateWordField(BUF0, 0x09, IRQL)
ENFF(0x02)
Store(ALFF, IOLO)
Store(ALFF, IORL)
Store(AHFF, IOHI)
Store(AHFF, IORH)
Store(0x01, Local0)
ShiftLeft(Local0, INTF, IRQL)
EXFF()
Return(BUF0)
}
Method(_PRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
StartDependentFn(0, 2)
{
IO(Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
IRQNoFlags() {4}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
IRQNoFlags() {4}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
IRQNoFlags() {3}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
IRQNoFlags() {3}
}
StartDependentFn(2, 0)
{
IO(Decode16, 0x0100, 0x03F8, 0x08, 0x08)
IRQNoFlags() {1, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15}
}
EndDependentFn()
})
Return(BUF0)
}
Method(_SRS, 1, NotSerialized)
{
CreateByteField(Arg0,0x02,IOLO)
CreateByteField(Arg0,0x03,IOHI)
CreateWordField(Arg0, 0x09, IRQL)
ENFF(0x02)
Store(IOLO, ALFF)
Store(IOHI, AHFF)
FindSetRightBit(IRQL, INTF)
If(LNotEqual(IRQL, Zero))
{
Decrement(INTF)
}
Store(0x01, ACTF)
EXFF()
}
}
Device(UAR2)
{
Name(_HID, EISAID("PNP0501"))
Name(_UID, 0x02)
Method(_STA, 0, NotSerialized)
{
ENFF(0x01)
If(ACTF)
{
EXFF()
Return(0x0F)
}
Else
{
If(LOr(AHFF, ALFF))
{
EXFF()
Return(0x0D)
}
Else
{
EXFF()
Return(0x00)
}
}
}
Method(_DIS, 0, NotSerialized)
{
ENFF(0x01)
Store(0x00, ACTF)
EXFF()
}
Method(_CRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
IO(Decode16, 0x02F8, 0x02F8, 0x08, 0x08)
IRQNoFlags() {3}
})
CreateByteField(BUF0,0x02,IOLO)
CreateByteField(BUF0,0x03,IOHI)
CreateByteField(BUF0,0x04,IORL)
CreateByteField(BUF0,0x05,IORH)
CreateWordField(BUF0, 0x09, IRQL)
ENFF(0x01)
Store(ALFF, IOLO)
Store(ALFF, IORL)
Store(AHFF, IOHI)
Store(AHFF, IORH)
Store(0x01, Local0)
ShiftLeft(Local0, INTF, IRQL)
EXFF()
Return(BUF0)
}
Method(_PRS, 0, NotSerialized)
{
Name(BUF0, ResourceTemplate()
{
StartDependentFn(0, 2)
{
IO(Decode16, 0x02F8, 0x02F8, 0x01, 0x08)
IRQNoFlags() {3}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x03F8, 0x03F8, 0x01, 0x08)
IRQNoFlags() {4}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x03E8, 0x03E8, 0x01, 0x08)
IRQNoFlags() {4}
}
StartDependentFn(0, 2)
{
IO(Decode16, 0x02E8, 0x02E8, 0x01, 0x08)
IRQNoFlags() {3}
}
StartDependentFn(2, 0)
{
IO(Decode16, 0x0100, 0x02F8, 0x08, 0x08)
IRQNoFlags() {1, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15}
}
EndDependentFn()
})
Return(BUF0)
}
Method(_SRS, 1, NotSerialized)
{
CreateByteField(Arg0,0x02,IOLO)
CreateByteField(Arg0,0x03,IOHI)
CreateWordField(Arg0, 0x09, IRQL)
ENFF(0x01)
Store(IOLO, ALFF)
Store(IOHI, AHFF)
FindSetRightBit(IRQL, INTF)
If(LNotEqual(IRQL, Zero))
{
Decrement(INTF)
}
Store(0x01, ACTF)
EXFF()
}
}
Device(TPM)
{
Name(_HID, EISAID("PNP0C31"))
Name(_STR, Buffer(0x1E)
{
0x54, 0x00, 0x50, 0x00, 0x4D, 0x00, 0x20, 0x00,
0x31, 0x00, 0x2E, 0x00, 0x32, 0x00, 0x20, 0x00,
0x44, 0x00, 0x65, 0x00, 0x76, 0x00, 0x69, 0x00,
0x63, 0x00, 0x65, 0x00, 0x00, 0x00
})
Name(_CRS, ResourceTemplate()
{
Memory32Fixed(ReadWrite, 0xFED40000, 0x00005000)
})
OperationRegion(TPMR, SystemMemory, 0xFED40000, 0x5000)
Field(TPMR, AnyAcc, NoLock, Preserve)
{
ACC0, 8,
}
Method(_STA, 0, NotSerialized)
{
If(TPME)
{
If(LEqual(ACC0, 0xFF))
{
Return(0x00)
}
Return(0x0F)
}
Return(0x00)
}
OperationRegion(CMOS, SystemIO, 0x70, 0x04)
Field(CMOS, ByteAcc, NoLock, Preserve)
{
IDX0, 8,
DAT0, 8,
IDX1, 8,
DAT1, 8,
}
IndexField(IDX1, DAT1, ByteAcc, NoLock, Preserve)
{
Offset(0x60), //Offset(96),
CCMD, 4,
LCMD, 4,
LRET, 32,
MOR, 8,
}
Name(PPI1, Buffer(0x08){})
CreateDWordField(PPI1, 0x00, INT1)
CreateDWordField(PPI1, 0x04, INT2)
Name(PPI2, Buffer(0x0C){})
CreateDWordField(PPI2, 0x00, INT3)
CreateDWordField(PPI2, 0x04, INT4)
CreateDWordField(PPI2, 0x08, INT5)
Method(_DSM, 4, NotSerialized)
{
Name(_T_2, Zero)
Name(_T_1, Zero)
Name(_T_0, Zero)
If(LEqual(Arg0, ToUUID("CF8E16A5-C1E84E25-B7124F54A96702C8")}))
{
Store(ToInteger(Arg2), _T_0)
If(LEqual(_T_0, 0x00))
{
Return(Buffer(0x01)
{
0x03
})
}
Else
{
If(LEqual(_T_0, 0x01))
{
If(LEqual(_STA(), 0x00))
{
Return(Package(1) {0x00})
}
Return(Package(2)
{
0x01,
Package(2) {0x01, 0x20}
})
}
Else {}
}
}
If(LEqual(Arg0, ToUUID("3DDDFAA6-361B4EB4-A4248D10089D1653")}))
{
Store(ToInteger(Arg2), _T_1)
If(LEqual(_T_1, 0x00))
{
Return(Buffer(0x01)
{
0x7F
})
}
Else
{
If(LEqual(_T_1, 0x01))
{
Return("1.0")
}
Else
{
If(LEqual(_T_1, 0x02))
{
Store(ToInteger(DerefOf(Index(Arg3, 0x00))), CCMD)
Return(0x00)
}
Else
{
If(LEqual(_T_1, 0x03))
{
Store(0x00, INT1)
Store(CCMD, INT2)
Return(PPI1)
}
Else
{
If(LEqual(_T_1, 0x04))
{
Return(0x02)
}
Else
{
If(LEqual(_T_1, 0x05))
{
Store(0x00, INT3)
Store(LCMD, INT4)
Store(LRET, INT5)
Return(PPI2)
}
Else
{
If(LEqual(_T_1, 0x06))
{
Return(0x00)
}
Else
{
BreakPoint
}
}
}
}
}
}
}
}
If(LEqual(Arg0, ToUUID("376054ED-CC134675-901C4756D7F2D45D")}))
{
Store(Arg2, _T_2)
If(LEqual(_T_2, 0x00))
{
Return(Buffer(0x01)
{
0x03
})
}
Else
{
If(LEqual(_T_2, 0x01))
{
Store(Index(Arg3, 0x00), MOR)
Return(0x00)
}
Else
{
BreakPoint
}
}
}
Return(Buffer(0x01)
{
0x00
})
}
}
}
Device(SAT1)
{
Name(_ADR, 0x001F0002)
OperationRegion(IDER, PCI_Config, 0x40, 0x20)
Field(IDER, AnyAcc, NoLock, Preserve)
{
PFT0, 1,
PIE0, 1,
PPE0, 1,
PDE0, 1,
PFT1, 1,
PIE1, 1,
PPE1, 1,
PDE1, 1,
PRT0, 2,
, 2,
PIP0, 2,
PSIT, 1,
PIDE, 1,
SFT0, 1,
SIE0, 1,
SPE0, 1,
SDE0, 1,
SFT1, 1,
SIE1, 1,
SPE1, 1,
SDE1, 1,
SRT0, 2,
, 2,
SIP0, 2,
SSIT, 1,
SIDE, 1,
PRT1, 2,
PIP1, 2,
SRT1, 2,
SIP1, 2,
Offset(0x8), //Offset(8),
UDM0, 1,
UDM1, 1,
UDM2, 1,
UDM3, 1,
Offset(0xA), //Offset(10),
PCT0, 2,
, 2,
PCT1, 2,
, 2,
SCT0, 2,
, 2,
SCT1, 2,
Offset(0x14), //Offset(20),
PCB0, 1,
PCB1, 1,
SCB0, 1,
SCB1, 1,
PCCR, 2,
SCCR, 2,
, 4,
PUM0, 1,
PUM1, 1,
SUM0, 1,
SUM1, 1,
PSIG, 2,
SSIG, 2,
}
Method(GPIO, 4, NotSerialized)
{
If(LEqual(Or(Arg0, Arg1), 0x00))
{
Return(0xFFFFFFFF)
}
Else
{
If(And(LEqual(Arg0, 0x00), LEqual(Arg1, 0x01)))
{
Return(0x0384)
}
}
Return(Multiply(0x1E, Subtract(0x09, Add(Arg2, Arg3))))
}
Method(GDMA, 5, NotSerialized)
{
If(LEqual(Arg0, 0x01))
{
If(LEqual(Arg1, 0x01))
{
If(LEqual(Arg4, 0x02))
{
Return(0x0F)
}
Return(0x14)
}
If(LEqual(Arg2, 0x01))
{
Return(Multiply(0x0F, Subtract(0x04, Arg4)))
}
Return(Multiply(0x1E, Subtract(0x04, Arg4)))
}
Return(0xFFFFFFFE)
}
Method(SFLG, 5, NotSerialized)
{
Store(0x00, Local0)
Or(Arg1, Local0, Local0)
Or(ShiftLeft(Arg0, 0x01), Local0, Local0)
Or(ShiftLeft(Arg2, 0x03), Local0, Local0)
Or(ShiftLeft(Arg3, 0x02), Local0, Local0)
Or(ShiftLeft(Arg4, 0x04), Local0, Local0)
Return(Local0)
}
Method(SPIO, 3, NotSerialized)
{
Name(PBUF, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00, 0x00
})
CreateByteField(PBUF,0x00,RCT)
CreateByteField(PBUF,0x01,ISP)
CreateByteField(PBUF,0x02,FAST)
CreateByteField(PBUF,0x03,DMAE)
CreateByteField(PBUF,0x04,PIOT)
If(LOr(LEqual(Arg0, 0x00), LEqual(Arg0, 0xFFFFFFFF)))
{
Return(PBUF)
}
If(LGreater(Arg0, 0xF0))
{
Store(0x01, DMAE)
Store(0x00, PIOT)
}
Else
{
Store(0x01, FAST)
If(And(Arg1, 0x02))
{
If(And(LEqual(Arg0, 0x78), And(Arg2, 0x02)))
{
Store(0x03, RCT)
Store(0x02, ISP)
Store(0x04, PIOT)
}
Else
{
If(And(LLessEqual(Arg0, 0xB4), And(Arg2, 0x01)))
{
Store(0x01, RCT)
Store(0x02, ISP)
Store(0x03, PIOT)
}
Else
{
Store(0x00, RCT)
Store(0x01, ISP)
Store(0x02, PIOT)
}
}
}
}
Return(PBUF)
}
Method(SDMA, 3, NotSerialized)
{
Name(PBUF, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(PBUF,0x00,PCT)
CreateByteField(PBUF,0x01,PCB)
CreateByteField(PBUF,0x02,UDMT)
CreateByteField(PBUF,0x03,UDME)
CreateByteField(PBUF,0x04,DMAT)
If(LOr(LEqual(Arg0, 0x00), LEqual(Arg0, 0xFFFFFFFF)))
{
Return(PBUF)
}
If(LLessEqual(Arg0, 0x78))
{
If(And(Arg1, 0x04))
{
Store(0x01, UDME)
If(And(LEqual(Arg0, 0x0F), And(Arg2, 0x40)))
{
Store(0x01, UDMT)
Store(0x01, PCB)
Store(0x02, PCT)
Store(0x06, DMAT)
}
Else
{
If(And(LEqual(Arg0, 0x14), And(Arg2, 0x20)))
{
Store(0x01, UDMT)
Store(0x01, PCB)
Store(0x01, PCT)
Store(0x05, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x1E), And(Arg2, 0x10)))
{
Store(0x01, PCB)
Store(0x02, PCT)
Store(0x04, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x2D), And(Arg2, 0x08)))
{
Store(0x01, PCB)
Store(0x01, PCT)
Store(0x03, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x3C), And(Arg2, 0x04)))
{
Store(0x02, PCT)
Store(0x02, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x5A), And(Arg2, 0x02)))
{
Store(0x01, PCT)
Store(0x01, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x78), And(Arg2, 0x01)))
{
Store(0x00, DMAT)
}
}
}
}
}
}
}
}
}
Return(PBUF)
}
Device(PRID)
{
Name(_ADR, 0x00)
Name(TDM0, 0x00)
Name(TPI0, 0x00)
Name(TDM1, 0x00)
Name(TPI1, 0x00)
Method(_GTM, 0, NotSerialized)
{
Name(PBUF, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
CreateDWordField(PBUF, 0x00, PIO0)
CreateDWordField(PBUF, 0x04, DMA0)
CreateDWordField(PBUF, 0x08, PIO1)
CreateDWordField(PBUF, 0x0C, DMA1)
CreateDWordField(PBUF, 0x10, FLAG)
Store(GPIO(PFT0, PDE0, PRT0, PIP0), PIO0)
If(And(PSIT, 0x01))
{
Store(GPIO(PFT1, PDE1, PRT1, PIP1), PIO1)
}
Else
{
Store(GPIO(PFT1, PDE1, PRT0, PIP0), PIO1)
}
If(LEqual(PIO0, 0xFFFFFFFF))
{
Store(PIO0, DMA0)
}
Else
{
Store(GDMA(UDM0, PUM0, PCB0, And(PCCR, 0x01), PCT0), DMA0)
If(LGreater(DMA0, PIO0))
{
Store(PIO0, DMA0)
}
}
If(LEqual(PIO1, 0xFFFFFFFF))
{
Store(PIO1, DMA1)
}
Else
{
Store(GDMA(UDM1, PUM1, PCB1, And(PCCR, 0x02), PCT1), DMA1)
If(LGreater(DMA1, PIO1))
{
Store(PIO1, DMA1)
}
}
Store(SFLG(PIE0, UDM0, PIE1, UDM1, 0x01), FLAG)
Return(PBUF)
}
Method(_STM, 3, NotSerialized)
{
CreateDWordField(Arg0, 0x00, PIO0)
CreateDWordField(Arg0, 0x04, DMA0)
CreateDWordField(Arg0, 0x08, PIO1)
CreateDWordField(Arg0, 0x0C, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
CreateWordField(Arg1, 0x6A, RPS0)
CreateWordField(Arg1, 0x80, IOM0)
CreateWordField(Arg1, 0xB0, DMM0)
CreateWordField(Arg2, 0x6A, RPS1)
CreateWordField(Arg2, 0x80, IOM1)
CreateWordField(Arg2, 0xB0, DMM1)
Name(IOTM, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(IOTM,0x00,RCT)
CreateByteField(IOTM,0x01,ISP)
CreateByteField(IOTM,0x02,FAST)
CreateByteField(IOTM,0x03,DMAE)
CreateByteField(IOTM,0x04,TPIO)
Name(DMAT, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(DMAT,0x00,PCT)
CreateByteField(DMAT,0x01,PCB)
CreateByteField(DMAT,0x02,UDMT)
CreateByteField(DMAT,0x03,UDME)
CreateByteField(DMAT,0x04,TDMA)
If(And(FLAG, 0x10))
{
Store(0x01, PSIT)
}
Store(SPIO(PIO0, RPS0, IOM0), IOTM)
If(Or(DMAE, FAST))
{
Store(RCT, PRT0)
Store(ISP, PIP0)
Store(FAST, PFT0)
Store(DMAE, PDE0)
Store(TPIO, TPI0)
}
Store(SPIO(PIO1, RPS1, IOM1), IOTM)
If(Or(DMAE, FAST))
{
Store(FAST, PFT1)
Store(DMAE, PDE1)
Store(TPIO, TPI1)
If(And(PSIT, 0x01))
{
Store(RCT, PRT1)
Store(ISP, PIP1)
}
Else
{
Store(RCT, PRT0)
Store(ISP, PIP0)
}
}
If(And(FLAG, 0x01))
{
Store(SDMA(DMA0, RPS0, DMM0), DMAT)
Store(PCT, PCT0)
Store(PCB, PCB0)
Store(UDME, UDM0)
Store(UDMT, PUM0)
Store(TDMA, TDM0)
}
Else
{
Store(0x00, UDM0)
}
If(And(FLAG, 0x04))
{
Store(SDMA(DMA1, RPS1, DMM1), DMAT)
Store(PCT, PCT1)
Store(PCB, PCB1)
Store(UDME, UDM1)
Store(UDMT, PUM1)
Store(TDMA, TDM1)
}
Else
{
Store(0x00, UDM1)
}
If(And(FLAG, 0x02))
{
Store(0x01, PIE0)
}
If(And(FLAG, 0x08))
{
Store(0x01, PIE1)
}
}
Device(MAST)
{
Name(_ADR, 0x00)
Method(_GTF, 0, NotSerialized)
{
Name(ATA0, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField(ATA0,0x01,PIO0)
CreateByteField(ATA0,0x08,DMA0)
Store(TPI0, PIO0)
Or(PIO0, 0x08, PIO0)
If(And(UDM0, 0x01))
{
Store(TDM0, DMA0)
Or(DMA0, 0x40, DMA0)
}
Else
{
Store(TPI0, DMA0)
If(LNotEqual(DMA0, 0x00))
{
Subtract(DMA0, 0x02)
}
Or(DMA0, 0x20, DMA0)
}
Return(ATA0)
}
}
Device(SLAV)
{
Name(_ADR, 0x01)
Method(_GTF, 0, NotSerialized)
{
Name(ATA1, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
})
CreateByteField(ATA1,0x01,PIO1)
CreateByteField(ATA1,0x08,DMA1)
Store(TPI1, PIO1)
Or(PIO1, 0x08, PIO1)
If(And(UDM1, 0x01))
{
Store(TDM1, DMA1)
Or(DMA1, 0x40, DMA1)
}
Else
{
Store(TPI1, DMA1)
If(LNotEqual(DMA1, 0x00))
{
Subtract(DMA1, 0x02)
}
Or(DMA1, 0x20, DMA1)
}
Return(ATA1)
}
}
}
Device(SECD)
{
Name(_ADR, 0x01)
Name(TDM0, 0x00)
Name(TPI0, 0x00)
Name(TDM1, 0x00)
Name(TPI1, 0x00)
Name(DMT1, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(DMT2, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(POT1, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(POT2, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(STMI, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
Method(_GTM, 0, NotSerialized)
{
Name(PBUF, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
CreateDWordField(PBUF, 0x00, PIO0)
CreateDWordField(PBUF, 0x04, DMA0)
CreateDWordField(PBUF, 0x08, PIO1)
CreateDWordField(PBUF, 0x0C, DMA1)
CreateDWordField(PBUF, 0x10, FLAG)
Store(GPIO(SFT0, SDE0, SRT0, SIP0), PIO0)
If(And(SSIT, 0x01))
{
Store(GPIO(SFT1, SDE1, SRT1, SIP1), PIO1)
}
Else
{
Store(GPIO(SFT1, SDE1, SRT0, SIP0), PIO1)
}
If(LEqual(PIO0, 0xFFFFFFFF))
{
Store(PIO0, DMA0)
}
Else
{
Store(GDMA(UDM2, SUM0, SCB0, And(SCCR, 0x01), SCT0), DMA0)
If(LGreater(DMA0, PIO0))
{
Store(PIO0, DMA0)
}
}
If(LEqual(PIO1, 0xFFFFFFFF))
{
Store(PIO1, DMA1)
}
Else
{
Store(GDMA(UDM3, SUM1, SCB1, And(SCCR, 0x02), SCT1), DMA1)
If(LGreater(DMA1, PIO1))
{
Store(PIO1, DMA1)
}
}
Store(SFLG(SIE0, UDM2, SIE1, UDM3, 0x01), FLAG)
Return(PBUF)
}
Method(_STM, 3, NotSerialized)
{
CreateDWordField(Arg0, 0x00, PIO0)
CreateDWordField(Arg0, 0x04, DMA0)
CreateDWordField(Arg0, 0x08, PIO1)
CreateDWordField(Arg0, 0x0C, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
Store(Arg0, STMI)
CreateWordField(Arg1, 0x6A, RPS0)
CreateWordField(Arg1, 0x80, IOM0)
CreateWordField(Arg1, 0xB0, DMM0)
CreateWordField(Arg2, 0x6A, RPS1)
CreateWordField(Arg2, 0x80, IOM1)
CreateWordField(Arg2, 0xB0, DMM1)
Name(IOTM, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(IOTM,0x00,RCT)
CreateByteField(IOTM,0x01,ISP)
CreateByteField(IOTM,0x02,FAST)
CreateByteField(IOTM,0x03,DMAE)
CreateByteField(IOTM,0x04,TPIO)
Name(DMAT, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(DMAT,0x00,PCT)
CreateByteField(DMAT,0x01,PCB)
CreateByteField(DMAT,0x02,UDMT)
CreateByteField(DMAT,0x03,UDME)
CreateByteField(DMAT,0x04,TDMA)
If(And(FLAG, 0x10))
{
Store(0x01, SSIT)
}
Store(SPIO(PIO0, RPS0, IOM0), IOTM)
If(Or(DMAE, FAST))
{
Store(RCT, SRT0)
Store(ISP, SIP0)
Store(FAST, SFT0)
Store(DMAE, SDE0)
Store(TPIO, TPI0)
}
Store(SPIO(PIO1, RPS1, IOM1), IOTM)
Store(IOTM, POT2)
If(Or(DMAE, FAST))
{
Store(FAST, SFT1)
Store(DMAE, SDE1)
Store(TPIO, TPI1)
If(And(SSIT, 0x01))
{
Store(RCT, SRT1)
Store(ISP, SIP1)
}
Else
{
Store(RCT, SRT0)
Store(ISP, SIP0)
}
}
If(And(FLAG, 0x01))
{
Store(SDMA(DMA0, RPS0, DMM0), DMAT)
Store(PCT, SCT0)
Store(PCB, SCB0)
Store(UDME, UDM2)
Store(UDMT, SUM0)
Store(TDMA, TDM0)
}
Else
{
Store(0x00, UDM2)
}
If(And(FLAG, 0x04))
{
Store(SDMA(DMA1, RPS1, DMM1), DMAT)
Store(PCT, SCT1)
Store(PCB, SCB1)
Store(UDME, UDM3)
Store(UDMT, SUM1)
Store(TDMA, TDM1)
}
Else
{
Store(0x00, UDM3)
}
If(And(FLAG, 0x02))
{
Store(0x01, SIE0)
}
If(And(FLAG, 0x08))
{
Store(0x01, SIE1)
}
}
Device(MAST)
{
Name(_ADR, 0x00)
Method(_GTF, 0, NotSerialized)
{
Name(ATA0, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField(ATA0,0x01,PIO0)
CreateByteField(ATA0,0x08,DMA0)
Store(TPI0, PIO0)
Or(PIO0, 0x08, PIO0)
If(And(UDM2, 0x01))
{
Store(TDM0, DMA0)
Or(DMA0, 0x40, DMA0)
}
Else
{
Store(TPI0, DMA0)
If(LNotEqual(DMA0, 0x00))
{
Subtract(DMA0, 0x02)
}
Or(DMA0, 0x20, DMA0)
}
Return(ATA0)
}
}
Device(SLAV)
{
Name(_ADR, 0x01)
Method(_GTF, 0, NotSerialized)
{
Name(ATA1, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
})
CreateByteField(ATA1,0x01,PIO1)
CreateByteField(ATA1,0x08,DMA1)
Store(TPI1, PIO1)
Or(PIO1, 0x08, PIO1)
If(And(UDM3, 0x01))
{
Store(TDM1, DMA1)
Or(DMA1, 0x40, DMA1)
}
Else
{
Store(TPI1, DMA1)
If(LNotEqual(DMA1, 0x00))
{
Subtract(DMA1, 0x02)
}
Or(DMA1, 0x20, DMA1)
}
Return(ATA1)
}
}
}
}
Device(CHAP)
{
Name(_ADR, 0x001F0004)
}
Device(SAT2)
{
Name(_ADR, 0x001F0005)
OperationRegion(IDER, PCI_Config, 0x40, 0x20)
Field(IDER, AnyAcc, NoLock, Preserve)
{
PFT0, 1,
PIE0, 1,
PPE0, 1,
PDE0, 1,
PFT1, 1,
PIE1, 1,
PPE1, 1,
PDE1, 1,
PRT0, 2,
, 2,
PIP0, 2,
PSIT, 1,
PIDE, 1,
SFT0, 1,
SIE0, 1,
SPE0, 1,
SDE0, 1,
SFT1, 1,
SIE1, 1,
SPE1, 1,
SDE1, 1,
SRT0, 2,
, 2,
SIP0, 2,
SSIT, 1,
SIDE, 1,
PRT1, 2,
PIP1, 2,
SRT1, 2,
SIP1, 2,
Offset(0x8), //Offset(8),
UDM0, 1,
UDM1, 1,
UDM2, 1,
UDM3, 1,
Offset(0xA), //Offset(10),
PCT0, 2,
, 2,
PCT1, 2,
, 2,
SCT0, 2,
, 2,
SCT1, 2,
Offset(0x14), //Offset(20),
PCB0, 1,
PCB1, 1,
SCB0, 1,
SCB1, 1,
PCCR, 2,
SCCR, 2,
, 4,
PUM0, 1,
PUM1, 1,
SUM0, 1,
SUM1, 1,
PSIG, 2,
SSIG, 2,
}
Method(GPIO, 4, NotSerialized)
{
If(LEqual(Or(Arg0, Arg1), 0x00))
{
Return(0xFFFFFFFF)
}
Else
{
If(And(LEqual(Arg0, 0x00), LEqual(Arg1, 0x01)))
{
Return(0x0384)
}
}
Return(Multiply(0x1E, Subtract(0x09, Add(Arg2, Arg3))))
}
Method(GDMA, 5, NotSerialized)
{
If(LEqual(Arg0, 0x01))
{
If(LEqual(Arg1, 0x01))
{
If(LEqual(Arg4, 0x02))
{
Return(0x0F)
}
Return(0x14)
}
If(LEqual(Arg2, 0x01))
{
Return(Multiply(0x0F, Subtract(0x04, Arg4)))
}
Return(Multiply(0x1E, Subtract(0x04, Arg4)))
}
Return(0xFFFFFFFE)
}
Method(SFLG, 5, NotSerialized)
{
Store(0x00, Local0)
Or(Arg1, Local0, Local0)
Or(ShiftLeft(Arg0, 0x01), Local0, Local0)
Or(ShiftLeft(Arg2, 0x03), Local0, Local0)
Or(ShiftLeft(Arg3, 0x02), Local0, Local0)
Or(ShiftLeft(Arg4, 0x04), Local0, Local0)
Return(Local0)
}
Method(SPIO, 3, NotSerialized)
{
Name(PBUF, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00, 0x00
})
CreateByteField(PBUF,0x00,RCT)
CreateByteField(PBUF,0x01,ISP)
CreateByteField(PBUF,0x02,FAST)
CreateByteField(PBUF,0x03,DMAE)
CreateByteField(PBUF,0x04,PIOT)
If(LOr(LEqual(Arg0, 0x00), LEqual(Arg0, 0xFFFFFFFF)))
{
Return(PBUF)
}
If(LGreater(Arg0, 0xF0))
{
Store(0x01, DMAE)
Store(0x00, PIOT)
}
Else
{
Store(0x01, FAST)
If(And(Arg1, 0x02))
{
If(And(LEqual(Arg0, 0x78), And(Arg2, 0x02)))
{
Store(0x03, RCT)
Store(0x02, ISP)
Store(0x04, PIOT)
}
Else
{
If(And(LLessEqual(Arg0, 0xB4), And(Arg2, 0x01)))
{
Store(0x01, RCT)
Store(0x02, ISP)
Store(0x03, PIOT)
}
Else
{
Store(0x00, RCT)
Store(0x01, ISP)
Store(0x02, PIOT)
}
}
}
}
Return(PBUF)
}
Method(SDMA, 3, NotSerialized)
{
Name(PBUF, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(PBUF,0x00,PCT)
CreateByteField(PBUF,0x01,PCB)
CreateByteField(PBUF,0x02,UDMT)
CreateByteField(PBUF,0x03,UDME)
CreateByteField(PBUF,0x04,DMAT)
If(LOr(LEqual(Arg0, 0x00), LEqual(Arg0, 0xFFFFFFFF)))
{
Return(PBUF)
}
If(LLessEqual(Arg0, 0x78))
{
If(And(Arg1, 0x04))
{
Store(0x01, UDME)
If(And(LEqual(Arg0, 0x0F), And(Arg2, 0x40)))
{
Store(0x01, UDMT)
Store(0x01, PCB)
Store(0x02, PCT)
Store(0x06, DMAT)
}
Else
{
If(And(LEqual(Arg0, 0x14), And(Arg2, 0x20)))
{
Store(0x01, UDMT)
Store(0x01, PCB)
Store(0x01, PCT)
Store(0x05, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x1E), And(Arg2, 0x10)))
{
Store(0x01, PCB)
Store(0x02, PCT)
Store(0x04, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x2D), And(Arg2, 0x08)))
{
Store(0x01, PCB)
Store(0x01, PCT)
Store(0x03, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x3C), And(Arg2, 0x04)))
{
Store(0x02, PCT)
Store(0x02, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x5A), And(Arg2, 0x02)))
{
Store(0x01, PCT)
Store(0x01, DMAT)
}
Else
{
If(And(LLessEqual(Arg0, 0x78), And(Arg2, 0x01)))
{
Store(0x00, DMAT)
}
}
}
}
}
}
}
}
}
Return(PBUF)
}
Device(PRID)
{
Name(_ADR, 0x00)
Name(TDM0, 0x00)
Name(TPI0, 0x00)
Name(TDM1, 0x00)
Name(TPI1, 0x00)
Method(_GTM, 0, NotSerialized)
{
Name(PBUF, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
CreateDWordField(PBUF, 0x00, PIO0)
CreateDWordField(PBUF, 0x04, DMA0)
CreateDWordField(PBUF, 0x08, PIO1)
CreateDWordField(PBUF, 0x0C, DMA1)
CreateDWordField(PBUF, 0x10, FLAG)
Store(GPIO(PFT0, PDE0, PRT0, PIP0), PIO0)
If(And(PSIT, 0x01))
{
Store(GPIO(PFT1, PDE1, PRT1, PIP1), PIO1)
}
Else
{
Store(GPIO(PFT1, PDE1, PRT0, PIP0), PIO1)
}
If(LEqual(PIO0, 0xFFFFFFFF))
{
Store(PIO0, DMA0)
}
Else
{
Store(GDMA(UDM0, PUM0, PCB0, And(PCCR, 0x01), PCT0), DMA0)
If(LGreater(DMA0, PIO0))
{
Store(PIO0, DMA0)
}
}
If(LEqual(PIO1, 0xFFFFFFFF))
{
Store(PIO1, DMA1)
}
Else
{
Store(GDMA(UDM1, PUM1, PCB1, And(PCCR, 0x02), PCT1), DMA1)
If(LGreater(DMA1, PIO1))
{
Store(PIO1, DMA1)
}
}
Store(SFLG(PIE0, UDM0, PIE1, UDM1, 0x01), FLAG)
Return(PBUF)
}
Method(_STM, 3, NotSerialized)
{
CreateDWordField(Arg0, 0x00, PIO0)
CreateDWordField(Arg0, 0x04, DMA0)
CreateDWordField(Arg0, 0x08, PIO1)
CreateDWordField(Arg0, 0x0C, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
CreateWordField(Arg1, 0x6A, RPS0)
CreateWordField(Arg1, 0x80, IOM0)
CreateWordField(Arg1, 0xB0, DMM0)
CreateWordField(Arg2, 0x6A, RPS1)
CreateWordField(Arg2, 0x80, IOM1)
CreateWordField(Arg2, 0xB0, DMM1)
Name(IOTM, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(IOTM,0x00,RCT)
CreateByteField(IOTM,0x01,ISP)
CreateByteField(IOTM,0x02,FAST)
CreateByteField(IOTM,0x03,DMAE)
CreateByteField(IOTM,0x04,TPIO)
Name(DMAT, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(DMAT,0x00,PCT)
CreateByteField(DMAT,0x01,PCB)
CreateByteField(DMAT,0x02,UDMT)
CreateByteField(DMAT,0x03,UDME)
CreateByteField(DMAT,0x04,TDMA)
If(And(FLAG, 0x10))
{
Store(0x01, PSIT)
}
Store(SPIO(PIO0, RPS0, IOM0), IOTM)
If(Or(DMAE, FAST))
{
Store(RCT, PRT0)
Store(ISP, PIP0)
Store(FAST, PFT0)
Store(DMAE, PDE0)
Store(TPIO, TPI0)
}
Store(SPIO(PIO1, RPS1, IOM1), IOTM)
If(Or(DMAE, FAST))
{
Store(FAST, PFT1)
Store(DMAE, PDE1)
Store(TPIO, TPI1)
If(And(PSIT, 0x01))
{
Store(RCT, PRT1)
Store(ISP, PIP1)
}
Else
{
Store(RCT, PRT0)
Store(ISP, PIP0)
}
}
If(And(FLAG, 0x01))
{
Store(SDMA(DMA0, RPS0, DMM0), DMAT)
Store(PCT, PCT0)
Store(PCB, PCB0)
Store(UDME, UDM0)
Store(UDMT, PUM0)
Store(TDMA, TDM0)
}
Else
{
Store(0x00, UDM0)
}
If(And(FLAG, 0x04))
{
Store(SDMA(DMA1, RPS1, DMM1), DMAT)
Store(PCT, PCT1)
Store(PCB, PCB1)
Store(UDME, UDM1)
Store(UDMT, PUM1)
Store(TDMA, TDM1)
}
Else
{
Store(0x00, UDM1)
}
If(And(FLAG, 0x02))
{
Store(0x01, PIE0)
}
If(And(FLAG, 0x08))
{
Store(0x01, PIE1)
}
}
Device(MAST)
{
Name(_ADR, 0x00)
Method(_GTF, 0, NotSerialized)
{
Name(ATA0, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField(ATA0,0x01,PIO0)
CreateByteField(ATA0,0x08,DMA0)
Store(TPI0, PIO0)
Or(PIO0, 0x08, PIO0)
If(And(UDM0, 0x01))
{
Store(TDM0, DMA0)
Or(DMA0, 0x40, DMA0)
}
Else
{
Store(TPI0, DMA0)
If(LNotEqual(DMA0, 0x00))
{
Subtract(DMA0, 0x02)
}
Or(DMA0, 0x20, DMA0)
}
Return(ATA0)
}
}
Device(SLAV)
{
Name(_ADR, 0x01)
Method(_GTF, 0, NotSerialized)
{
Name(ATA1, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
})
CreateByteField(ATA1,0x01,PIO1)
CreateByteField(ATA1,0x08,DMA1)
Store(TPI1, PIO1)
Or(PIO1, 0x08, PIO1)
If(And(UDM1, 0x01))
{
Store(TDM1, DMA1)
Or(DMA1, 0x40, DMA1)
}
Else
{
Store(TPI1, DMA1)
If(LNotEqual(DMA1, 0x00))
{
Subtract(DMA1, 0x02)
}
Or(DMA1, 0x20, DMA1)
}
Return(ATA1)
}
}
}
Device(SECD)
{
Name(_ADR, 0x01)
Name(TDM0, 0x00)
Name(TPI0, 0x00)
Name(TDM1, 0x00)
Name(TPI1, 0x00)
Name(DMT1, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(DMT2, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(POT1, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(POT2, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
Name(STMI, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
Method(_GTM, 0, NotSerialized)
{
Name(PBUF, Buffer(0x14)
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
})
CreateDWordField(PBUF, 0x00, PIO0)
CreateDWordField(PBUF, 0x04, DMA0)
CreateDWordField(PBUF, 0x08, PIO1)
CreateDWordField(PBUF, 0x0C, DMA1)
CreateDWordField(PBUF, 0x10, FLAG)
Store(GPIO(SFT0, SDE0, SRT0, SIP0), PIO0)
If(And(SSIT, 0x01))
{
Store(GPIO(SFT1, SDE1, SRT1, SIP1), PIO1)
}
Else
{
Store(GPIO(SFT1, SDE1, SRT0, SIP0), PIO1)
}
If(LEqual(PIO0, 0xFFFFFFFF))
{
Store(PIO0, DMA0)
}
Else
{
Store(GDMA(UDM2, SUM0, SCB0, And(SCCR, 0x01), SCT0), DMA0)
If(LGreater(DMA0, PIO0))
{
Store(PIO0, DMA0)
}
}
If(LEqual(PIO1, 0xFFFFFFFF))
{
Store(PIO1, DMA1)
}
Else
{
Store(GDMA(UDM3, SUM1, SCB1, And(SCCR, 0x02), SCT1), DMA1)
If(LGreater(DMA1, PIO1))
{
Store(PIO1, DMA1)
}
}
Store(SFLG(SIE0, UDM2, SIE1, UDM3, 0x01), FLAG)
Return(PBUF)
}
Method(_STM, 3, NotSerialized)
{
CreateDWordField(Arg0, 0x00, PIO0)
CreateDWordField(Arg0, 0x04, DMA0)
CreateDWordField(Arg0, 0x08, PIO1)
CreateDWordField(Arg0, 0x0C, DMA1)
CreateDWordField(Arg0, 0x10, FLAG)
Store(Arg0, STMI)
CreateWordField(Arg1, 0x6A, RPS0)
CreateWordField(Arg1, 0x80, IOM0)
CreateWordField(Arg1, 0xB0, DMM0)
CreateWordField(Arg2, 0x6A, RPS1)
CreateWordField(Arg2, 0x80, IOM1)
CreateWordField(Arg2, 0xB0, DMM1)
Name(IOTM, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(IOTM,0x00,RCT)
CreateByteField(IOTM,0x01,ISP)
CreateByteField(IOTM,0x02,FAST)
CreateByteField(IOTM,0x03,DMAE)
CreateByteField(IOTM,0x04,TPIO)
Name(DMAT, Buffer(0x05)
{
0x00, 0x00, 0x00, 0x00
})
CreateByteField(DMAT,0x00,PCT)
CreateByteField(DMAT,0x01,PCB)
CreateByteField(DMAT,0x02,UDMT)
CreateByteField(DMAT,0x03,UDME)
CreateByteField(DMAT,0x04,TDMA)
If(And(FLAG, 0x10))
{
Store(0x01, SSIT)
}
Store(SPIO(PIO0, RPS0, IOM0), IOTM)
If(Or(DMAE, FAST))
{
Store(RCT, SRT0)
Store(ISP, SIP0)
Store(FAST, SFT0)
Store(DMAE, SDE0)
Store(TPIO, TPI0)
}
Store(SPIO(PIO1, RPS1, IOM1), IOTM)
Store(IOTM, POT2)
If(Or(DMAE, FAST))
{
Store(FAST, SFT1)
Store(DMAE, SDE1)
Store(TPIO, TPI1)
If(And(SSIT, 0x01))
{
Store(RCT, SRT1)
Store(ISP, SIP1)
}
Else
{
Store(RCT, SRT0)
Store(ISP, SIP0)
}
}
If(And(FLAG, 0x01))
{
Store(SDMA(DMA0, RPS0, DMM0), DMAT)
Store(PCT, SCT0)
Store(PCB, SCB0)
Store(UDME, UDM2)
Store(UDMT, SUM0)
Store(TDMA, TDM0)
}
Else
{
Store(0x00, UDM2)
}
If(And(FLAG, 0x04))
{
Store(SDMA(DMA1, RPS1, DMM1), DMAT)
Store(PCT, SCT1)
Store(PCB, SCB1)
Store(UDME, UDM3)
Store(UDMT, SUM1)
Store(TDMA, TDM1)
}
Else
{
Store(0x00, UDM3)
}
If(And(FLAG, 0x02))
{
Store(0x01, SIE0)
}
If(And(FLAG, 0x08))
{
Store(0x01, SIE1)
}
}
Device(MAST)
{
Name(_ADR, 0x00)
Method(_GTF, 0, NotSerialized)
{
Name(ATA0, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xA0, 0xEF
})
CreateByteField(ATA0,0x01,PIO0)
CreateByteField(ATA0,0x08,DMA0)
Store(TPI0, PIO0)
Or(PIO0, 0x08, PIO0)
If(And(UDM2, 0x01))
{
Store(TDM0, DMA0)
Or(DMA0, 0x40, DMA0)
}
Else
{
Store(TPI0, DMA0)
If(LNotEqual(DMA0, 0x00))
{
Subtract(DMA0, 0x02)
}
Or(DMA0, 0x20, DMA0)
}
Return(ATA0)
}
}
Device(SLAV)
{
Name(_ADR, 0x01)
Method(_GTF, 0, NotSerialized)
{
Name(ATA1, Buffer(0x0E)
{
0x03, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF, 0x03,
0x00, 0x00, 0x00, 0x00, 0xB0, 0xEF
})
CreateByteField(ATA1,0x01,PIO1)
CreateByteField(ATA1,0x08,DMA1)
Store(TPI1, PIO1)
Or(PIO1, 0x08, PIO1)
If(And(UDM3, 0x01))
{
Store(TDM1, DMA1)
Or(DMA1, 0x40, DMA1)
}
Else
{
Store(TPI1, DMA1)
If(LNotEqual(DMA1, 0x00))
{
Subtract(DMA1, 0x02)
}
Or(DMA1, 0x20, DMA1)
}
Return(ATA1)
}
}
}
}
Device(SMBS)
{
Name(_ADR, 0x001F0003)
}
Device(TERM)
{
Name(_ADR, 0x001F0006)
}
}
Device(SLPB)
{
Name(_HID, EISAID("PNP0C0E"))
Method(_PRW, 0, NotSerialized)
{
Return(Package(2) {0x1D, 0x04})
}
}
}
Scope(\_GPE)
{
Method(_L03, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC1, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L04, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC2, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L05, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC5, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L09, 0, NotSerialized)
{
Notify(\_SB.PCI0.MRP1, 0x02)
Notify(\_SB.PCI0.MRP1.ZOR1, 0x02)
Notify(\_SB.PCI0.MRP1.ZOR2, 0x02)
Notify(\_SB.PCI0.MRP3, 0x02)
Notify(\_SB.PCI0.MRP4, 0x02)
Notify(\_SB.PCI0.MRP5, 0x02)
Notify(\_SB.PCI0.MRP6, 0x02)
Notify(\_SB.PCI0.MRP7, 0x02)
Notify(\_SB.PCI0.MRP8, 0x02)
Notify(\_SB.PCI0.MRP9, 0x02)
Notify(\_SB.PCI0.MRPA, 0x02)
Notify(\_SB.PCI0.PEX0, 0x02)
Notify(\_SB.PCI0.PEX1, 0x02)
Notify(\_SB.PCI0.PEX2, 0x02)
Notify(\_SB.PCI0.PEX3, 0x02)
Notify(\_SB.PCI0.PEX4, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L0B, 0, NotSerialized)
{
Notify(\_SB.PCI0.IP2P, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L0C, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC3, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L0D, 0, NotSerialized)
{
Notify(\_SB.PCI0.EHC2, 0x02)
Notify(\_SB.PCI0.EHC1, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L0E, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC4, 0x02)
Notify(\_SB.SLPB, 0x02)
}
Method(_L20, 0, NotSerialized)
{
Notify(\_SB.PCI0.UHC6, 0x02)
Notify(\_SB.PCI0.UHCI, 0x02)
Notify(\_SB.SLPB, 0x02)
}
}
Method(_WAK, 1, Serialized)
{
Store(0x73, IO80)
\_SB.PCI0.HEC2.WAK()
If(LNotEqual(Arg0, 0x04))
{
\_SB.SWAF(0x50)
}
Notify(\_SB.PCI0.UHC1, 0x00)
Notify(\_SB.PCI0.UHC2, 0x00)
Notify(\_SB.PCI0.UHC3, 0x00)
Notify(\_SB.PCI0.UHC4, 0x00)
Notify(\_SB.PCI0.UHC5, 0x00)
Notify(\_SB.PCI0.UHC6, 0x00)
Notify(\_SB.PCI0.UHCI, 0x00)
Notify(\_SB.PCI0.EHC1, 0x00)
Notify(\_SB.PCI0.EHC2, 0x00)
Return(0x00)
}
Scope(\_SB)
{
OperationRegion(IOB2, SystemIO, 0xB2, 0x02)
Field(IOB2, ByteAcc, NoLock, Preserve)
{
SMIC, 8,
SMIS, 8,
}
Method(SWAF, 1, NotSerialized)
{
Mutex(MUT1, 0)
Acquire(MUT1, 0xFFFF)
Store(Arg0, \_SB.SMIS)
Store(0xAF, \_SB.SMIC)
Release(MUT1)
}
Name(\PCAP, 0x00010000)
Name(\WHEN, 0x00)
OperationRegion(CMOS, SystemIO, 0x70, 0x04)
Field(CMOS, ByteAcc, NoLock, Preserve)
{
IDX0, 7,
, 1,
DAT0, 8,
IDX1, 7,
, 1,
DAT1, 8,
}
IndexField(IDX1, DAT1, ByteAcc, NoLock, Preserve)
{
Offset(0x48), //Offset(72),
OSF1, 32,
OSF2, 32,
}
Method(SWWE, 1, NotSerialized)
{
Store(0x00, \_SB.SMIS)
Store(Arg0, \_SB.SMIC)
}
Device(WERR)
{
Name(_HID, EISAID("PNP0C33"))
Name(_UID, 0x00)
Method(_STA, 0, NotSerialized)
{
If(LEqual(\OSFL, 0x0A))
{
If(And(\PCAP, 0x00010000))
{
Return(0x0F)
}
}
Return(0x00)
}
}
Method(\_GPE._L1D, 0, NotSerialized)
{
Store(0x01, GP13)
Store(0xFE, IO80)
Notify(\_SB.WERR, 0x80)
}
Method(_OSC, 4, NotSerialized)
{
CreateDWordField(Arg3, 0x00, CPB1)
CreateDWordField(Arg3, 0x04, CPB2)
CreateDWordField(Arg3, 0x08, CPB3)
If(LEqual(Arg0, ToUUID("ED855E0C-6C9047BF-A62A26DE0FC5AD5C")}))
{
If(And(\PCAP, 0x00010000))
{
SWWE(0x9E)
Store(0x01, \WHEN)
Return(Arg3)
}
}
Store(0x00, \WHEN)
Or(CPB2, 0x04, CPB2)
Return(Arg3)
}
}
Scope(\_GPE)
{
OperationRegion(TCOS, SystemIO, 0x0464, 0x02)
Field(TCOS, ByteAcc, NoLock, WriteAsZeros)
{
, 8,
, 1,
DSCI, 1,
}
Method(_L06, 0, Serialized)
{
If(DSCI)
{
Store(0x01, DSCI)
\_SB.PCI0.HEC2.HSCI()
}
}
}
Scope(\_SI)
{
OperationRegion(SIOR, SystemIO, 0x0500, 0x30)
Field(SIOR, ByteAcc, NoLock, Preserve)
{
Offset(0xC), //Offset(12),
Offset(0xD), //Offset(13),
, 7,
PLED, 1,
Offset(0x18), //Offset(24),
Offset(0x19), //Offset(25),
, 7,
BLNK, 1,
}
Method(_SST, 1, NotSerialized)
{
If(Arg0)
{
If(LEqual(Arg0, 0x01))
{
Store(Zero, PLED)
Store(Zero, BLNK)
}
If(LEqual(Arg0, 0x02))
{
Store(Zero, PLED)
Store(Zero, BLNK)
}
If(LEqual(Arg0, 0x03))
{
Store(Zero, PLED)
Store(One, BLNK)
}
If(LEqual(Arg0, 0x04))
{
Store(One, PLED)
Store(Zero, BLNK)
}
}
Else
{
Store(One, PLED)
Store(Zero, BLNK)
}
}
Method(_MSG, 1, NotSerialized)
{
NoOp
}
}
}



Das gehoert vermutlich dazu

--/************************************************** ****************************
--*
--* INTEL CORPORATION CONFIDENTIAL INFORMATION
--* Copyright (c) 2001 Intel Corporation. All Rights Reserved.
--*
--*
--************************************************** ****************************/

--/************************************************** ****************************
-- *
-- * Revision History:
-- * edy - 10/13/08 removed unneeded variables
-- * edy - 1/14/09 added offsets for Upper threasholds going Low, and
-- * lower threasholds going high.
-- *
-- ************************************************** ***************************/

Ich finde da keinerlei Strings
 
Was willst du da für Strings finden? Das Bios ist dafür da den Bootloader zu laden damit dieser das betriesbsystem in den Speicher laden kann (deshalb denke ich checkt er zuerst welches OS geladen werden muss und welche Platten überhaupt bootfähig sind). Außerdem führt es noch spezielle Hardware tests durch und initalisiert diese. Ich denke zum lernen ist so etwas ganz schön overkill.

lowlevel.eu wäre wahrscheinlich eine bessere Anlaufstelle dafür
 
XPrototypeX schrieb:
Was willst du da für Strings finden? Das Bios ist dafür da den Bootloader zu laden damit dieser das betriesbsystem in den Speicher laden kann (deshalb denke ich checkt er zuerst welches OS geladen werden muss und welche Platten überhaupt bootfähig sind). Außerdem führt es noch spezielle Hardware tests durch und initalisiert diese. Ich denke zum lernen ist so etwas ganz schön overkill.

lowlevel.eu wäre wahrscheinlich eine bessere Anlaufstelle dafür
Zum Vergrößern anklicken....

War halt nur unerwartet , ich habe gedacht das das ganze BIOS in Assembler geschrieben ist was ja in vielen aelteren der Fall war
 
DSDT = Differentiated System Description Table, das ist eine ACPI Tabelle. Und der Code scheint mir ACPI Machine Language (AML) zu sein. Die DSDT beschreibt im Prinzip, welche Komponenten der Rechner hat und enthält auch einige andere Informationen, z. B. IRQ Mapping.
 
Das ist schon Teil des BIOS, da diese ACPI Tabellen im BIOS stehen bzw. vom BIOS generiert werden. Ich zitiere mal aus Wikipedia:
DSDT beschreibt implementierte Systemfunktionen wie Energieverwaltung, Plug and Play und Kühlung in sogenannten Definition Blocks. Definition Blocks enthalten neben Informationen zur Ansteuerung auch in AML (ACPI Machine Language) kodierte Steuerfunktionen. Die für ACPI-Funktionen in der DSDT eingetragenen Definition Blocks bilden die Grundlage für das Funktionieren der ACPI-Funktionen im System. Der DSDT Differentiated Definition Block wird beim Systemboot geladen und verbleibt im Speicher.
Zum Vergrößern anklicken....
 
Du musst dich einloggen oder registrieren, um hier zu antworten.

Ähnliche Themen

modx
Kann ich 2026 noch Zocken? Ein Problem, was sehr viele von uns 2026 betreffen wird erklärt
Antworten
17
Aufrufe
4K
modx
modx
L
Gigabyte Master 16 Laptop i9 275HX CPU taktet nicht hoch
Antworten
18
Aufrufe
993
Z3Rlot
Z3Rlot
B
Linux Rechner stellt sich bei wenigen Spielestarts vor dem Intro komplett aus
Antworten
15
Aufrufe
2K
BxBender
B
T
[Erledigt] RTX 2060 (S) hängt sich direkt nach Boot unter Last auf
Antworten
10
Aufrufe
1K
throws
T
C
Test Corsair Link - welche Lüfter und welche Kühlung?
Antworten
2
Aufrufe
3K
cbw249
C
Oben Unten
Zurück