Created
October 6, 2011 16:58
-
-
Save metaphys/1267940 to your computer and use it in GitHub Desktop.
/sys/firmware/acpi/tables/SSDT4 decoded by iasl on K93SV
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
ACPI Error: Argument count mismatch for method P8XH 4 2 (20100528/dmextern-387) | |
/* | |
* Intel ACPI Component Architecture | |
* AML Disassembler version 20100528 | |
* | |
* Disassembly of file, Thu Oct 6 18:46:50 2011 | |
* | |
* | |
* Original Table Header: | |
* Signature "SSDT" | |
* Length 0x00000E6B (3691) | |
* Revision 0x01 | |
* Checksum 0x2E | |
* OEM ID "OptRef" | |
* OEM Table ID "OptTabl" | |
* OEM Revision 0x00001000 (4096) | |
* Compiler ID "INTL" | |
* Compiler Version 0x20051117 (537202967) | |
*/ | |
DefinitionBlock ("file.aml", "SSDT", 1, "OptRef", "OptTabl", 0x00001000) | |
{ | |
External (DSDG) | |
External (FNF8) | |
External (P8XH, MethodObj) // 4 Arguments | |
External (DID8) | |
External (NXD8) | |
External (NXD7) | |
External (NXD6) | |
External (NXD5) | |
External (NXD4) | |
External (NXD3) | |
External (NXD2) | |
External (NXD1) | |
External (NVGA, MethodObj) // 1 Arguments | |
External (DID7, IntObj) | |
External (DID6, IntObj) | |
External (DID5, IntObj) | |
External (DID4, IntObj) | |
External (DID3, IntObj) | |
External (DID2, IntObj) | |
External (DID1, IntObj) | |
External (SGOF, MethodObj) // 0 Arguments | |
External (SGON, MethodObj) // 0 Arguments | |
External (EBAS, MethodObj) // 1 Arguments | |
External (NVHA, MethodObj) // 1 Arguments | |
External (\_SB_.PCI0, DeviceObj) | |
External (\_SB_.PCI0.GFX0, DeviceObj) | |
External (\_SB_.PCI0.GFX0._DSM, IntObj) | |
External (\_SB_.PCI0.PEG0.PEGP, DeviceObj) | |
External (\_SB_.PCI0.PEG0.PEGP.SGOF, MethodObj) // 0 Arguments | |
External (\_SB_.PCI0.PEG0.PEGP.SGON, MethodObj) // 0 Arguments | |
External (\_SB_.PCI0.PEG0.PEGP.SGST, MethodObj) // 0 Arguments | |
Scope (\_SB.PCI0) | |
{ | |
Name (OTM, "OTMACPI 2010-Mar-09 12:08:26") | |
} | |
Scope (\_SB.PCI0.PEG0.PEGP) | |
{ | |
OperationRegion (NVHM, SystemMemory, NVHA (0x00010400), Field (NVHM, AnyAcc, NoLock, Preserve) | |
{ | |
NVSG, 128, | |
NVSZ, 32, | |
NVVR, 32, | |
NVHO, 32, | |
RVBS, 32, | |
RBF1, 262144, | |
RBF2, 262144, | |
MXML, 32, | |
MXM3, 1600 | |
}) | |
Name (OPCE, 0x02) | |
Name (OPTF, One) | |
Name (DGPS, Zero) | |
Name (_PSC, Zero) | |
Method (_PS0, 0, NotSerialized) | |
{ | |
Store (Zero, _PSC) | |
If (LNotEqual (DGPS, Zero)) | |
{ | |
_ON () | |
Store (Zero, DGPS) | |
} | |
} | |
Method (_PS1, 0, NotSerialized) | |
{ | |
Store (One, _PSC) | |
} | |
Method (_PS3, 0, NotSerialized) | |
{ | |
If (LEqual (OPCE, 0x03)) | |
{ | |
If (LEqual (DGPS, Zero)) | |
{ | |
_OFF () | |
Store (One, DGPS) | |
} | |
Store (0x02, OPCE) | |
} | |
Store (0x03, _PSC) | |
} | |
Method (_STA, 0, NotSerialized) | |
{ | |
Return (0x0F) | |
} | |
Method (_ROM, 2, NotSerialized) | |
{ | |
Store (Arg0, Local0) | |
Store (Arg1, Local1) | |
If (LGreater (Local1, 0x1000)) | |
{ | |
Store (0x1000, Local1) | |
} | |
If (LGreater (Local0, 0x00010000)) | |
{ | |
Return (Buffer (Local1) | |
{ | |
0x00 | |
}) | |
} | |
Multiply (Local1, 0x08, Local3) | |
Name (ROM1, Buffer (0x8000) | |
{ | |
0x00 | |
}) | |
Name (ROM2, Buffer (Local1) | |
{ | |
0x00 | |
}) | |
If (LLess (Local0, 0x8000)) | |
{ | |
Store (RBF1, ROM1) | |
} | |
Else | |
{ | |
Subtract (Local0, 0x8000, Local0) | |
Store (RBF2, ROM1) | |
} | |
Multiply (Local0, 0x08, Local2) | |
CreateField (ROM1, Local2, Local3, TMPB) | |
Store (TMPB, ROM2) | |
Return (ROM2) | |
} | |
Method (HDSM, 4, Serialized) | |
{ | |
Return (0x80000001) | |
} | |
Method (_DSM, 4, Serialized) | |
{ | |
CreateByteField (Arg0, 0x03, GUID) | |
Return (\_SB.PCI0.GFX0.HDSM (Arg0, Arg1, Arg2, Arg3)) | |
} | |
OperationRegion (BPCI, SystemMemory, EBAS (0x1000), Field (BPCI, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
PCIC, 32, | |
Offset (0x10), | |
GMM1, 32, | |
GMM2, 32, | |
Offset (0x1C), | |
GMM3, 32, | |
Offset (0x24), | |
GIO1, 32, | |
Offset (0x3C), | |
GIRQ, 32, | |
SID, 32, | |
Offset (0x488), | |
, 25, | |
NHDM, 1 | |
}) | |
Name (BUFF, Buffer (0x20) {}) | |
CreateDWordField (BUFF, Zero, BUF1) | |
CreateDWordField (BUFF, One, BUF2) | |
CreateDWordField (BUFF, 0x02, BUF3) | |
CreateDWordField (BUFF, 0x03, BUF4) | |
CreateDWordField (BUFF, 0x04, BUF5) | |
CreateDWordField (BUFF, 0x05, BUF6) | |
CreateDWordField (BUFF, 0x06, BUF7) | |
CreateDWordField (BUFF, 0x07, BUF8) | |
Method (_ON, 0, Serialized) | |
{ | |
SGON () | |
Store (BUF1, PCIC) | |
Store (BUF2, GMM1) | |
Store (BUF3, GMM2) | |
Store (BUF4, GMM3) | |
Store (BUF5, GIO1) | |
Store (BUF6, GIRQ) | |
Store (BUF7, SID) | |
Sleep (0x64) | |
If (OPTF) | |
{ | |
Store (Zero, NHDM) | |
} | |
} | |
Method (_OFF, 0, Serialized) | |
{ | |
Store (PCIC, BUF1) | |
Store (GMM1, BUF2) | |
Store (GMM2, BUF3) | |
Store (GMM3, BUF4) | |
Store (GIO1, BUF5) | |
Store (GIRQ, BUF6) | |
Store (SID, BUF7) | |
SGOF () | |
} | |
} | |
Scope (\_SB.PCI0.GFX0) | |
{ | |
Method (_INI, 0, NotSerialized) | |
{ | |
Store (DID1, Index (TLPK, Zero)) | |
Store (DID2, Index (TLPK, 0x02)) | |
Store (DID3, Index (TLPK, 0x04)) | |
Store (DID4, Index (TLPK, 0x06)) | |
Store (DID5, Index (TLPK, 0x08)) | |
Store (DID6, Index (TLPK, 0x0A)) | |
Store (DID7, Index (TLPK, 0x0C)) | |
Store (DID2, Index (TLPK, 0x0E)) | |
Store (DID1, Index (TLPK, 0x0F)) | |
Store (DID2, Index (TLPK, 0x11)) | |
Store (DID3, Index (TLPK, 0x12)) | |
Store (DID2, Index (TLPK, 0x14)) | |
Store (DID4, Index (TLPK, 0x15)) | |
Store (DID2, Index (TLPK, 0x17)) | |
Store (DID5, Index (TLPK, 0x18)) | |
Store (DID2, Index (TLPK, 0x1A)) | |
Store (DID6, Index (TLPK, 0x1B)) | |
Store (DID2, Index (TLPK, 0x1D)) | |
Store (DID7, Index (TLPK, 0x1E)) | |
} | |
OperationRegion (NVIG, SystemMemory, NVGA (0x0400), Field (NVIG, AnyAcc, NoLock, Preserve) | |
{ | |
NISG, 128, | |
NISZ, 32, | |
NIVR, 32, | |
GPSS, 32, | |
GACD, 16, | |
GATD, 16, | |
LDES, 8, | |
DKST, 8, | |
DACE, 8, | |
DHPE, 8, | |
DHPS, 8, | |
SGNC, 8, | |
GPPO, 8, | |
USPM, 8, | |
GPSP, 8, | |
TLSN, 8, | |
DOSF, 8, | |
ELCL, 16 | |
}) | |
Name (TLPK, Package (0x20) | |
{ | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C, | |
Ones, | |
Ones, | |
0x2C | |
}) | |
Method (INDL, 0, Serialized) | |
{ | |
Store (Zero, NXD1) | |
Store (Zero, NXD2) | |
Store (Zero, NXD3) | |
Store (Zero, NXD4) | |
Store (Zero, NXD5) | |
Store (Zero, NXD6) | |
Store (Zero, NXD7) | |
Store (Zero, NXD8) | |
} | |
Method (SND1, 1, Serialized) | |
{ | |
If (LEqual (Arg0, DID1)) | |
{ | |
Store (One, NXD1) | |
} | |
If (LEqual (Arg0, DID2)) | |
{ | |
Store (One, NXD2) | |
} | |
If (LEqual (Arg0, DID3)) | |
{ | |
Store (One, NXD3) | |
} | |
If (LEqual (Arg0, DID4)) | |
{ | |
Store (One, NXD4) | |
} | |
If (LEqual (Arg0, DID5)) | |
{ | |
Store (One, NXD5) | |
} | |
If (LEqual (Arg0, DID6)) | |
{ | |
Store (One, NXD6) | |
} | |
If (LEqual (Arg0, DID7)) | |
{ | |
Store (One, NXD7) | |
} | |
If (LEqual (Arg0, DID8)) | |
{ | |
Store (One, NXD8) | |
} | |
} | |
Method (SNXD, 1, Serialized) | |
{ | |
INDL () | |
Store (One, Local0) | |
Store (Zero, Local1) | |
While (LLess (Local0, Arg0)) | |
{ | |
If (LEqual (DerefOf (Index (TLPK, Local1)), 0x2C)) | |
{ | |
Increment (Local0) | |
} | |
Increment (Local1) | |
} | |
SND1 (DerefOf (Index (TLPK, Local1))) | |
Increment (Local1) | |
If (LNotEqual (DerefOf (Index (TLPK, Local1)), 0x2C)) | |
{ | |
SND1 (DerefOf (Index (TLPK, Local1))) | |
} | |
} | |
Method (CTOI, 1, Serialized) | |
{ | |
Name (_T_0, Zero) | |
Store (ToInteger (Arg0), _T_0) | |
If (LEqual (_T_0, One)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x04)) | |
{ | |
Return (0x04) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x05)) | |
{ | |
Return (0x05) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x06)) | |
{ | |
Return (0x06) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Method (HDSM, 4, Serialized) | |
{ | |
Name (SGCI, Zero) | |
Name (NBCI, Zero) | |
Name (OPCI, Zero) | |
If (LEqual (Arg0, Buffer (0x10) | |
{ | |
/* 0000 */ 0xF8, 0xD8, 0x86, 0xA4, 0xDA, 0x0B, 0x1B, 0x47, | |
/* 0008 */ 0xA7, 0x2B, 0x60, 0x42, 0xA6, 0xB5, 0xBE, 0xE0 | |
})) | |
{ | |
Store (One, OPCI) | |
} | |
If (LOr (OPCI, LOr (SGCI, NBCI))) | |
{ | |
If (OPCI) | |
{ | |
If (LNotEqual (Arg1, 0x0100)) | |
{ | |
Return (0x80000002) | |
} | |
} | |
Else | |
{ | |
If (LNotEqual (Arg1, 0x0102)) | |
{ | |
Return (0x80000002) | |
} | |
} | |
If (LEqual (Arg2, Zero)) | |
{ | |
If (SGCI) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x7F, 0x00, 0x04, 0x00 | |
}) | |
} | |
Else | |
{ | |
If (NBCI) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x73, 0x00, 0x04, 0x00 | |
}) | |
} | |
Else | |
{ | |
If (OPCI) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x61, 0x18, 0x03, 0x0C | |
}) | |
} | |
} | |
} | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Name (TEMP, Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}) | |
CreateDWordField (TEMP, Zero, STS0) | |
If (SGCI) | |
{ | |
Or (STS0, 0x0B0000BF, STS0) | |
Or (STS0, ShiftLeft (SGNC, 0x08, SGNC), STS0) | |
} | |
Else | |
{ | |
Or (STS0, Zero, STS0) | |
} | |
Return (TEMP) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Name (TMP1, Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}) | |
CreateDWordField (TMP1, Zero, STS1) | |
ToInteger (Arg3, Local0) | |
And (Local0, 0x1F, Local0) | |
If (And (Local0, 0x10)) | |
{ | |
And (Local0, 0x0F, Local0) | |
Store (Local0, GPSS) | |
Notify (\_SB.PCI0.GFX0, 0xD9) | |
Notify (\_SB.PCI0.WMI1, 0xD9) | |
} | |
Else | |
{ | |
And (Local0, 0x0F, Local0) | |
If (LEqual (GPPO, One)) | |
{ | |
Store (GPSS, Local0) | |
Or (Local0, 0x10, Local0) | |
Store (Zero, GPPO) | |
} | |
} | |
Or (STS1, Local0, STS1) | |
Return (TMP1) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Name (TMP2, Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}) | |
CreateDWordField (TMP2, Zero, STS2) | |
ToInteger (Arg3, Local0) | |
And (Local0, 0x03, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
\_SB.PCI0.PEG0.PEGP.SGST () | |
} | |
If (LEqual (Local0, One)) | |
{ | |
\_SB.PCI0.PEG0.PEGP.SGON () | |
} | |
If (LEqual (Local0, 0x02)) | |
{ | |
\_SB.PCI0.PEG0.PEGP.SGOF () | |
} | |
If (LEqual (\_SB.PCI0.PEG0.PEGP.SGST (), 0x0F)) | |
{ | |
Or (STS2, One, STS2) | |
} | |
Return (TMP2) | |
} | |
If (LEqual (Arg2, 0x04)) | |
{ | |
Name (TMP3, Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}) | |
CreateDWordField (TMP3, Zero, STS3) | |
ToInteger (Arg3, Local0) | |
Store (Local0, Local1) | |
ShiftRight (Local0, 0x10, Local0) | |
And (Local0, One, USPM) | |
ShiftRight (Local1, 0x0D, Local1) | |
And (Local1, 0x03, Local1) | |
If (LNotEqual (Local1, GPSP)) | |
{ | |
If (LEqual (USPM, One)) | |
{ | |
Store (Local1, GPSP) | |
} | |
Else | |
{ | |
Store (GPSP, Local1) | |
Or (STS3, 0x8000, STS3) | |
} | |
} | |
Or (STS3, ShiftLeft (Local1, 0x0D), STS3) | |
Return (TMP3) | |
} | |
If (LEqual (Arg2, 0x05)) | |
{ | |
P8XH (Zero, 0xAA, Name (TMP4, Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}), CreateDWordField (TMP4, Zero, | |
STS4)) | |
ToInteger (Arg3, Local0) | |
If (And (Local0, 0x80000000)) | |
{ | |
Store (And (ShiftRight (Local0, 0x19), 0x1F), TLSN) | |
If (And (Local0, 0x40000000)) | |
{ | |
Store (One, DOSF) | |
} | |
} | |
If (And (Local0, 0x01000000)) | |
{ | |
Store (And (ShiftRight (Local0, 0x0C), 0x0FFF), GACD) | |
Store (And (Local0, 0x0FFF), GATD) | |
Store (CTOI (GACD), TLSN) | |
Increment (TLSN) | |
If (LGreater (TLSN, 0x06)) | |
{ | |
Store (One, TLSN) | |
} | |
SNXD (TLSN) | |
} | |
Or (STS4, ShiftLeft (DHPE, 0x15), STS4) | |
Or (STS4, ShiftLeft (DHPS, 0x14), STS4) | |
Or (STS4, ShiftLeft (FNF8, 0x08), STS4) | |
Or (STS4, ShiftLeft (DKST, 0x05), STS4) | |
Or (STS4, ShiftLeft (LDES, 0x04), STS4) | |
Or (STS4, DACE, STS4) | |
Store (Zero, LDES) | |
Store (Zero, DHPS) | |
Store (Zero, DHPE) | |
Store (Zero, DACE) | |
Store (Arg3, DSDG) | |
Return (TMP4) | |
} | |
If (LEqual (Arg2, 0x06)) | |
{ | |
P8XH (Zero, 0xBB, Return (Package (0x0F) | |
{ | |
0x0110, | |
0x2C, | |
0x80000100, | |
0x2C, | |
0x0110, | |
0x80000100, | |
0x2C, | |
0x80007330, | |
0x2C, | |
0x0110, | |
0x80007330, | |
0x2C, | |
0x80000100, | |
0x80007330, | |
0x2C | |
}), If (LEqual (Arg2, 0x10)) | |
{ | |
CreateWordField (Arg3, 0x02, USRG) | |
Name (OPVK, Buffer (0xE6) | |
{ | |
/* 0000 */ 0xE4, 0x42, 0x5F, 0x14, 0x36, 0x26, 0x16, 0x37, | |
/* 0008 */ 0x4B, 0x56, 0xE6, 0x00, 0x00, 0x00, 0x01, 0x00, | |
/* 0010 */ 0x31, 0x34, 0x38, 0x35, 0x39, 0x37, 0x34, 0x35, | |
/* 0018 */ 0x36, 0x39, 0x38, 0x35, 0x47, 0x65, 0x6E, 0x75, | |
/* 0020 */ 0x69, 0x6E, 0x65, 0x20, 0x4E, 0x56, 0x49, 0x44, | |
/* 0028 */ 0x49, 0x41, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, | |
/* 0030 */ 0x66, 0x69, 0x65, 0x64, 0x20, 0x4F, 0x70, 0x74, | |
/* 0038 */ 0x69, 0x6D, 0x75, 0x73, 0x20, 0x52, 0x65, 0x61, | |
/* 0040 */ 0x64, 0x79, 0x20, 0x4D, 0x6F, 0x74, 0x68, 0x65, | |
/* 0048 */ 0x72, 0x62, 0x6F, 0x61, 0x72, 0x64, 0x20, 0x66, | |
/* 0050 */ 0x6F, 0x72, 0x20, 0x37, 0x33, 0x36, 0x30, 0x31, | |
/* 0058 */ 0x39, 0x5F, 0x4D, 0x49, 0x52, 0x63, 0x20, 0x20, | |
/* 0060 */ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, | |
/* 0068 */ 0x2D, 0x20, 0x3C, 0x34, 0x27, 0x21, 0x58, 0x29, | |
/* 0070 */ 0x57, 0x27, 0x58, 0x20, 0x27, 0x25, 0x59, 0x5D, | |
/* 0078 */ 0x31, 0x29, 0x3A, 0x2A, 0x26, 0x39, 0x59, 0x43, | |
/* 0080 */ 0x56, 0x3B, 0x58, 0x56, 0x58, 0x3D, 0x59, 0x4E, | |
/* 0088 */ 0x3B, 0x3A, 0x35, 0x44, 0x25, 0x42, 0x5A, 0x48, | |
/* 0090 */ 0x55, 0x3A, 0x58, 0x4C, 0x25, 0x48, 0x54, 0x21, | |
/* 0098 */ 0x35, 0x4B, 0x4D, 0x37, 0x2C, 0x3C, 0x20, 0x2D, | |
/* 00A0 */ 0x20, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69, 0x67, | |
/* 00A8 */ 0x68, 0x74, 0x20, 0x32, 0x30, 0x31, 0x30, 0x20, | |
/* 00B0 */ 0x4E, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, | |
/* 00B8 */ 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, | |
/* 00C0 */ 0x6F, 0x6E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x52, | |
/* 00C8 */ 0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x52, 0x65, | |
/* 00D0 */ 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2D, 0x31, | |
/* 00D8 */ 0x34, 0x38, 0x35, 0x39, 0x37, 0x34, 0x35, 0x36, | |
/* 00E0 */ 0x39, 0x38, 0x35, 0x28, 0x52, 0x29 | |
}) | |
If (LEqual (USRG, 0x564B)) | |
{ | |
Return (OPVK) | |
} | |
Return (Zero) | |
}) | |
} | |
If (LEqual (Arg2, 0x11)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (Arg2, 0x12)) | |
{ | |
Return (Package (0x0A) | |
{ | |
0xD0, | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x40, 0x2F, 0x1A, 0x92, 0xC4, 0x0D, 0x2D, 0x40, | |
/* 0008 */ 0xAC, 0x18, 0xB4, 0x84, 0x44, 0xEF, 0x9E, 0xD2 | |
}, | |
0xD9, | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x61, 0xD3, 0x2A, 0xC1, 0xA9, 0x9F, 0x74, 0x4C, | |
/* 0008 */ 0x90, 0x1F, 0x95, 0xCB, 0x09, 0x45, 0xCF, 0x3E | |
}, | |
0xDB, | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x06, 0x80, 0x84, 0x42, 0x86, 0x88, 0x0E, 0x49, | |
/* 0008 */ 0x8C, 0x72, 0x2B, 0xDC, 0xA9, 0x3A, 0x8A, 0x09 | |
}, | |
0xEF, | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0xD2, 0x85, 0xE4, 0xB3, 0xC1, 0x3C, 0x54, 0x4B, | |
/* 0008 */ 0x8F, 0x31, 0x77, 0xBA, 0x2F, 0xDC, 0x9E, 0xBE | |
}, | |
0xF0, | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0xB6, 0x6F, 0x0D, 0x36, 0x4E, 0x1D, 0xA6, 0x4F, | |
/* 0008 */ 0xB8, 0x48, 0x1B, 0xE3, 0x3D, 0xD8, 0xEC, 0x7B | |
} | |
}) | |
} | |
If (LEqual (Arg2, 0x1A)) | |
{ | |
CreateField (Arg3, 0x18, 0x02, OMPR) | |
CreateField (Arg3, Zero, One, FLCH) | |
If (ToInteger (FLCH)) | |
{ | |
Store (OMPR, \_SB.PCI0.PEG0.PEGP.OPCE) | |
} | |
Store (Buffer (0x04) | |
{ | |
0x00, 0x00, 0x00, 0x00 | |
}, Local0) | |
CreateField (Local0, Zero, One, OPEN) | |
CreateField (Local0, 0x03, 0x02, CGCS) | |
CreateField (Local0, 0x06, One, SHPC) | |
CreateField (Local0, 0x18, 0x03, DGPC) | |
CreateField (Local0, 0x1B, 0x02, HDAC) | |
Store (One, OPEN) | |
Store (One, SHPC) | |
Store (0x02, HDAC) | |
Store (One, DGPC) | |
If (LNotEqual (\_SB.PCI0.PEG0.PEGP.SGST (), Zero)) | |
{ | |
Store (0x03, CGCS) | |
} | |
Return (Local0) | |
} | |
If (LEqual (Arg2, 0x1B)) | |
{ | |
Store (Arg3, Local0) | |
CreateField (Local0, Zero, One, OPFL) | |
CreateField (Local0, One, One, OPVL) | |
If (ToInteger (OPVL)) | |
{ | |
Store (Zero, \_SB.PCI0.PEG0.PEGP.OPTF) | |
If (ToInteger (OPFL)) | |
{ | |
Store (One, \_SB.PCI0.PEG0.PEGP.OPTF) | |
} | |
} | |
Store (\_SB.PCI0.PEG0.PEGP.OPTF, Local0) | |
Return (Local0) | |
} | |
Return (0x80000002) | |
} | |
Return (\_SB.PCI0.PEG0.PEGP.HDSM (Arg0, Arg1, Arg2, Arg3)) | |
} | |
} | |
Scope (\_SB.PCI0) | |
{ | |
Device (WMI1) | |
{ | |
Name (_HID, "pnp0c14") | |
Name (_UID, "OPT1") | |
Name (_WDG, Buffer (0x14) | |
{ | |
/* 0000 */ 0x3C, 0x5C, 0xCB, 0xF6, 0xAE, 0x9C, 0xBD, 0x4E, | |
/* 0008 */ 0xB5, 0x77, 0x93, 0x1E, 0xA3, 0x2A, 0x2C, 0xC0, | |
/* 0010 */ 0x4D, 0x58, 0x01, 0x02 | |
}) | |
Method (WMMX, 3, NotSerialized) | |
{ | |
CreateDWordField (Arg2, Zero, FUNC) | |
If (LEqual (FUNC, 0x534F525F)) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x08)) | |
{ | |
CreateDWordField (Arg2, 0x04, ARGS) | |
CreateDWordField (Arg2, 0x08, XARG) | |
Return (\_SB.PCI0.PEG0.PEGP._ROM (ARGS, XARG)) | |
} | |
} | |
If (LEqual (FUNC, 0x4D53445F)) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x1C)) | |
{ | |
CreateField (Arg2, Zero, 0x80, MUID) | |
CreateDWordField (Arg2, 0x10, REVI) | |
CreateDWordField (Arg2, 0x14, SFNC) | |
CreateField (Arg2, 0xE0, 0x20, XRG0) | |
If (CondRefOf (\_SB.PCI0.GFX0._DSM)) | |
{ | |
Return (\_SB.PCI0.GFX0._DSM) | |
MUID | |
REVI | |
SFNC | |
XRG0 | |
} | |
} | |
} | |
Return (Zero) | |
} | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment