|
/* |
|
* Intel ACPI Component Architecture |
|
* AML/ASL+ Disassembler version 20251212 (64-bit version) |
|
* Copyright (c) 2000 - 2025 Intel Corporation |
|
* |
|
* Disassembling to symbolic ASL+ operators |
|
* |
|
* Disassembly of DSDT_0.aml |
|
* |
|
* Original Table Header: |
|
* Signature "DSDT" |
|
* Length 0x000127D4 (75732) |
|
* Revision 0x02 |
|
* Checksum 0x34 |
|
* OEM ID "_ASUS_" |
|
* OEM Table ID "Notebook" |
|
* OEM Revision 0x00000204 (516) |
|
* Compiler ID "INTL" |
|
* Compiler Version 0x20051117 (537202967) |
|
*/ |
|
DefinitionBlock ("", "DSDT", 2, "_ASUS_", "Notebook", 0x00000204) |
|
{ |
|
/* |
|
* iASL Warning: There were 2 external control methods found during |
|
* disassembly, but only 0 were resolved (2 unresolved). Additional |
|
* ACPI tables may be required to properly disassemble the code. This |
|
* resulting disassembler output file may not compile because the |
|
* disassembler did not know how many arguments to assign to the |
|
* unresolved methods. Note: SSDTs can be dynamically loaded at |
|
* runtime and may or may not be available via the host OS. |
|
* |
|
* To specify the tables needed to resolve external control method |
|
* references, the -e option can be used to specify the filenames. |
|
* Example iASL invocations: |
|
* iasl -e ssdt1.aml ssdt2.aml ssdt3.aml -d dsdt.aml |
|
* iasl -e dsdt.aml ssdt2.aml -d ssdt1.aml |
|
* iasl -e ssdt*.aml -d dsdt.aml |
|
* |
|
* In addition, the -fe option can be used to specify a file containing |
|
* control method external declarations with the associated method |
|
* argument counts. Each line of the file must be of the form: |
|
* External (<method pathname>, MethodObj, <argument count>) |
|
* Invocation: |
|
* iasl -fe refs.txt -d dsdt.aml |
|
* |
|
* The following methods were unresolved and many not compile properly |
|
* because the disassembler had to guess at the number of arguments |
|
* required for each: |
|
*/ |
|
External (ALIB, IntObj) |
|
External (APTS, MethodObj) // Warning: Unknown method, guessing 1 arguments |
|
External (AWAK, MethodObj) // Warning: Unknown method, guessing 1 arguments |
|
|
|
Name (SMBB, 0x0B20) |
|
Name (SMBL, 0x20) |
|
Name (SMB0, 0x0B00) |
|
Name (SMBM, 0x10) |
|
Name (PMBS, 0x0800) |
|
Name (SMIO, 0xB2) |
|
Name (GPBS, Zero) |
|
Name (GPLN, Zero) |
|
Name (APCB, 0xFEC00000) |
|
Name (APCL, 0x1000) |
|
Name (HPTB, 0xFED00000) |
|
Name (HPTL, 0x1000) |
|
Name (GIOB, 0xFED80100) |
|
Name (IOMB, 0xFED80D00) |
|
Name (SMIB, 0xFED80200) |
|
Name (PEBS, 0xE0000000) |
|
Name (PEBL, 0x10000000) |
|
Name (ACPH, 0xDE) |
|
Name (ASSB, Zero) |
|
Name (AOTB, Zero) |
|
Name (AAXB, Zero) |
|
Name (PEHP, One) |
|
Name (SHPC, Zero) |
|
Name (PEER, One) |
|
Name (PECS, One) |
|
Name (ITKE, Zero) |
|
Name (SRSI, 0xB2) |
|
Name (CSMI, 0x61) |
|
Name (DSSP, Zero) |
|
Name (FHPP, Zero) |
|
Name (PEPM, Zero) |
|
Name (HIDK, "MSFT0001") |
|
Name (HIDM, "MSFT0003") |
|
Name (CIDK, 0x0303D041) |
|
Name (CIDM, 0x030FD041) |
|
Name (ATIS, 0xB0) |
|
Name (MBEC, Zero) |
|
Name (SPIB, 0xFEC10000) |
|
Name (SPIL, 0x1000) |
|
Name (PMLN, 0xA0) |
|
Name (MBLF, 0x0A) |
|
Name (SOAO, 0x6B) |
|
Name (PICM, Zero) |
|
Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model |
|
{ |
|
If (Arg0) |
|
{ |
|
DBG8 = 0xAE |
|
\_SB.IRQC () |
|
} |
|
Else |
|
{ |
|
DBG8 = 0xAC |
|
} |
|
|
|
PICM = Arg0 |
|
} |
|
|
|
Name (OSVR, Ones) |
|
Method (OSFL, 0, NotSerialized) |
|
{ |
|
If ((OSVR != Ones)) |
|
{ |
|
Return (OSVR) /* \OSVR */ |
|
} |
|
|
|
If ((PICM == Zero)) |
|
{ |
|
DBG8 = 0xAC |
|
} |
|
|
|
OSVR = 0x03 |
|
If (CondRefOf (_OSI, Local0)) |
|
{ |
|
If (_OSI ("Windows 2001")) |
|
{ |
|
OSVR = 0x04 |
|
} |
|
|
|
If (_OSI ("Windows 2001.1")) |
|
{ |
|
OSVR = 0x05 |
|
} |
|
|
|
If (_OSI ("FreeBSD")) |
|
{ |
|
OSVR = 0x06 |
|
} |
|
|
|
If (_OSI ("HP-UX")) |
|
{ |
|
OSVR = 0x07 |
|
} |
|
|
|
If (_OSI ("OpenVMS")) |
|
{ |
|
OSVR = 0x08 |
|
} |
|
|
|
If (_OSI ("Windows 2001 SP1")) |
|
{ |
|
OSVR = 0x09 |
|
} |
|
|
|
If (_OSI ("Windows 2001 SP2")) |
|
{ |
|
OSVR = 0x0A |
|
} |
|
|
|
If (_OSI ("Windows 2001 SP3")) |
|
{ |
|
OSVR = 0x0B |
|
} |
|
|
|
If (_OSI ("Windows 2006")) |
|
{ |
|
OSVR = 0x0C |
|
} |
|
|
|
If (_OSI ("Windows 2006 SP1")) |
|
{ |
|
OSVR = 0x0D |
|
} |
|
|
|
If (_OSI ("Windows 2009")) |
|
{ |
|
OSVR = 0x0E |
|
} |
|
|
|
If (_OSI ("Windows 2012")) |
|
{ |
|
OSVR = 0x0F |
|
} |
|
} |
|
Else |
|
{ |
|
If (MCTH (_OS, "Microsoft Windows NT")) |
|
{ |
|
OSVR = Zero |
|
} |
|
|
|
If (MCTH (_OS, "Microsoft Windows")) |
|
{ |
|
OSVR = One |
|
} |
|
|
|
If (MCTH (_OS, "Microsoft WindowsME: Millennium Edition")) |
|
{ |
|
OSVR = 0x02 |
|
} |
|
|
|
If (MCTH (_OS, "Linux")) |
|
{ |
|
OSVR = 0x03 |
|
} |
|
|
|
If (MCTH (_OS, "FreeBSD")) |
|
{ |
|
OSVR = 0x06 |
|
} |
|
|
|
If (MCTH (_OS, "HP-UX")) |
|
{ |
|
OSVR = 0x07 |
|
} |
|
|
|
If (MCTH (_OS, "OpenVMS")) |
|
{ |
|
OSVR = 0x08 |
|
} |
|
} |
|
|
|
Return (OSVR) /* \OSVR */ |
|
} |
|
|
|
Method (MCTH, 2, NotSerialized) |
|
{ |
|
If ((SizeOf (Arg0) < SizeOf (Arg1))) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0 = (SizeOf (Arg0) + One) |
|
Name (BUF0, Buffer (Local0){}) |
|
Name (BUF1, Buffer (Local0){}) |
|
BUF0 = Arg0 |
|
BUF1 = Arg1 |
|
While (Local0) |
|
{ |
|
Local0-- |
|
If ((DerefOf (BUF0 [Local0]) != DerefOf (BUF1 [Local0] |
|
))) |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Name (PRWP, Package (0x02) |
|
{ |
|
Zero, |
|
Zero |
|
}) |
|
Method (GPRW, 2, NotSerialized) |
|
{ |
|
PRWP [Zero] = Arg0 |
|
Local0 = (SS1 << One) |
|
Local0 |= (SS2 << 0x02) |
|
Local0 |= (SS3 << 0x03) |
|
Local0 |= (SS4 << 0x04) |
|
If (((One << Arg1) & Local0)) |
|
{ |
|
PRWP [One] = Arg1 |
|
} |
|
Else |
|
{ |
|
Local0 >>= One |
|
If (((OSFL () == One) || (OSFL () == 0x02))) |
|
{ |
|
FindSetLeftBit (Local0, PRWP [One]) |
|
} |
|
Else |
|
{ |
|
FindSetRightBit (Local0, PRWP [One]) |
|
} |
|
} |
|
|
|
Return (PRWP) /* \PRWP */ |
|
} |
|
|
|
Name (WAKP, Package (0x02) |
|
{ |
|
Zero, |
|
Zero |
|
}) |
|
OperationRegion (DEB0, SystemIO, 0x80, One) |
|
Field (DEB0, ByteAcc, NoLock, Preserve) |
|
{ |
|
DBG8, 8 |
|
} |
|
|
|
OperationRegion (DEB1, SystemIO, 0x90, 0x02) |
|
Field (DEB1, WordAcc, NoLock, Preserve) |
|
{ |
|
DBG9, 16 |
|
} |
|
|
|
Name (SS1, Zero) |
|
Name (SS2, Zero) |
|
Name (SS3, One) |
|
Name (SS4, One) |
|
Name (IOST, 0xC400) |
|
Name (TOPM, 0x00000000) |
|
Name (ROMS, 0xFFE00000) |
|
Name (VGAF, One) |
|
OperationRegion (DEB2, SystemIO, 0xEB, 0x02) |
|
Field (DEB2, WordAcc, NoLock, Preserve) |
|
{ |
|
P80H, 16 |
|
} |
|
|
|
Name (OSTY, Ones) |
|
OperationRegion (ACMS, SystemIO, 0x72, 0x10) |
|
Field (ACMS, ByteAcc, NoLock, Preserve) |
|
{ |
|
ICMS, 8, |
|
DCMS, 8, |
|
Offset (0x0E), |
|
P80, 8 |
|
} |
|
|
|
Name (PCIE, 0xE0000000) |
|
Name (OSCF, Zero) |
|
Name (GGN2, One) |
|
OperationRegion (CMPT, SystemIO, 0x0C50, 0x03) |
|
Field (CMPT, ByteAcc, NoLock, Preserve) |
|
{ |
|
CMID, 8, |
|
, 6, |
|
GPCT, 2, |
|
GP0I, 1, |
|
GP1I, 1, |
|
GP2I, 1, |
|
GP3I, 1, |
|
GP4I, 1, |
|
GP5I, 1, |
|
GP6I, 1, |
|
GP7I, 1 |
|
} |
|
|
|
OperationRegion (PCFG, SystemMemory, PCIE, 0x02000000) |
|
Field (PCFG, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x20078), |
|
Offset (0x2007A), |
|
PMSA, 1, |
|
Offset (0x28078), |
|
Offset (0x2807A), |
|
PMSB, 1, |
|
Offset (0x48078), |
|
Offset (0x4807A), |
|
PMSC, 1, |
|
Offset (0x8800A), |
|
STCL, 16, |
|
Offset (0x880FC), |
|
RMBA, 32, |
|
Offset (0xA0004), |
|
SMIE, 1, |
|
SMME, 1, |
|
Offset (0xA0008), |
|
RVID, 8, |
|
Offset (0xA0014), |
|
SMB1, 32, |
|
Offset (0xA0082), |
|
, 2, |
|
G31O, 1, |
|
Offset (0xA00E1), |
|
, 6, |
|
ACIR, 1, |
|
Offset (0xA4004), |
|
PCMD, 2, |
|
Offset (0xA807A), |
|
PMS0, 1, |
|
Offset (0xA8088), |
|
TLS0, 4, |
|
Offset (0xA907A), |
|
PMS1, 1, |
|
Offset (0xA9088), |
|
TLS1, 4, |
|
Offset (0xAA07A), |
|
PMS2, 1, |
|
Offset (0xAA088), |
|
TLS2, 4, |
|
Offset (0xAB07A), |
|
PMS3, 1, |
|
Offset (0xAB088), |
|
TLS3, 4 |
|
} |
|
|
|
OperationRegion (PMIO, SystemIO, 0x0CD6, 0x02) |
|
Field (PMIO, ByteAcc, NoLock, Preserve) |
|
{ |
|
INPM, 8, |
|
DAPM, 8 |
|
} |
|
|
|
IndexField (INPM, DAPM, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x24), |
|
MMSO, 32, |
|
Offset (0x60), |
|
P1EB, 16 |
|
} |
|
|
|
OperationRegion (ERMM, SystemMemory, MMSO, 0x1000) |
|
Field (ERMM, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x105), |
|
, 5, |
|
G06E, 1, |
|
G06O, 1, |
|
G06I, 1, |
|
G07B, 8, |
|
Offset (0x10A), |
|
G0BB, 8, |
|
Offset (0x10D), |
|
G0EB, 8, |
|
Offset (0x113), |
|
, 5, |
|
G14E, 1, |
|
G14O, 1, |
|
G14I, 1, |
|
, 5, |
|
G15E, 1, |
|
G15O, 1, |
|
G15I, 1, |
|
Offset (0x11B), |
|
, 7, |
|
G1CI, 1, |
|
Offset (0x11F), |
|
, 7, |
|
G20I, 1, |
|
Offset (0x122), |
|
, 5, |
|
G23E, 1, |
|
G23O, 1, |
|
G23I, 1, |
|
Offset (0x12B), |
|
, 5, |
|
G2CE, 1, |
|
G2CO, 1, |
|
G2CI, 1, |
|
, 5, |
|
G2DE, 1, |
|
G2DO, 1, |
|
G2DI, 1, |
|
Offset (0x132), |
|
, 5, |
|
G33E, 1, |
|
G33O, 1, |
|
G33I, 1, |
|
Offset (0x134), |
|
, 5, |
|
G35E, 1, |
|
G35O, 1, |
|
Offset (0x136), |
|
, 5, |
|
G37E, 1, |
|
G37O, 1, |
|
G37I, 1, |
|
Offset (0x13F), |
|
, 7, |
|
G40I, 1, |
|
Offset (0x164), |
|
, 7, |
|
GE05, 1, |
|
, 7, |
|
GE06, 1, |
|
Offset (0x16E), |
|
, 7, |
|
GE15, 1, |
|
, 7, |
|
GE16, 1, |
|
Offset (0x175), |
|
, 7, |
|
GE22, 1, |
|
Offset (0x1A9), |
|
, 5, |
|
GAAE, 1, |
|
GAAO, 1, |
|
GAAI, 1, |
|
, 5, |
|
GABE, 1, |
|
GABO, 1, |
|
Offset (0x1AE), |
|
GAFB, 8, |
|
GB0B, 8, |
|
Offset (0x1FF), |
|
, 9, |
|
GESA, 1, |
|
Offset (0x207), |
|
, 5, |
|
E05C, 1, |
|
E06C, 1, |
|
Offset (0x208), |
|
E08C, 1, |
|
E09C, 1, |
|
Offset (0x209), |
|
E10C, 1, |
|
Offset (0x20A), |
|
, 5, |
|
E1DC, 1, |
|
Offset (0x2AF), |
|
, 2, |
|
SLPS, 2, |
|
Offset (0x376), |
|
EPNM, 1, |
|
DPPF, 1, |
|
Offset (0x3BA), |
|
, 6, |
|
PWDE, 1, |
|
Offset (0x3BD), |
|
, 5, |
|
ALLS, 1, |
|
Offset (0x3EF), |
|
PHYD, 1, |
|
, 1, |
|
, 1, |
|
US5R, 1, |
|
Offset (0x3F5), |
|
GECD, 1, |
|
Offset (0xD05), |
|
G06M, 8, |
|
G07M, 8, |
|
Offset (0xD0A), |
|
G0BM, 8, |
|
Offset (0xD0D), |
|
G0EM, 8, |
|
Offset (0xD13), |
|
G14M, 8, |
|
Offset (0xD1B), |
|
G1CM, 8, |
|
Offset (0xD1F), |
|
G20M, 8, |
|
Offset (0xD22), |
|
G23M, 8, |
|
Offset (0xD2C), |
|
G2DM, 8, |
|
Offset (0xD36), |
|
G37M, 8, |
|
Offset (0xD6F), |
|
G70M, 8, |
|
Offset (0xD75), |
|
G76M, 8, |
|
Offset (0xDA9), |
|
GAAM, 8, |
|
Offset (0xDAE), |
|
GAFM, 8, |
|
GB0M, 8, |
|
Offset (0xE7F), |
|
, 2, |
|
IMCS, 1 |
|
} |
|
|
|
OperationRegion (ABIO, SystemIO, 0x0CD8, 0x08) |
|
Field (ABIO, DWordAcc, NoLock, Preserve) |
|
{ |
|
INAB, 32, |
|
DAAB, 32 |
|
} |
|
|
|
Method (RDAB, 1, NotSerialized) |
|
{ |
|
INAB = Arg0 |
|
Return (DAAB) /* \DAAB */ |
|
} |
|
|
|
Method (WTAB, 2, NotSerialized) |
|
{ |
|
INAB = Arg0 |
|
DAAB = Arg1 |
|
} |
|
|
|
Method (RWAB, 3, NotSerialized) |
|
{ |
|
Local0 = (RDAB (Arg0) & Arg1) |
|
Local1 = (Local0 | Arg2) |
|
WTAB (Arg0, Local1) |
|
} |
|
|
|
Method (CABR, 3, NotSerialized) |
|
{ |
|
Local0 = (Arg0 << 0x05) |
|
Local1 = (Local0 + Arg1) |
|
Local2 = (Local1 << 0x18) |
|
Local3 = (Local2 + Arg2) |
|
Return (Local3) |
|
} |
|
|
|
Method (GHPS, 2, NotSerialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
RWAB (CABR (0x06, Zero, 0xC0), 0xFFFFBFFF, Zero) |
|
RWAB (CABR (One, Zero, 0x65), 0xFFFFFBFB, Zero) |
|
Stall (0xC8) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
RWAB (CABR (0x06, Zero, 0xC0), 0xFFFFBFFF, 0x4000) |
|
RWAB (CABR (One, Zero, 0x65), 0xFFFFFBFB, 0x0404) |
|
Stall (0xC8) |
|
} |
|
|
|
If (GGN2) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
GEN2 () |
|
Local0 = RDAB (CABR (0x03, 0x02, 0xA5)) |
|
Local0 &= 0xFF |
|
Local1 = 0x01F4 |
|
While (((Local1 > Zero) && (Local0 != 0x10))) |
|
{ |
|
Local0 = RDAB (CABR (0x03, 0x02, 0xA5)) |
|
Local0 &= 0xFF |
|
Local1-- |
|
Stall (0xC8) |
|
Stall (0xC8) |
|
} |
|
|
|
If ((Local0 != 0x10)) |
|
{ |
|
GEN1 () |
|
} |
|
} |
|
} |
|
} |
|
|
|
Method (GEN2, 0, NotSerialized) |
|
{ |
|
TLS2 = 0x02 |
|
RWAB (CABR (0x03, 0x02, 0xA4), 0xFFFFFFFE, One) |
|
RWAB (CABR (0x03, 0x02, 0xA2), 0xFFFFDFFF, 0x2000) |
|
RWAB (CABR (0x03, 0x02, 0xC0), 0xFFFF7FFF, 0x8000) |
|
RWAB (CABR (0x03, 0x02, 0xA4), 0xDFFFFFFF, 0x20000000) |
|
Stall (0xC8) |
|
Stall (0xC8) |
|
} |
|
|
|
Method (GEN1, 0, NotSerialized) |
|
{ |
|
TLS2 = One |
|
RWAB (CABR (0x03, 0x02, 0xA4), 0xFFFFFFFE, Zero) |
|
RWAB (CABR (0x03, 0x02, 0xA2), 0xFFFFDFFF, 0x2000) |
|
Stall (0xC8) |
|
Stall (0xC8) |
|
} |
|
|
|
OperationRegion (P1E0, SystemIO, P1EB, 0x04) |
|
Field (P1E0, ByteAcc, NoLock, Preserve) |
|
{ |
|
, 14, |
|
PEWS, 1, |
|
WSTA, 1, |
|
, 14, |
|
PEWD, 1 |
|
} |
|
|
|
Method (SPTS, 1, NotSerialized) |
|
{ |
|
PCMD = One |
|
P80 = Arg0 |
|
If (IMCS) |
|
{ |
|
IBSE () |
|
} |
|
|
|
CPMS () |
|
CPMS () |
|
PEWS = One |
|
} |
|
|
|
Method (SWAK, 1, NotSerialized) |
|
{ |
|
CPMS () |
|
CPMS () |
|
PEWS = One |
|
If (IMCS) |
|
{ |
|
IBWE () |
|
} |
|
} |
|
|
|
Method (TRMD, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (CPMS, 0, NotSerialized) |
|
{ |
|
If ((EPNM == Zero)) |
|
{ |
|
PMSA = One |
|
PMSB = One |
|
PMSC = One |
|
PMS0 = One |
|
PMS1 = One |
|
PMS2 = One |
|
PMS3 = One |
|
} |
|
} |
|
|
|
Scope (_GPE) |
|
{ |
|
} |
|
|
|
OperationRegion (IMIO, SystemIO, 0x3E, 0x02) |
|
Field (IMIO, ByteAcc, NoLock, Preserve) |
|
{ |
|
IMCX, 8, |
|
IMCA, 8 |
|
} |
|
|
|
IndexField (IMCX, IMCA, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x80), |
|
MSTI, 8, |
|
MITS, 8, |
|
MRG0, 8, |
|
MRG1, 8, |
|
MRG2, 8, |
|
MRG3, 8 |
|
} |
|
|
|
Method (WACK, 0, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
While ((Local0 != 0xFA)) |
|
{ |
|
Local0 = MRG0 /* \MRG0 */ |
|
Sleep (0x0A) |
|
} |
|
} |
|
|
|
Method (IBSE, 0, NotSerialized) |
|
{ |
|
MRG0 = Zero |
|
MRG1 = 0xB5 |
|
MRG2 = Zero |
|
MSTI = 0x96 |
|
WACK () |
|
MRG0 = Zero |
|
MRG1 = Zero |
|
MRG2 = Zero |
|
MSTI = 0x80 |
|
WACK () |
|
Local0 = MRG2 /* \MRG2 */ |
|
Local0 &= 0xFE |
|
MRG0 = Zero |
|
MRG1 = Zero |
|
MRG2 = Local0 |
|
MSTI = 0x81 |
|
WACK () |
|
MRG0 = Zero |
|
MRG1 = One |
|
MRG2 = Zero |
|
MSTI = 0x98 |
|
WACK () |
|
MRG0 = Zero |
|
MRG1 = 0xB4 |
|
MRG2 = Zero |
|
MSTI = 0x96 |
|
WACK () |
|
} |
|
|
|
Method (IBWE, 0, NotSerialized) |
|
{ |
|
MRG0 = Zero |
|
MRG1 = 0xB5 |
|
MRG2 = Zero |
|
MSTI = 0x96 |
|
WACK () |
|
MRG0 = Zero |
|
MRG1 = Zero |
|
MRG2 = Zero |
|
MSTI = 0x80 |
|
WACK () |
|
Local0 = MRG2 /* \MRG2 */ |
|
Local0 |= One |
|
MRG0 = Zero |
|
MRG1 = Zero |
|
MRG2 = Local0 |
|
MSTI = 0x81 |
|
WACK () |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Name (PR00, Package (0x2D) |
|
{ |
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
Zero, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0011FFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
One, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
One, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
0x02, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
0x03, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
Zero, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
0x02, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
0x03, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
Zero, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
One, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
0x02, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
0x03, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
One, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
One, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
0x02, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
0x03, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
0x02, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
0x03, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0012FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0012FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0013FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0013FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0016FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0016FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0010FFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0010FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
Zero, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
0x02, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
0x03, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
Zero, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
One, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
} |
|
}) |
|
Name (AR00, Package (0x2D) |
|
{ |
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
Zero, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0011FFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
One, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0002FFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
One, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
0x02, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0003FFFF, |
|
0x03, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
Zero, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
0x02, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0004FFFF, |
|
0x03, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
Zero, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
One, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
0x02, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0005FFFF, |
|
0x03, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
One, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0006FFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
One, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
0x02, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0007FFFF, |
|
0x03, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
0x02, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0014FFFF, |
|
0x03, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0012FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0012FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0013FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0013FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0016FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0016FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0010FFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0010FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
Zero, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
0x02, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0015FFFF, |
|
0x03, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
Zero, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
One, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0x0001FFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
} |
|
}) |
|
Name (PR20, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKD, |
|
Zero |
|
} |
|
}) |
|
Name (AR20, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x13 |
|
} |
|
}) |
|
Name (PR21, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKA, |
|
Zero |
|
} |
|
}) |
|
Name (AR21, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x10 |
|
} |
|
}) |
|
Name (PR22, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
} |
|
}) |
|
Name (AR22, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
} |
|
}) |
|
Name (PR23, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKC, |
|
Zero |
|
} |
|
}) |
|
Name (AR23, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x12 |
|
} |
|
}) |
|
Name (PR12, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
} |
|
}) |
|
Name (AR12, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
} |
|
}) |
|
Name (PR13, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKC, |
|
Zero |
|
} |
|
}) |
|
Name (AR13, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x12 |
|
} |
|
}) |
|
Name (PR14, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKD, |
|
Zero |
|
} |
|
}) |
|
Name (AR14, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x13 |
|
} |
|
}) |
|
Name (PR15, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKA, |
|
Zero |
|
} |
|
}) |
|
Name (AR15, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x10 |
|
} |
|
}) |
|
Name (PR16, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKC, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKB, |
|
Zero |
|
} |
|
}) |
|
Name (AR16, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x12 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x11 |
|
} |
|
}) |
|
Name (PR17, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
LNKD, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
LNKA, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
LNKB, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
LNKC, |
|
Zero |
|
} |
|
}) |
|
Name (AR17, Package (0x04) |
|
{ |
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
Zero, |
|
Zero, |
|
0x13 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
One, |
|
Zero, |
|
0x10 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x02, |
|
Zero, |
|
0x11 |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
0xFFFF, |
|
0x03, |
|
Zero, |
|
0x12 |
|
} |
|
}) |
|
Name (PRSA, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{4,5,7,10,11,14,15} |
|
}) |
|
Alias (PRSA, PRSB) |
|
Alias (PRSA, PRSC) |
|
Alias (PRSA, PRSD) |
|
Alias (PRSA, PRSE) |
|
Alias (PRSA, PRSF) |
|
Alias (PRSA, PRSG) |
|
Alias (PRSA, PRSH) |
|
Device (PCI0) |
|
{ |
|
Name (_HID, EisaId ("PNP0A03") /* PCI Bus */) // _HID: Hardware ID |
|
Name (_ADR, 0x00180000) // _ADR: Address |
|
Method (^BN00, 0, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (_BBN, 0, NotSerialized) // _BBN: BIOS Bus Number |
|
{ |
|
Return (BN00 ()) |
|
} |
|
|
|
Name (_UID, Zero) // _UID: Unique ID |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR00) /* \_SB_.AR00 */ |
|
} |
|
|
|
Return (PR00) /* \_SB_.PR00 */ |
|
} |
|
|
|
Name (CPRB, One) |
|
Name (LVGA, 0x01) |
|
Name (STAV, 0x0F) |
|
Name (BRB, 0x0000) |
|
Name (BRL, 0x0100) |
|
Name (IOB, 0x1000) |
|
Name (IOL, 0xF000) |
|
Name (MBB, 0xB0000000) |
|
Name (MBL, 0x50000000) |
|
Name (MABL, 0x00000000) |
|
Name (MABH, 0x00000000) |
|
Name (MALL, 0x00000000) |
|
Name (MALH, 0x00000000) |
|
Name (MAML, 0x00000000) |
|
Name (MAMH, 0x00000000) |
|
Name (CRS1, ResourceTemplate () |
|
{ |
|
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, |
|
0x0000, // Granularity |
|
0x0000, // Range Minimum |
|
0x007F, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0080, // Length |
|
,, _Y00) |
|
IO (Decode16, |
|
0x0CF8, // Range Minimum |
|
0x0CF8, // Range Maximum |
|
0x01, // Alignment |
|
0x08, // Length |
|
) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x0000, // Range Minimum |
|
0x03AF, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x03B0, // Length |
|
,, , TypeStatic, DenseTranslation) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x03E0, // Range Minimum |
|
0x0CF7, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0918, // Length |
|
,, , TypeStatic, DenseTranslation) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0000, // Length |
|
,, _Y02, TypeStatic, DenseTranslation) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x0D00, // Range Minimum |
|
0x0FFF, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0300, // Length |
|
,, _Y01, TypeStatic, DenseTranslation) |
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x00000000, // Granularity |
|
0x00000000, // Range Minimum |
|
0x00000000, // Range Maximum |
|
0x00000000, // Translation Offset |
|
0x00000000, // Length |
|
,, _Y03, AddressRangeMemory, TypeStatic) |
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, |
|
0x00000000, // Granularity |
|
0x000C0000, // Range Minimum |
|
0x000DFFFF, // Range Maximum |
|
0x00000000, // Translation Offset |
|
0x00020000, // Length |
|
,, , AddressRangeMemory, TypeStatic) |
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x00000000, // Granularity |
|
0x02000000, // Range Minimum |
|
0xFFDFFFFF, // Range Maximum |
|
0x00000000, // Translation Offset |
|
0xFDFC0000, // Length |
|
,, _Y04, AddressRangeMemory, TypeStatic) |
|
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x0000000000000000, // Granularity |
|
0x0000000000000000, // Range Minimum |
|
0x0000000000000000, // Range Maximum |
|
0x0000000000000000, // Translation Offset |
|
0x0000000000000000, // Length |
|
,, _Y05, AddressRangeMemory, TypeStatic) |
|
}) |
|
Name (CRS2, ResourceTemplate () |
|
{ |
|
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, |
|
0x0000, // Granularity |
|
0x0080, // Range Minimum |
|
0x00FF, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0080, // Length |
|
,, _Y06) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0000, // Length |
|
,, _Y08, TypeStatic, DenseTranslation) |
|
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
|
0x0000, // Granularity |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x0000, // Translation Offset |
|
0x0000, // Length |
|
,, _Y07, TypeStatic, DenseTranslation) |
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x00000000, // Granularity |
|
0x00000000, // Range Minimum |
|
0x00000000, // Range Maximum |
|
0x00000000, // Translation Offset |
|
0x00000000, // Length |
|
,, _Y09, AddressRangeMemory, TypeStatic) |
|
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x00000000, // Granularity |
|
0x80000000, // Range Minimum |
|
0xFFFFFFFF, // Range Maximum |
|
0x00000000, // Translation Offset |
|
0x80000000, // Length |
|
,, _Y0A, AddressRangeMemory, TypeStatic) |
|
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
|
0x0000000000000000, // Granularity |
|
0x0000000000000000, // Range Minimum |
|
0x0000000000000000, // Range Maximum |
|
0x0000000000000000, // Translation Offset |
|
0x0000000000000000, // Length |
|
,, _Y0B, AddressRangeMemory, TypeStatic) |
|
}) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (STAV) /* \_SB_.PCI0.STAV */ |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
If (CPRB) |
|
{ |
|
CreateWordField (CRS1, \_SB.PCI0._Y00._MIN, MIN0) // _MIN: Minimum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y00._MAX, MAX0) // _MAX: Maximum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y00._LEN, LEN0) // _LEN: Length |
|
MIN0 = BRB /* \_SB_.PCI0.BRB_ */ |
|
LEN0 = BRL /* \_SB_.PCI0.BRL_ */ |
|
Local0 = LEN0 /* \_SB_.PCI0._CRS.LEN0 */ |
|
MAX0 = (MIN0 + Local0--) |
|
CreateWordField (CRS1, \_SB.PCI0._Y01._MIN, MIN1) // _MIN: Minimum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y01._MAX, MAX1) // _MAX: Maximum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y01._LEN, LEN1) // _LEN: Length |
|
If ((IOB == 0x1000)) |
|
{ |
|
Local0 = IOL /* \_SB_.PCI0.IOL_ */ |
|
MAX1 = (IOB + Local0--) |
|
Local0 = (MAX1 - MIN1) /* \_SB_.PCI0._CRS.MIN1 */ |
|
LEN1 = (Local0 + One) |
|
} |
|
Else |
|
{ |
|
MIN1 = IOB /* \_SB_.PCI0.IOB_ */ |
|
LEN1 = IOL /* \_SB_.PCI0.IOL_ */ |
|
Local0 = LEN1 /* \_SB_.PCI0._CRS.LEN1 */ |
|
MAX1 = (MIN1 + Local0--) |
|
} |
|
|
|
If (((LVGA == One) || (LVGA == 0x55))) |
|
{ |
|
If (VGAF) |
|
{ |
|
CreateWordField (CRS1, \_SB.PCI0._Y02._MIN, IMN1) // _MIN: Minimum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y02._MAX, IMX1) // _MAX: Maximum Base Address |
|
CreateWordField (CRS1, \_SB.PCI0._Y02._LEN, ILN1) // _LEN: Length |
|
IMN1 = 0x03B0 |
|
IMX1 = 0x03DF |
|
ILN1 = 0x30 |
|
CreateDWordField (CRS1, \_SB.PCI0._Y03._MIN, VMN1) // _MIN: Minimum Base Address |
|
CreateDWordField (CRS1, \_SB.PCI0._Y03._MAX, VMX1) // _MAX: Maximum Base Address |
|
CreateDWordField (CRS1, \_SB.PCI0._Y03._LEN, VLN1) // _LEN: Length |
|
VMN1 = 0x000A0000 |
|
VMX1 = 0x000BFFFF |
|
VLN1 = 0x00020000 |
|
VGAF = Zero |
|
} |
|
} |
|
|
|
CreateDWordField (CRS1, \_SB.PCI0._Y04._MIN, MIN3) // _MIN: Minimum Base Address |
|
CreateDWordField (CRS1, \_SB.PCI0._Y04._MAX, MAX3) // _MAX: Maximum Base Address |
|
CreateDWordField (CRS1, \_SB.PCI0._Y04._LEN, LEN3) // _LEN: Length |
|
MIN3 = MBB /* \_SB_.PCI0.MBB_ */ |
|
LEN3 = MBL /* \_SB_.PCI0.MBL_ */ |
|
Local0 = LEN3 /* \_SB_.PCI0._CRS.LEN3 */ |
|
MAX3 = (MIN3 + Local0--) |
|
If ((MALH || MALL)) |
|
{ |
|
CreateDWordField (CRS1, \_SB.PCI0._Y05._MIN, MN8L) // _MIN: Minimum Base Address |
|
Local0 = (0xB4 + 0x04) |
|
CreateDWordField (CRS1, Local0, MN8H) |
|
MN8L = MABL /* \_SB_.PCI0.MABL */ |
|
MN8H = MABH /* \_SB_.PCI0.MABH */ |
|
CreateDWordField (CRS1, \_SB.PCI0._Y05._MAX, MX8L) // _MAX: Maximum Base Address |
|
Local1 = (0xBC + 0x04) |
|
CreateDWordField (CRS1, Local1, MX8H) |
|
CreateDWordField (CRS1, \_SB.PCI0._Y05._LEN, LN8L) // _LEN: Length |
|
Local2 = (0xCC + 0x04) |
|
CreateDWordField (CRS1, Local2, LN8H) |
|
MN8L = MABL /* \_SB_.PCI0.MABL */ |
|
MN8H = MABH /* \_SB_.PCI0.MABH */ |
|
LN8L = MALL /* \_SB_.PCI0.MALL */ |
|
LN8H = MALH /* \_SB_.PCI0.MALH */ |
|
MX8L = MAML /* \_SB_.PCI0.MAML */ |
|
MX8H = MAMH /* \_SB_.PCI0.MAMH */ |
|
} |
|
|
|
Return (CRS1) /* \_SB_.PCI0.CRS1 */ |
|
} |
|
Else |
|
{ |
|
CreateWordField (CRS2, \_SB.PCI0._Y06._MIN, MIN2) // _MIN: Minimum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y06._MAX, MAX2) // _MAX: Maximum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y06._LEN, LEN2) // _LEN: Length |
|
MIN2 = BRB /* \_SB_.PCI0.BRB_ */ |
|
LEN2 = BRL /* \_SB_.PCI0.BRL_ */ |
|
Local1 = LEN2 /* \_SB_.PCI0._CRS.LEN2 */ |
|
MAX2 = (MIN2 + Local1--) |
|
CreateWordField (CRS2, \_SB.PCI0._Y07._MIN, MIN4) // _MIN: Minimum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y07._MAX, MAX4) // _MAX: Maximum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y07._LEN, LEN4) // _LEN: Length |
|
MIN4 = IOB /* \_SB_.PCI0.IOB_ */ |
|
LEN4 = IOL /* \_SB_.PCI0.IOL_ */ |
|
Local1 = LEN4 /* \_SB_.PCI0._CRS.LEN4 */ |
|
MAX4 = (MIN4 + Local1--) |
|
If (LVGA) |
|
{ |
|
CreateWordField (CRS2, \_SB.PCI0._Y08._MIN, IMN2) // _MIN: Minimum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y08._MAX, IMX2) // _MAX: Maximum Base Address |
|
CreateWordField (CRS2, \_SB.PCI0._Y08._LEN, ILN2) // _LEN: Length |
|
IMN2 = 0x03B0 |
|
IMX2 = 0x03DF |
|
ILN2 = 0x30 |
|
CreateDWordField (CRS2, \_SB.PCI0._Y09._MIN, VMN2) // _MIN: Minimum Base Address |
|
CreateDWordField (CRS2, \_SB.PCI0._Y09._MAX, VMX2) // _MAX: Maximum Base Address |
|
CreateDWordField (CRS2, \_SB.PCI0._Y09._LEN, VLN2) // _LEN: Length |
|
VMN2 = 0x000A0000 |
|
VMX2 = 0x000BFFFF |
|
VLN2 = 0x00020000 |
|
} |
|
|
|
CreateDWordField (CRS2, \_SB.PCI0._Y0A._MIN, MIN5) // _MIN: Minimum Base Address |
|
CreateDWordField (CRS2, \_SB.PCI0._Y0A._MAX, MAX5) // _MAX: Maximum Base Address |
|
CreateDWordField (CRS2, \_SB.PCI0._Y0A._LEN, LEN5) // _LEN: Length |
|
MIN5 = MBB /* \_SB_.PCI0.MBB_ */ |
|
LEN5 = MBL /* \_SB_.PCI0.MBL_ */ |
|
Local1 = LEN5 /* \_SB_.PCI0._CRS.LEN5 */ |
|
MAX5 = (MIN5 + Local1--) |
|
If ((MALH || MALL)) |
|
{ |
|
CreateDWordField (CRS2, \_SB.PCI0._Y0B._MIN, MN9L) // _MIN: Minimum Base Address |
|
Local0 = (0x72 + 0x04) |
|
CreateDWordField (CRS2, Local0, MN9H) |
|
CreateDWordField (CRS2, \_SB.PCI0._Y0B._MAX, MX9L) // _MAX: Maximum Base Address |
|
Local1 = (0x7A + 0x04) |
|
CreateDWordField (CRS2, Local1, MX9H) |
|
CreateDWordField (CRS2, \_SB.PCI0._Y0B._LEN, LN9L) // _LEN: Length |
|
Local2 = (0x8A + 0x04) |
|
CreateDWordField (CRS2, Local2, LN9H) |
|
MN9L = MABL /* \_SB_.PCI0.MABL */ |
|
MN9H = MABH /* \_SB_.PCI0.MABH */ |
|
LN9L = MALL /* \_SB_.PCI0.MALL */ |
|
LN9H = MALH /* \_SB_.PCI0.MALH */ |
|
MX9L = MAML /* \_SB_.PCI0.MAML */ |
|
MX9H = MAMH /* \_SB_.PCI0.MAMH */ |
|
} |
|
|
|
Return (CRS2) /* \_SB_.PCI0.CRS2 */ |
|
} |
|
} |
|
|
|
Scope (\_SB) |
|
{ |
|
Scope (PCI0) |
|
{ |
|
Device (AMDN) |
|
{ |
|
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID |
|
Name (_UID, 0xC8) // _UID: Unique ID |
|
Name (_STA, 0x0F) // _STA: Status |
|
Name (NPTR, ResourceTemplate () |
|
{ |
|
Memory32Fixed (ReadWrite, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y0C) |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateDWordField (NPTR, \_SB.PCI0.AMDN._Y0C._LEN, PL) // _LEN: Length |
|
CreateDWordField (NPTR, \_SB.PCI0.AMDN._Y0C._BAS, PB) // _BAS: Base Address |
|
PB = PEBS /* \PEBS */ |
|
PL = PEBL /* \PEBL */ |
|
Return (NPTR) /* \_SB_.PCI0.AMDN.NPTR */ |
|
} |
|
} |
|
} |
|
} |
|
|
|
Method (NPTS, 1, NotSerialized) |
|
{ |
|
APTS (Arg0) |
|
} |
|
|
|
Method (NWAK, 1, NotSerialized) |
|
{ |
|
AWAK (Arg0) |
|
} |
|
|
|
Device (IDEC) |
|
{ |
|
Name (_ADR, 0x00140001) // _ADR: Address |
|
Name (UDMT, Package (0x08) |
|
{ |
|
0x78, |
|
0x5A, |
|
0x3C, |
|
0x2D, |
|
0x1E, |
|
0x14, |
|
0x0F, |
|
Zero |
|
}) |
|
Name (PIOT, Package (0x06) |
|
{ |
|
0x0258, |
|
0x0186, |
|
0x010E, |
|
0xB4, |
|
0x78, |
|
Zero |
|
}) |
|
Name (PITR, Package (0x06) |
|
{ |
|
0x99, |
|
0x47, |
|
0x34, |
|
0x22, |
|
0x20, |
|
0x99 |
|
}) |
|
Name (MDMT, Package (0x04) |
|
{ |
|
0x01E0, |
|
0x96, |
|
0x78, |
|
Zero |
|
}) |
|
Name (MDTR, Package (0x04) |
|
{ |
|
0x77, |
|
0x21, |
|
0x20, |
|
0xFF |
|
}) |
|
OperationRegion (IDE, PCI_Config, 0x40, 0x20) |
|
Field (IDE, AnyAcc, NoLock, Preserve) |
|
{ |
|
PPIT, 16, |
|
SPIT, 16, |
|
PMDT, 16, |
|
SMDT, 16, |
|
PPIC, 8, |
|
SPIC, 8, |
|
PPIM, 8, |
|
SPIM, 8, |
|
Offset (0x14), |
|
PUDC, 2, |
|
SUDC, 2, |
|
Offset (0x16), |
|
PUDM, 8, |
|
SUDM, 8 |
|
} |
|
|
|
Method (GETT, 1, NotSerialized) |
|
{ |
|
Local0 = (Arg0 & 0x0F) |
|
Local1 = (Arg0 >> 0x04) |
|
Return ((0x1E * ((Local0 + One) + (Local1 + One) |
|
))) |
|
} |
|
|
|
Method (GTM, 1, NotSerialized) |
|
{ |
|
CreateByteField (Arg0, Zero, PIT1) |
|
CreateByteField (Arg0, One, PIT0) |
|
CreateByteField (Arg0, 0x02, MDT1) |
|
CreateByteField (Arg0, 0x03, MDT0) |
|
CreateByteField (Arg0, 0x04, PICX) |
|
CreateByteField (Arg0, 0x05, UDCX) |
|
CreateByteField (Arg0, 0x06, UDMX) |
|
Name (BUF, Buffer (0x14) |
|
{ |
|
/* 0000 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // ........ |
|
/* 0008 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // ........ |
|
/* 0010 */ 0x00, 0x00, 0x00, 0x00 // .... |
|
}) |
|
CreateDWordField (BUF, Zero, PIO0) |
|
CreateDWordField (BUF, 0x04, DMA0) |
|
CreateDWordField (BUF, 0x08, PIO1) |
|
CreateDWordField (BUF, 0x0C, DMA1) |
|
CreateDWordField (BUF, 0x10, FLAG) |
|
If ((PICX & One)) |
|
{ |
|
Return (BUF) /* \_SB_.PCI0.IDEC.GTM_.BUF_ */ |
|
} |
|
|
|
PIO0 = GETT (PIT0) |
|
PIO1 = GETT (PIT1) |
|
If ((UDCX & One)) |
|
{ |
|
FLAG |= One |
|
DMA0 = DerefOf (UDMT [(UDMX & 0x0F)]) |
|
} |
|
Else |
|
{ |
|
DMA0 = GETT (MDT0) |
|
} |
|
|
|
If ((UDCX & 0x02)) |
|
{ |
|
FLAG |= 0x04 |
|
DMA1 = DerefOf (UDMT [(UDMX >> 0x04)]) |
|
} |
|
Else |
|
{ |
|
DMA1 = GETT (MDT1) |
|
} |
|
|
|
FLAG |= 0x1A |
|
Return (BUF) /* \_SB_.PCI0.IDEC.GTM_.BUF_ */ |
|
} |
|
|
|
Method (STM, 3, NotSerialized) |
|
{ |
|
CreateDWordField (Arg0, Zero, PIO0) |
|
CreateDWordField (Arg0, 0x04, DMA0) |
|
CreateDWordField (Arg0, 0x08, PIO1) |
|
CreateDWordField (Arg0, 0x0C, DMA1) |
|
CreateDWordField (Arg0, 0x10, FLAG) |
|
Name (BUF, Buffer (0x07) |
|
{ |
|
0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00 // ....... |
|
}) |
|
CreateByteField (BUF, Zero, PIT1) |
|
CreateByteField (BUF, One, PIT0) |
|
CreateByteField (BUF, 0x02, MDT1) |
|
CreateByteField (BUF, 0x03, MDT0) |
|
CreateByteField (BUF, 0x04, PIMX) |
|
CreateByteField (BUF, 0x05, UDCX) |
|
CreateByteField (BUF, 0x06, UDMX) |
|
Local0 = Match (PIOT, MLE, PIO0, MTR, Zero, Zero) |
|
Local0 %= 0x05 |
|
Local1 = Match (PIOT, MLE, PIO1, MTR, Zero, Zero) |
|
Local1 %= 0x05 |
|
PIMX = ((Local1 << 0x04) | Local0) |
|
PIT0 = DerefOf (PITR [Local0]) |
|
PIT1 = DerefOf (PITR [Local1]) |
|
If ((FLAG & One)) |
|
{ |
|
Local0 = Match (UDMT, MLE, DMA0, MTR, Zero, Zero) |
|
Local0 %= 0x07 |
|
UDMX |= Local0 |
|
UDCX |= One |
|
} |
|
ElseIf ((DMA0 != 0xFFFFFFFF)) |
|
{ |
|
Local0 = Match (MDMT, MLE, DMA0, MTR, Zero, Zero) |
|
MDT0 = DerefOf (MDTR [Local0]) |
|
} |
|
|
|
If ((FLAG & 0x04)) |
|
{ |
|
Local0 = Match (UDMT, MLE, DMA1, MTR, Zero, Zero) |
|
Local0 %= 0x07 |
|
UDMX |= (Local0 << 0x04) |
|
UDCX |= 0x02 |
|
} |
|
ElseIf ((DMA1 != 0xFFFFFFFF)) |
|
{ |
|
Local0 = Match (MDMT, MLE, DMA1, MTR, Zero, Zero) |
|
MDT1 = DerefOf (MDTR [Local0]) |
|
} |
|
|
|
Return (BUF) /* \_SB_.PCI0.IDEC.STM_.BUF_ */ |
|
} |
|
|
|
Method (GTF, 2, NotSerialized) |
|
{ |
|
CreateByteField (Arg1, Zero, MDT1) |
|
CreateByteField (Arg1, One, MDT0) |
|
CreateByteField (Arg1, 0x02, PIMX) |
|
CreateByteField (Arg1, 0x03, UDCX) |
|
CreateByteField (Arg1, 0x04, UDMX) |
|
If ((Arg0 == 0xA0)) |
|
{ |
|
Local0 = (PIMX & 0x0F) |
|
Local1 = MDT0 /* \_SB_.PCI0.IDEC.GTF_.MDT0 */ |
|
Local2 = (UDCX & One) |
|
Local3 = (UDMX & 0x0F) |
|
} |
|
Else |
|
{ |
|
Local0 = (PIMX >> 0x04) |
|
Local1 = MDT1 /* \_SB_.PCI0.IDEC.GTF_.MDT1 */ |
|
Local2 = (UDCX & 0x02) |
|
Local3 = (UDMX >> 0x04) |
|
} |
|
|
|
Name (BUF, Buffer (0x15) |
|
{ |
|
/* 0000 */ 0x03, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF, 0x03, // ........ |
|
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0xFF, 0xEF, 0x00, 0x00, // ........ |
|
/* 0010 */ 0x00, 0x00, 0x00, 0x00, 0xF5 // ..... |
|
}) |
|
CreateByteField (BUF, One, PMOD) |
|
CreateByteField (BUF, 0x08, DMOD) |
|
CreateByteField (BUF, 0x05, CMDA) |
|
CreateByteField (BUF, 0x0C, CMDB) |
|
CreateByteField (BUF, 0x13, CMDC) |
|
CMDA = Arg0 |
|
CMDB = Arg0 |
|
CMDC = Arg0 |
|
PMOD = (Local0 | 0x08) |
|
If (Local2) |
|
{ |
|
DMOD = (Local3 | 0x40) |
|
} |
|
Else |
|
{ |
|
Local4 = Match (MDMT, MLE, GETT (Local1), MTR, Zero, Zero) |
|
If ((Local4 < 0x03)) |
|
{ |
|
DMOD = (0x20 | Local4) |
|
} |
|
} |
|
|
|
Return (BUF) /* \_SB_.PCI0.IDEC.GTF_.BUF_ */ |
|
} |
|
|
|
Device (PRID) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
|
{ |
|
Name (BUF, Buffer (0x07) |
|
{ |
|
0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00 // ....... |
|
}) |
|
CreateWordField (BUF, Zero, VPIT) |
|
CreateWordField (BUF, 0x02, VMDT) |
|
CreateByteField (BUF, 0x04, VPIC) |
|
CreateByteField (BUF, 0x05, VUDC) |
|
CreateByteField (BUF, 0x06, VUDM) |
|
VPIT = PPIT /* \_SB_.PCI0.IDEC.PPIT */ |
|
VMDT = PMDT /* \_SB_.PCI0.IDEC.PMDT */ |
|
VPIC = PPIC /* \_SB_.PCI0.IDEC.PPIC */ |
|
VUDC = PUDC /* \_SB_.PCI0.IDEC.PUDC */ |
|
VUDM = PUDM /* \_SB_.PCI0.IDEC.PUDM */ |
|
Return (GTM (BUF)) |
|
} |
|
|
|
Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
|
{ |
|
Name (BUF, Buffer (0x07) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ....... |
|
}) |
|
CreateWordField (BUF, Zero, VPIT) |
|
CreateWordField (BUF, 0x02, VMDT) |
|
CreateByteField (BUF, 0x04, VPIM) |
|
CreateByteField (BUF, 0x05, VUDC) |
|
CreateByteField (BUF, 0x06, VUDM) |
|
BUF = STM (Arg0, Arg1, Arg2) |
|
PPIT = VPIT /* \_SB_.PCI0.IDEC.PRID._STM.VPIT */ |
|
PMDT = VMDT /* \_SB_.PCI0.IDEC.PRID._STM.VMDT */ |
|
PPIM = VPIM /* \_SB_.PCI0.IDEC.PRID._STM.VPIM */ |
|
PUDC = VUDC /* \_SB_.PCI0.IDEC.PRID._STM.VUDC */ |
|
PUDM = VUDM /* \_SB_.PCI0.IDEC.PRID._STM.VUDM */ |
|
} |
|
|
|
Device (P_D0) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
|
{ |
|
Name (BUF, Buffer (0x05) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00 // ..... |
|
}) |
|
CreateWordField (BUF, Zero, VMDT) |
|
CreateByteField (BUF, 0x02, VPIM) |
|
CreateByteField (BUF, 0x03, VUDC) |
|
CreateByteField (BUF, 0x04, VUDM) |
|
VMDT = PMDT /* \_SB_.PCI0.IDEC.PMDT */ |
|
VPIM = PPIM /* \_SB_.PCI0.IDEC.PPIM */ |
|
VUDC = PUDC /* \_SB_.PCI0.IDEC.PUDC */ |
|
VUDM = PUDM /* \_SB_.PCI0.IDEC.PUDM */ |
|
Return (GTF (0xA0, BUF)) |
|
} |
|
} |
|
|
|
Device (P_D1) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
|
{ |
|
Name (BUF, Buffer (0x05) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00 // ..... |
|
}) |
|
CreateWordField (BUF, Zero, VMDT) |
|
CreateByteField (BUF, 0x02, VPIM) |
|
CreateByteField (BUF, 0x03, VUDC) |
|
CreateByteField (BUF, 0x04, VUDM) |
|
VMDT = PMDT /* \_SB_.PCI0.IDEC.PMDT */ |
|
VPIM = PPIM /* \_SB_.PCI0.IDEC.PPIM */ |
|
VUDC = PUDC /* \_SB_.PCI0.IDEC.PUDC */ |
|
VUDM = PUDM /* \_SB_.PCI0.IDEC.PUDM */ |
|
Return (GTF (0xB0, BUF)) |
|
} |
|
} |
|
} |
|
|
|
Device (SECD) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
|
{ |
|
Name (BUF, Buffer (0x07) |
|
{ |
|
0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00 // ....... |
|
}) |
|
CreateWordField (BUF, Zero, VPIT) |
|
CreateWordField (BUF, 0x02, VMDT) |
|
CreateByteField (BUF, 0x04, VPIC) |
|
CreateByteField (BUF, 0x05, VUDC) |
|
CreateByteField (BUF, 0x06, VUDM) |
|
VPIT = SPIT /* \_SB_.PCI0.IDEC.SPIT */ |
|
VMDT = SMDT /* \_SB_.PCI0.IDEC.SMDT */ |
|
VPIC = SPIC /* \_SB_.PCI0.IDEC.SPIC */ |
|
VUDC = SUDC /* \_SB_.PCI0.IDEC.SUDC */ |
|
VUDM = SUDM /* \_SB_.PCI0.IDEC.SUDM */ |
|
Return (GTM (BUF)) |
|
} |
|
|
|
Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
|
{ |
|
Name (BUF, Buffer (0x07) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ....... |
|
}) |
|
CreateWordField (BUF, Zero, VPIT) |
|
CreateWordField (BUF, 0x02, VMDT) |
|
CreateByteField (BUF, 0x04, VPIM) |
|
CreateByteField (BUF, 0x05, VUDC) |
|
CreateByteField (BUF, 0x06, VUDM) |
|
BUF = STM (Arg0, Arg1, Arg2) |
|
SPIT = VPIT /* \_SB_.PCI0.IDEC.SECD._STM.VPIT */ |
|
SMDT = VMDT /* \_SB_.PCI0.IDEC.SECD._STM.VMDT */ |
|
SPIM = VPIM /* \_SB_.PCI0.IDEC.SECD._STM.VPIM */ |
|
SUDC = VUDC /* \_SB_.PCI0.IDEC.SECD._STM.VUDC */ |
|
SUDM = VUDM /* \_SB_.PCI0.IDEC.SECD._STM.VUDM */ |
|
} |
|
|
|
Device (S_D0) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
|
{ |
|
Name (BUF, Buffer (0x05) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00 // ..... |
|
}) |
|
CreateWordField (BUF, Zero, VMDT) |
|
CreateByteField (BUF, 0x02, VPIM) |
|
CreateByteField (BUF, 0x03, VUDC) |
|
CreateByteField (BUF, 0x04, VUDM) |
|
VMDT = SMDT /* \_SB_.PCI0.IDEC.SMDT */ |
|
VPIM = SPIM /* \_SB_.PCI0.IDEC.SPIM */ |
|
VUDC = SUDC /* \_SB_.PCI0.IDEC.SUDC */ |
|
VUDM = SUDM /* \_SB_.PCI0.IDEC.SUDM */ |
|
Return (GTF (0xA0, BUF)) |
|
} |
|
} |
|
|
|
Device (S_D1) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
|
{ |
|
Name (BUF, Buffer (0x05) |
|
{ |
|
0x00, 0x00, 0x00, 0x00, 0x00 // ..... |
|
}) |
|
CreateWordField (BUF, Zero, VMDT) |
|
CreateByteField (BUF, 0x02, VPIM) |
|
CreateByteField (BUF, 0x03, VUDC) |
|
CreateByteField (BUF, 0x04, VUDM) |
|
VMDT = SMDT /* \_SB_.PCI0.IDEC.SMDT */ |
|
VPIM = SPIM /* \_SB_.PCI0.IDEC.SPIM */ |
|
VUDC = SUDC /* \_SB_.PCI0.IDEC.SUDC */ |
|
VUDM = SUDM /* \_SB_.PCI0.IDEC.SUDM */ |
|
Return (GTF (0xB0, BUF)) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Device (GNBD) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Scope (\) |
|
{ |
|
OperationRegion (ATFB, SystemMemory, 0x7E3A4018, 0x0105) |
|
Field (ATFB, AnyAcc, NoLock, Preserve) |
|
{ |
|
BCMD, 8, |
|
DID, 32, |
|
INFO, 2048 |
|
} |
|
|
|
Field (ATFB, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x05), |
|
INF0, 8, |
|
INF1, 8, |
|
INF2, 8, |
|
INF3, 8, |
|
INF4, 8, |
|
INF5, 8, |
|
INF6, 8, |
|
INF7, 8 |
|
} |
|
|
|
Field (ATFB, AnyAcc, NoLock, Preserve) |
|
{ |
|
AccessAs (ByteAcc, 0x00), |
|
Offset (0x05), |
|
INF, 8 |
|
} |
|
} |
|
|
|
OperationRegion (NBRV, PCI_Config, 0x08, One) |
|
Field (NBRV, ByteAcc, NoLock, Preserve) |
|
{ |
|
PREV, 8 |
|
} |
|
|
|
OperationRegion (NBBR, PCI_Config, 0x1C, 0x08) |
|
Field (NBBR, DWordAcc, NoLock, Preserve) |
|
{ |
|
BR3L, 32, |
|
BR3H, 32 |
|
} |
|
|
|
OperationRegion (NBBI, PCI_Config, 0x84, 0x04) |
|
Field (NBBI, DWordAcc, NoLock, Preserve) |
|
{ |
|
PARB, 32 |
|
} |
|
|
|
OperationRegion (NBMS, PCI_Config, 0x60, 0x08) |
|
Field (NBMS, DWordAcc, NoLock, Preserve) |
|
{ |
|
MIDX, 32, |
|
MIDR, 32 |
|
} |
|
|
|
Mutex (NBMM, 0x00) |
|
Method (NBMR, 1, NotSerialized) |
|
{ |
|
Acquire (NBMM, 0xFFFF) |
|
Local0 = (Arg0 & 0x7F) |
|
MIDX = Local0 |
|
Local0 = MIDR /* \_SB_.PCI0.GNBD.MIDR */ |
|
MIDX = 0x7F |
|
Release (NBMM) |
|
Return (Local0) |
|
} |
|
|
|
Method (NBMW, 2, NotSerialized) |
|
{ |
|
Acquire (NBMM, 0xFFFF) |
|
Local0 = (Arg0 & 0x7F) |
|
Local0 |= 0x80 |
|
MIDX = Local0 |
|
MIDR = Arg1 |
|
MIDX = Local0 &= 0x7F |
|
Release (NBMM) |
|
} |
|
|
|
OperationRegion (NBXP, PCI_Config, 0xE0, 0x08) |
|
Field (NBXP, DWordAcc, NoLock, Preserve) |
|
{ |
|
NBXI, 32, |
|
NBXD, 32 |
|
} |
|
|
|
Mutex (NBXM, 0x00) |
|
Method (NBXR, 1, NotSerialized) |
|
{ |
|
Acquire (NBXM, 0xFFFF) |
|
NBXI = Arg0 |
|
Local0 = NBXD /* \_SB_.PCI0.GNBD.NBXD */ |
|
NBXI = Zero |
|
Release (NBXM) |
|
Return (Local0) |
|
} |
|
|
|
Method (NBXW, 2, NotSerialized) |
|
{ |
|
Acquire (NBXM, 0xFFFF) |
|
NBXI = Arg0 |
|
NBXD = Arg1 |
|
NBXI = Zero |
|
Release (NBXM) |
|
} |
|
|
|
Method (GFXM, 0, NotSerialized) |
|
{ |
|
Local0 = NBMR (0x08) |
|
Local0 &= 0x0F |
|
Return (Local0) |
|
} |
|
|
|
Method (GPPM, 0, NotSerialized) |
|
{ |
|
Local0 = NBMR (0x67) |
|
Local0 &= 0xF0 |
|
Return (Local0) |
|
} |
|
|
|
Method (GPPX, 0, NotSerialized) |
|
{ |
|
Local0 = NBMR (0x2D) |
|
Local0 >>= 0x07 |
|
Local0 &= 0x0F |
|
Return (Local0) |
|
} |
|
|
|
Method (XPTR, 2, NotSerialized) |
|
{ |
|
If (((Arg0 < 0x02) && (Arg0 > 0x07))) |
|
{ |
|
Return (Zero) |
|
} |
|
Else |
|
{ |
|
Local0 = GPPM () |
|
Local1 = GPPX () |
|
Local0 = One |
|
If ((Arg0 < 0x04)) |
|
{ |
|
Local1 = (Arg0 + 0x02) |
|
} |
|
Else |
|
{ |
|
Local1 = (Arg0 + 0x11) |
|
} |
|
|
|
Local0 <<= Local1 |
|
Local2 = NBMR (0x08) |
|
If (Arg1) |
|
{ |
|
Local2 &= ~Local0 |
|
} |
|
Else |
|
{ |
|
Local2 |= Local0 |
|
} |
|
|
|
NBMW (0x08, Local2) |
|
Return (Ones) |
|
} |
|
} |
|
|
|
Name (PX3L, 0x80000000) |
|
Name (PX3H, 0x80000000) |
|
Name (PX3S, 0x10000000) |
|
Name (PX3K, 0xF0000000) |
|
Mutex (BR3X, 0x00) |
|
Method (BR3M, 0, NotSerialized) |
|
{ |
|
Local0 = PARB /* \_SB_.PCI0.GNBD.PARB */ |
|
Local0 >>= 0x10 |
|
Local0 &= 0x07 |
|
If (Local0) |
|
{ |
|
Local1 = (One << Local0) |
|
Local1 = (0x1000 - Local1) |
|
Local1 <<= 0x14 |
|
PX3K = Local1 |
|
Local0 = (0x00100000 >> Local0) |
|
PX3S = Local0 |
|
} |
|
|
|
Acquire (BR3X, 0xFFFF) |
|
Local0 = NBMR (Zero) |
|
Local0 &= 0xFFFFFFF7 |
|
NBMW (Zero, Local0) |
|
Local0 = BR3L /* \_SB_.PCI0.GNBD.BR3L */ |
|
Local0 &= PX3K /* \_SB_.PCI0.GNBD.PX3K */ |
|
PX3L = Local0 |
|
Local0 = BR3H /* \_SB_.PCI0.GNBD.BR3H */ |
|
Local0 &= 0xFF |
|
PX3H = Local0 |
|
Local0 = NBMR (Zero) |
|
Local0 |= 0x08 |
|
NBMW (Zero, Local0) |
|
Release (BR3X) |
|
Return (PX3L) /* \_SB_.PCI0.GNBD.PX3L */ |
|
} |
|
|
|
OperationRegion (NB2, PCI_Config, Zero, 0x0100) |
|
Field (NB2, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x60), |
|
MI, 32, |
|
MD, 32, |
|
Offset (0x90), |
|
TOM, 32, |
|
OI, 32, |
|
OD, 32, |
|
Offset (0xE0), |
|
LI, 32, |
|
LD, 32 |
|
} |
|
|
|
Device (BROD) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x14) // _UID: Unique ID |
|
Name (UMAS, 0x30000000) |
|
Name (CRS, ResourceTemplate () |
|
{ |
|
Memory32Fixed (ReadOnly, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y0D) |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateDWordField (CRS, \_SB.PCI0.GNBD.BROD._Y0D._BAS, BAS1) // _BAS: Base Address |
|
CreateDWordField (CRS, \_SB.PCI0.GNBD.BROD._Y0D._LEN, LEN1) // _LEN: Length |
|
LEN1 = UMAS /* \_SB_.PCI0.GNBD.BROD.UMAS */ |
|
BAS1 = (TOM - LEN1) /* \_SB_.PCI0.GNBD.BROD._CRS.LEN1 */ |
|
Return (CRS) /* \_SB_.PCI0.GNBD.BROD.CRS_ */ |
|
} |
|
} |
|
} |
|
|
|
Device (PCED) |
|
{ |
|
Name (_ADR, 0x00020000) // _ADR: Address |
|
OperationRegion (XPEX, SystemMemory, 0xE0010100, 0x0100) |
|
Field (XPEX, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x28), |
|
VC0S, 32 |
|
} |
|
|
|
OperationRegion (PCFG, PCI_Config, Zero, 0x20) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
DVID, 32, |
|
Offset (0x18), |
|
SBUS, 32 |
|
} |
|
|
|
OperationRegion (XPCB, PCI_Config, 0x58, 0x24) |
|
Field (XPCB, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x10), |
|
LKCN, 16, |
|
LKST, 16, |
|
Offset (0x18), |
|
, 3, |
|
PDC8, 1, |
|
, 2, |
|
PDS8, 1, |
|
Offset (0x19), |
|
HPC8, 1, |
|
Offset (0x1A), |
|
, 3, |
|
PDC2, 1, |
|
, 2, |
|
PDS2, 1, |
|
Offset (0x1B), |
|
HPCS, 1, |
|
Offset (0x20), |
|
Offset (0x22), |
|
PMES, 1 |
|
} |
|
|
|
OperationRegion (XPRI, PCI_Config, 0xE0, 0x08) |
|
Field (XPRI, ByteAcc, NoLock, Preserve) |
|
{ |
|
XPIR, 32, |
|
XPID, 32 |
|
} |
|
|
|
Method (XPDL, 0, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
If ((VC0S & 0x00020000)) |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Mutex (XPPM, 0x00) |
|
Method (XPRD, 1, NotSerialized) |
|
{ |
|
Acquire (XPPM, 0xFFFF) |
|
XPIR = Arg0 |
|
Local0 = XPID /* \_SB_.PCI0.PCED.XPID */ |
|
XPIR = Zero |
|
Release (XPPM) |
|
Return (Local0) |
|
} |
|
|
|
Method (XPWR, 2, NotSerialized) |
|
{ |
|
Acquire (XPPM, 0xFFFF) |
|
XPIR = Arg0 |
|
XPID = Arg1 |
|
XPIR = Zero |
|
Release (XPPM) |
|
} |
|
|
|
Method (XPRT, 0, NotSerialized) |
|
{ |
|
Local0 = XPRD (0xA2) |
|
Local0 &= 0xFFFFFFF8 |
|
Local1 = (Local0 >> 0x04) |
|
Local1 &= 0x07 |
|
Local0 |= Local1 |
|
Local0 |= 0x0100 |
|
XPWR (0xA2, Local0) |
|
} |
|
|
|
Method (XPPB, 0, NotSerialized) |
|
{ |
|
Local0 = _ADR /* \_SB_.PCI0.PCED._ADR */ |
|
Local1 = (Local0 >> 0x10) |
|
Local1 = (Local1 << 0x03) |
|
Local2 = (Local0 & 0x0F) |
|
Local3 = (Local1 | Local2) |
|
Return (Local3) |
|
} |
|
|
|
Method (XPCN, 0, NotSerialized) |
|
{ |
|
Local1 = Zero |
|
Local0 = XPPB () |
|
If ((0x04 > Local0)) |
|
{ |
|
Local1 = Zero |
|
} |
|
|
|
If ((0x08 > Local0)) |
|
{ |
|
Local1 = 0x00010000 |
|
} |
|
|
|
If ((0x0B > Local0)) |
|
{ |
|
Local1 = 0x00020000 |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Method (XPPD, 0, NotSerialized) |
|
{ |
|
Local0 = XPPB () |
|
Local2 = ^^GNBD.GPPX () |
|
Local3 = ^^GNBD.GFXM () |
|
Local1 = Zero |
|
If ((0x10 == Local0)) |
|
{ |
|
Local1 = 0xFFFF |
|
If (Local3) |
|
{ |
|
Local1 = 0x0F0F |
|
} |
|
} |
|
|
|
If ((0x18 == Local0)) |
|
{ |
|
Local1 = 0xF0F0 |
|
} |
|
|
|
If ((0x20 == Local0)) |
|
{ |
|
Local1 = 0x1010 |
|
} |
|
|
|
If ((0x28 == Local0)) |
|
{ |
|
Local1 = 0x2020 |
|
} |
|
|
|
If ((0x30 == Local0)) |
|
{ |
|
Local1 = 0x4040 |
|
} |
|
|
|
If ((0x38 == Local0)) |
|
{ |
|
Local1 = 0x8080 |
|
} |
|
|
|
If ((0x48 == Local0)) |
|
{ |
|
Local1 = Zero |
|
If ((0x02 == Local2)) |
|
{ |
|
Local1 = 0x0303 |
|
} |
|
|
|
If ((0x03 == Local2)) |
|
{ |
|
Local1 = 0x0101 |
|
} |
|
} |
|
|
|
If ((0x50 == Local0)) |
|
{ |
|
Local1 = Zero |
|
If ((0x03 == Local2)) |
|
{ |
|
Local1 = 0x0202 |
|
} |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Method (XPLP, 1, NotSerialized) |
|
{ |
|
Local1 = XPPD () |
|
If ((Zero != Local1)) |
|
{ |
|
Local2 = ^^GNBD.NBXR ((0x65 + XPCN ())) |
|
If (Arg0) |
|
{ |
|
Local2 &= ~Local1 |
|
} |
|
Else |
|
{ |
|
Local2 |= Local1 |
|
} |
|
|
|
^^GNBD.NBXW ((0x65 + XPCN ()), Local2) |
|
} |
|
} |
|
|
|
Method (XPR2, 0, NotSerialized) |
|
{ |
|
Local0 = LKCN /* \_SB_.PCI0.PCED.LKCN */ |
|
Local0 &= 0xFFFFFFDF |
|
LKCN = Local0 |
|
Local0 |= 0x20 |
|
LKCN = Local0 |
|
Local1 = 0x64 |
|
Local2 = One |
|
While ((Local1 && Local2)) |
|
{ |
|
Sleep (One) |
|
Local3 = LKST /* \_SB_.PCI0.PCED.LKST */ |
|
If ((Local3 & 0x0800)) |
|
{ |
|
Local1-- |
|
} |
|
Else |
|
{ |
|
Local2 = Zero |
|
} |
|
} |
|
|
|
Local0 &= 0xFFFFFFDF |
|
LKCN = Local0 |
|
If (!Local2) |
|
{ |
|
Return (Ones) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (XPLL, 1, NotSerialized) |
|
{ |
|
Local0 = ^^GNBD.GFXM () |
|
Local1 = XPPB () |
|
Local2 = Zero |
|
If ((0x10 == Local1)) |
|
{ |
|
Local2 = One |
|
Local3 = 0x00770070 |
|
If (Local0) |
|
{ |
|
Local3 = 0x00330030 |
|
} |
|
} |
|
|
|
If (((0x18 == Local1) && Local0)) |
|
{ |
|
Local2 = One |
|
Local3 = 0x00440040 |
|
} |
|
|
|
Local0 = ^^GNBD.NBMR (0x07) |
|
Local1 = ^^GNBD.NBXR (0x65) |
|
If ((Local0 && 0x0201F000)) |
|
{ |
|
Local4 = 0x00440040 |
|
Local5 = Local4 |
|
If ((~Local1 && 0xF0F0)) |
|
{ |
|
Local5 = Zero |
|
} |
|
} |
|
Else |
|
{ |
|
Local4 = 0x00110010 |
|
Local5 = Local4 |
|
If ((~Local1 && 0x0F0F)) |
|
{ |
|
Local5 = Zero |
|
} |
|
} |
|
|
|
If (Local2) |
|
{ |
|
Local6 = (Local3 | Local4) |
|
Local0 = (Local5 & Local4) |
|
Local7 = (Local3 | Local0) |
|
Local0 = ^^GNBD.NBMR (0x2E) |
|
If (Arg0) |
|
{ |
|
Local0 &= ~Local6 |
|
} |
|
Else |
|
{ |
|
Local0 |= Local7 |
|
} |
|
|
|
^^GNBD.NBMW (0x2E, Local0) |
|
} |
|
} |
|
|
|
Method (XPPR, 1, NotSerialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
XPLL (One) |
|
XPLP (One) |
|
Sleep (0xC8) |
|
^^GNBD.XPTR ((XPPB () << 0x03), One) |
|
Sleep (0x14) |
|
} |
|
Else |
|
{ |
|
^^GNBD.XPTR ((XPPB () << 0x03), Zero) |
|
XPLP (Zero) |
|
XPLL (Zero) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Device (VGA) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
OperationRegion (VSID, PCI_Config, Zero, 0x20) |
|
Field (VSID, ByteAcc, NoLock, Preserve) |
|
{ |
|
REG0, 32, |
|
REG4, 32, |
|
REG8, 32 |
|
} |
|
|
|
Method (PRST, 0, NotSerialized) |
|
{ |
|
If ((REG0 == 0xFFFFFFFF)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf (((REG8 & 0xFFFFFF00) == 0x03000000)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (DVIM, 0x10) |
|
Name (HDMM, 0x08) |
|
Name (PCTG, Package (0x0D){}) |
|
Name (PCW8, Package (0x67){}) |
|
Name (LCDM, One) |
|
Name (CRTM, 0x02) |
|
Name (TVOM, 0x04) |
|
Name (DO1M, 0x10) |
|
Name (DO2M, 0x08) |
|
Name (DONE, Zero) |
|
Name (DOSF, One) |
|
Name (BRNC, Zero) |
|
Name (UPDN, One) |
|
Name (NXTD, One) |
|
Name (GADD, Zero) |
|
Method (MD2A, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
If ((Arg0 & LCDM)) |
|
{ |
|
Local0 |= One |
|
} |
|
|
|
If ((Arg0 & CRTM)) |
|
{ |
|
Local0 |= 0x02 |
|
} |
|
|
|
If ((Arg0 & TVOM)) |
|
{ |
|
Local0 |= 0x04 |
|
} |
|
|
|
If ((Arg0 & DVIM)) |
|
{ |
|
Local0 |= 0x08 |
|
} |
|
|
|
If ((Arg0 & HDMM)) |
|
{ |
|
Local0 |= 0x10 |
|
} |
|
|
|
If (!Local0) |
|
{ |
|
Return (NXTD) /* \_SB_.PCI0.PCED.VGA_.NXTD */ |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (MA2D, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
If ((Arg0 & One)) |
|
{ |
|
Local0 |= LCDM /* \_SB_.PCI0.PCED.VGA_.LCDM */ |
|
} |
|
|
|
If ((Arg0 & 0x02)) |
|
{ |
|
Local0 |= CRTM /* \_SB_.PCI0.PCED.VGA_.CRTM */ |
|
} |
|
|
|
If ((Arg0 & 0x04)) |
|
{ |
|
Local0 |= TVOM /* \_SB_.PCI0.PCED.VGA_.TVOM */ |
|
} |
|
|
|
If ((Arg0 & 0x08)) |
|
{ |
|
Local0 |= DVIM /* \_SB_.PCI0.PCED.VGA_.DVIM */ |
|
} |
|
|
|
If ((Arg0 & 0x10)) |
|
{ |
|
Local0 |= HDMM /* \_SB_.PCI0.PCED.VGA_.HDMM */ |
|
} |
|
|
|
If (!Local0) |
|
{ |
|
Return (LCDM) /* \_SB_.PCI0.PCED.VGA_.LCDM */ |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize |
|
{ |
|
} |
|
|
|
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching |
|
{ |
|
DOSF = (Arg0 & 0x03) |
|
BRNC = (Arg0 >> 0x02) |
|
BRNC &= One |
|
If ((OSFG >= OSW8)) |
|
{ |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
^^^VGA.AF7E |= One |
|
} |
|
} |
|
} |
|
|
|
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices |
|
{ |
|
Name (ADOD, Package (0x03) |
|
{ |
|
0x00010110, |
|
0x00010100, |
|
0x0210 |
|
}) |
|
Name (NDOD, Package (0x03) |
|
{ |
|
0x00010110, |
|
0x00010100, |
|
0x0121 |
|
}) |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
Return (ADOD) /* \_SB_.PCI0.PCED.VGA_._DOD.ADOD */ |
|
} |
|
Else |
|
{ |
|
Return (NDOD) /* \_SB_.PCI0.PCED.VGA_._DOD.NDOD */ |
|
} |
|
} |
|
|
|
Device (LCDD) |
|
{ |
|
Name (_ADR, 0x0110) // _ADR: Address |
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & LCDM)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & LCDM)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
|
|
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Local0 = Zero |
|
Local1 = ((\WMI0.AB00 * 0x64) / 0xFF) |
|
While ((Local0 < 0x65)) |
|
{ |
|
If ((Local0 < Local1)) |
|
{ |
|
PCW8 [(Local0 + 0x02)] = Local1 |
|
} |
|
Else |
|
{ |
|
PCW8 [(Local0 + 0x02)] = Local0 |
|
} |
|
|
|
Local0++ |
|
} |
|
|
|
PCW8 [Zero] = 0x64 |
|
PCW8 [One] = 0x28 |
|
Return (PCW8) /* \_SB_.PCI0.PCED.VGA_.PCW8 */ |
|
} |
|
|
|
Local0 = (0x0B - One) |
|
Local1 = ^^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [Zero] = Local2 |
|
Local0 = (0x0B - 0x04) |
|
Local1 = ^^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [One] = Local2 |
|
Local0 = Zero |
|
While ((Local0 < 0x0B)) |
|
{ |
|
Local1 = ^^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [(Local0 + 0x02)] = Local2 |
|
Local0++ |
|
} |
|
|
|
Return (PCTG) /* \_SB_.PCI0.PCED.VGA_.PCTG */ |
|
} |
|
|
|
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method |
|
{ |
|
Local0 = GCBL (Arg0) |
|
\WMI0.LBTN = Local0 |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Local1 = ((Local0 * 0xFF) / 0x64) |
|
If ((^^^^VGA.AF7E == 0x80000001)) |
|
{ |
|
^^^^VGA.AFN7 (Local1) |
|
} |
|
} |
|
Else |
|
{ |
|
^^^^SBRG.HEC.STBR () |
|
} |
|
} |
|
|
|
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Return (DerefOf (PCW8 [(Local0 + 0x02)])) |
|
} |
|
Else |
|
{ |
|
Return (DerefOf (PCTG [(Local0 + 0x02)])) |
|
} |
|
} |
|
} |
|
|
|
Device (CRTD) |
|
{ |
|
Name (_ADR, 0x0100) // _ADR: Address |
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & CRTM)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & CRTM)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
} |
|
|
|
Device (DO2D) |
|
{ |
|
Method (_ADR, 0, NotSerialized) // _ADR: Address |
|
{ |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
Return (0x0210) |
|
} |
|
Else |
|
{ |
|
Return (0x0121) |
|
} |
|
} |
|
|
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & DO2M)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & DO2M)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
} |
|
|
|
Method (SWHD, 1, Serialized) |
|
{ |
|
UPDN = One |
|
If ((DOSF & 0x03)) |
|
{ |
|
\WMI0.SETD = MA2D (Arg0) |
|
ISMI (0x94) |
|
} |
|
Else |
|
{ |
|
\WMI0.SETD = MA2D (Arg0) |
|
Notify (VGA, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Method (GETD, 0, NotSerialized) |
|
{ |
|
GADD = One |
|
^^^VGA.AFN0 () |
|
Local0 = Zero |
|
While (((Local0 < 0x0A) && GADD)) |
|
{ |
|
Sleep (0x64) |
|
Local0++ |
|
} |
|
|
|
GADD = Zero |
|
Return (\WMI0.ACTD) |
|
} |
|
|
|
Method (GNDD, 0, NotSerialized) |
|
{ |
|
ISMI (0xA0) |
|
Return (\WMI0.SETD) |
|
} |
|
|
|
Method (ADVD, 0, NotSerialized) |
|
{ |
|
If (UPDN) |
|
{ |
|
GETD () |
|
\WMI0.SETD = \WMI0.ACTD |
|
UPDN = Zero |
|
} |
|
|
|
GNDD () |
|
NXTD = \WMI0.SETD |
|
NXTD = MD2A (NXTD) |
|
Return (NXTD) /* \_SB_.PCI0.PCED.VGA_.NXTD */ |
|
} |
|
|
|
Method (NATK, 0, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (UPBL, 0, NotSerialized) |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Notify (LCDD, 0x86) // Device-Specific |
|
Sleep (0x19) |
|
Return (Zero) |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((\WMI0.LBTN < 0x0A)) |
|
{ |
|
Local0++ |
|
} |
|
Else |
|
{ |
|
Local0 = 0x0A |
|
} |
|
|
|
\WMI0.LBTN = Local0 |
|
^^^^ATKD.NTFY ((Local0 + 0x10)) |
|
} |
|
|
|
Notify (LCDD, 0x86) // Device-Specific |
|
} |
|
|
|
Method (DWBL, 0, NotSerialized) |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Notify (LCDD, 0x87) // Device-Specific |
|
Sleep (0x19) |
|
Return (Zero) |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((\WMI0.LBTN > Zero)) |
|
{ |
|
Local0-- |
|
} |
|
|
|
If ((\WMI0.LBTN > 0x0A)) |
|
{ |
|
Local0 = 0x0A |
|
} |
|
|
|
\WMI0.LBTN = Local0 |
|
^^^^ATKD.NTFY ((Local0 + 0x20)) |
|
} |
|
|
|
Notify (LCDD, 0x87) // Device-Specific |
|
} |
|
|
|
Method (GCBL, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
Arg0 &= 0x7FFFFFFF |
|
While ((Local0 < 0x0B)) |
|
{ |
|
Local1 = DerefOf (PCTG [(Local0 + 0x02)]) |
|
If ((Local1 >= Arg0)) |
|
{ |
|
Break |
|
} |
|
|
|
Local0++ |
|
} |
|
|
|
If ((Local0 >= 0x0B)) |
|
{ |
|
Local2 = 0x0A |
|
} |
|
Else |
|
{ |
|
Local2 = Local0 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
OperationRegion (PCFG, PCI_Config, Zero, 0x50) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
DVID, 32, |
|
Offset (0x2C), |
|
SVID, 32, |
|
Offset (0x4C), |
|
SMID, 32 |
|
} |
|
|
|
Name (DOSP, Zero) |
|
Name (BLVL, Buffer (0x10) |
|
{ |
|
/* 0000 */ 0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x70, // . 0@PX`p |
|
/* 0008 */ 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xFF // ........ |
|
}) |
|
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Device (HDAU) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
OperationRegion (PCFG, PCI_Config, Zero, 0x50) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
DVID, 32, |
|
Offset (0x2C), |
|
SVID, 32, |
|
Offset (0x4C), |
|
SMID, 32 |
|
} |
|
} |
|
|
|
Method (XPDT, 1, NotSerialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
Local0 = Zero |
|
Local2 = Zero |
|
While ((Local2 < 0x0F)) |
|
{ |
|
PDC2 = One |
|
Local4 = One |
|
Local5 = 0xC8 |
|
While ((Local4 && Local5)) |
|
{ |
|
Local6 = XPRD (0xA5) |
|
Local6 &= 0x7F |
|
If (((Local6 >= 0x10) && (Local6 != 0x7F))) |
|
{ |
|
Local4 = Zero |
|
} |
|
Else |
|
{ |
|
Sleep (0x05) |
|
Local5-- |
|
} |
|
} |
|
|
|
If (!Local4) |
|
{ |
|
Local5 = XPDL () |
|
If (Local5) |
|
{ |
|
XPRT () |
|
Sleep (0x05) |
|
Local2++ |
|
} |
|
Else |
|
{ |
|
INFO = (XPPB () << 0x03) |
|
BCMD = 0x87 |
|
^^SBRG.SMIC = Zero |
|
If ((XPR2 () == Ones)) |
|
{ |
|
Local0 = One |
|
Local2 = 0x10 |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
Local2 = 0x10 |
|
} |
|
} |
|
} |
|
Else |
|
{ |
|
Local2 = 0x10 |
|
} |
|
} |
|
|
|
If (!Local0) |
|
{ |
|
XPDT (Zero) |
|
XPPR (Zero) |
|
Return (Zero) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
Else |
|
{ |
|
PDC2 = One |
|
Local7 = ^VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x0A) |
|
Local4 = One |
|
Local5 = 0x05 |
|
While ((Local4 && Local5)) |
|
{ |
|
Local6 = XPRD (0xA5) |
|
Local6 &= 0x7F |
|
If ((Local6 <= 0x04)) |
|
{ |
|
Local4 = Zero |
|
} |
|
Else |
|
{ |
|
Local7 = ^VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x05) |
|
Local5-- |
|
} |
|
} |
|
|
|
Return (Ones) |
|
} |
|
} |
|
|
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR12) /* \_SB_.AR12 */ |
|
} |
|
|
|
Return (PR12) /* \_SB_.PR12 */ |
|
} |
|
} |
|
|
|
Device (BR13) |
|
{ |
|
Name (_ADR, 0x00030000) // _ADR: Address |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR13) /* \_SB_.AR13 */ |
|
} |
|
|
|
Return (PR13) /* \_SB_.PR13 */ |
|
} |
|
} |
|
|
|
Device (BR14) |
|
{ |
|
Name (_ADR, 0x00040000) // _ADR: Address |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR14) /* \_SB_.AR14 */ |
|
} |
|
|
|
Return (PR14) /* \_SB_.PR14 */ |
|
} |
|
} |
|
|
|
Device (BR15) |
|
{ |
|
Name (_ADR, 0x00050000) // _ADR: Address |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR15) /* \_SB_.AR15 */ |
|
} |
|
|
|
Return (PR15) /* \_SB_.PR15 */ |
|
} |
|
} |
|
|
|
Device (BR16) |
|
{ |
|
Name (_ADR, 0x00060000) // _ADR: Address |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR16) /* \_SB_.AR16 */ |
|
} |
|
|
|
Return (PR16) /* \_SB_.PR16 */ |
|
} |
|
} |
|
|
|
Device (BR17) |
|
{ |
|
Name (_ADR, 0x00070000) // _ADR: Address |
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR17) /* \_SB_.AR17 */ |
|
} |
|
|
|
Return (PR17) /* \_SB_.PR17 */ |
|
} |
|
} |
|
|
|
Device (SBAZ) |
|
{ |
|
Name (_ADR, 0x00140002) // _ADR: Address |
|
OperationRegion (PCI, PCI_Config, Zero, 0x0100) |
|
Field (PCI, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x42), |
|
DNSP, 1, |
|
DNSO, 1, |
|
ENSR, 1 |
|
} |
|
|
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x1B, 0x04)) |
|
} |
|
} |
|
|
|
Device (SBRG) |
|
{ |
|
Name (_ADR, 0x00140003) // _ADR: Address |
|
OperationRegion (RMBS, PCI_Config, Zero, 0x0100) |
|
Field (RMBS, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x6C), |
|
LR2S, 16, |
|
LR2E, 16 |
|
} |
|
|
|
Method (SPTS, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (SWAK, 1, NotSerialized) |
|
{ |
|
IRQC () |
|
} |
|
|
|
Scope (\_SB) |
|
{ |
|
Name (SLPS, Zero) |
|
} |
|
|
|
OperationRegion (SMI0, SystemIO, SMIO, One) |
|
Field (SMI0, ByteAcc, NoLock, Preserve) |
|
{ |
|
SMIC, 8 |
|
} |
|
|
|
Device (S900) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x0700) // _UID: Unique ID |
|
Name (_STA, 0x0F) // _STA: Status |
|
Name (CRS, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0010, // Range Minimum |
|
0x0010, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x0022, // Range Minimum |
|
0x0022, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x0063, // Range Minimum |
|
0x0063, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0065, // Range Minimum |
|
0x0065, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0067, // Range Minimum |
|
0x0067, // Range Maximum |
|
0x00, // Alignment |
|
0x09, // Length |
|
) |
|
IO (Decode16, |
|
0x0072, // Range Minimum |
|
0x0072, // Range Maximum |
|
0x00, // Alignment |
|
0x0E, // Length |
|
) |
|
IO (Decode16, |
|
0x0080, // Range Minimum |
|
0x0080, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0084, // Range Minimum |
|
0x0084, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0088, // Range Minimum |
|
0x0088, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x008C, // Range Minimum |
|
0x008C, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0090, // Range Minimum |
|
0x0090, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x00A2, // Range Minimum |
|
0x00A2, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x00B1, // Range Minimum |
|
0x00B1, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x00E0, // Range Minimum |
|
0x00E0, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x04D0, // Range Minimum |
|
0x04D0, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x040B, // Range Minimum |
|
0x040B, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x04D6, // Range Minimum |
|
0x04D6, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0C00, // Range Minimum |
|
0x0C00, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0C14, // Range Minimum |
|
0x0C14, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0C50, // Range Minimum |
|
0x0C50, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0C52, // Range Minimum |
|
0x0C52, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0C6C, // Range Minimum |
|
0x0C6C, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0C6F, // Range Minimum |
|
0x0C6F, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0CD0, // Range Minimum |
|
0x0CD0, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0CD2, // Range Minimum |
|
0x0CD2, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0CD4, // Range Minimum |
|
0x0CD4, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0CD6, // Range Minimum |
|
0x0CD6, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0CD8, // Range Minimum |
|
0x0CD8, // Range Maximum |
|
0x00, // Alignment |
|
0x08, // Length |
|
) |
|
IO (Decode16, |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
_Y0E) |
|
IO (Decode16, |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
_Y11) |
|
IO (Decode16, |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
_Y10) |
|
IO (Decode16, |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
_Y0F) |
|
IO (Decode16, |
|
0x0900, // Range Minimum |
|
0x0900, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x0910, // Range Minimum |
|
0x0910, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0xFE00, // Range Minimum |
|
0xFE00, // Range Maximum |
|
0x00, // Alignment |
|
0xFF, // Length |
|
) |
|
IO (Decode16, |
|
0x0060, // Range Minimum |
|
0x0060, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
) |
|
IO (Decode16, |
|
0x0064, // Range Minimum |
|
0x0064, // Range Maximum |
|
0x00, // Alignment |
|
0x00, // Length |
|
) |
|
Memory32Fixed (ReadWrite, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y12) |
|
Memory32Fixed (ReadWrite, |
|
0xFEE00000, // Address Base |
|
0x00001000, // Address Length |
|
) |
|
Memory32Fixed (ReadWrite, |
|
0xFED80000, // Address Base |
|
0x00010000, // Address Length |
|
) |
|
Memory32Fixed (ReadWrite, |
|
0xFED61000, // Address Base |
|
0x00010000, // Address Length |
|
) |
|
Memory32Fixed (ReadWrite, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y13) |
|
Memory32Fixed (ReadWrite, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y14) |
|
Memory32Fixed (ReadWrite, |
|
0x00000000, // Address Base |
|
0x00000000, // Address Length |
|
_Y15) |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y0E._MIN, PBB) // _MIN: Minimum Base Address |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y0E._MAX, PBH) // _MAX: Maximum Base Address |
|
CreateByteField (CRS, \_SB.PCI0.SBRG.S900._Y0E._LEN, PML) // _LEN: Length |
|
PBB = PMBS /* \PMBS */ |
|
PBH = PMBS /* \PMBS */ |
|
PML = PMLN /* \PMLN */ |
|
If (SMBB) |
|
{ |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y0F._MIN, SMB1) // _MIN: Minimum Base Address |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y0F._MAX, SMH1) // _MAX: Maximum Base Address |
|
CreateByteField (CRS, \_SB.PCI0.SBRG.S900._Y0F._LEN, SML1) // _LEN: Length |
|
SMB1 = SMBB /* \SMBB */ |
|
SMH1 = SMBB /* \SMBB */ |
|
SML1 = SMBL /* \SMBL */ |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y10._MIN, SMB0) // _MIN: Minimum Base Address |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y10._MAX, SMH0) // _MAX: Maximum Base Address |
|
CreateByteField (CRS, \_SB.PCI0.SBRG.S900._Y10._LEN, SML0) // _LEN: Length |
|
SMB0 = SMB0 /* \_SB_.PCI0.SBRG.S900._CRS.SMB0 */ |
|
SMH0 = SMB0 /* \_SB_.PCI0.SBRG.S900._CRS.SMB0 */ |
|
SML0 = SMBM /* \SMBM */ |
|
} |
|
|
|
If (GPBS) |
|
{ |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y11._MIN, IGB) // _MIN: Minimum Base Address |
|
CreateWordField (CRS, \_SB.PCI0.SBRG.S900._Y11._MAX, IGH) // _MAX: Maximum Base Address |
|
CreateByteField (CRS, \_SB.PCI0.SBRG.S900._Y11._LEN, IGL) // _LEN: Length |
|
IGB = GPBS /* \GPBS */ |
|
IGH = GPBS /* \GPBS */ |
|
IGL = GPLN /* \GPLN */ |
|
} |
|
|
|
If (APCB) |
|
{ |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y12._BAS, APB) // _BAS: Base Address |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y12._LEN, APL) // _LEN: Length |
|
APB = APCB /* \APCB */ |
|
APL = APCL /* \APCL */ |
|
} |
|
|
|
If (SPIB) |
|
{ |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y13._BAS, SPIB) // _BAS: Base Address |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y13._LEN, SPIL) // _LEN: Length |
|
SPIB = \SPIB |
|
SPIL = \SPIL |
|
} |
|
|
|
If (HPTB) |
|
{ |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y14._BAS, HXTB) // _BAS: Base Address |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y14._LEN, HXTL) // _LEN: Length |
|
HXTB = HPTB /* \HPTB */ |
|
HXTL = HPTL /* \HPTL */ |
|
} |
|
|
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y15._BAS, ROMB) // _BAS: Base Address |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.S900._Y15._LEN, ROML) // _LEN: Length |
|
If (LR2S) |
|
{ |
|
ROMB = (LR2S << 0x10) |
|
ROML = (((LR2E - LR2S) + One) << 0x10) |
|
} |
|
Else |
|
{ |
|
ROMB = ROMS /* \ROMS */ |
|
ROML = (Zero - ROMS) /* \ROMS */ |
|
} |
|
|
|
Return (CRS) /* \_SB_.PCI0.SBRG.S900.CRS_ */ |
|
} |
|
} |
|
|
|
Device (PIC) |
|
{ |
|
Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x0020, // Range Minimum |
|
0x0020, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x00A0, // Range Minimum |
|
0x00A0, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IRQNoFlags () |
|
{2} |
|
}) |
|
} |
|
|
|
Device (DMAD) |
|
{ |
|
Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
DMA (Compatibility, BusMaster, Transfer8, ) |
|
{4} |
|
IO (Decode16, |
|
0x0000, // Range Minimum |
|
0x0000, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x0081, // Range Minimum |
|
0x0081, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0087, // Range Minimum |
|
0x0087, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0089, // Range Minimum |
|
0x0089, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x008F, // Range Minimum |
|
0x008F, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x00C0, // Range Minimum |
|
0x00C0, // Range Maximum |
|
0x00, // Alignment |
|
0x20, // Length |
|
) |
|
}) |
|
} |
|
|
|
Device (TMR) |
|
{ |
|
Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x0040, // Range Minimum |
|
0x0040, // Range Maximum |
|
0x00, // Alignment |
|
0x04, // Length |
|
) |
|
IRQNoFlags () |
|
{0} |
|
}) |
|
} |
|
|
|
Device (RTC0) |
|
{ |
|
Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x0070, // Range Minimum |
|
0x0070, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IRQNoFlags () |
|
{8} |
|
}) |
|
} |
|
|
|
Device (SPKR) |
|
{ |
|
Name (_HID, EisaId ("PNP0800") /* Microsoft Sound System Compatible Device */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x0061, // Range Minimum |
|
0x0061, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
}) |
|
} |
|
|
|
Device (NBRM) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x99) // _UID: Unique ID |
|
Name (CRS, Buffer (0x02) |
|
{ |
|
0x79, 0x00 // y. |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
Return (CRS) /* \_SB_.PCI0.SBRG.NBRM.CRS_ */ |
|
} |
|
} |
|
|
|
Device (RMSC) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x10) // _UID: Unique ID |
|
Name (CRS1, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0010, // Range Minimum |
|
0x0010, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x0022, // Range Minimum |
|
0x0022, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x0044, // Range Minimum |
|
0x0044, // Range Maximum |
|
0x00, // Alignment |
|
0x1C, // Length |
|
) |
|
IO (Decode16, |
|
0x0062, // Range Minimum |
|
0x0062, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
IO (Decode16, |
|
0x0065, // Range Minimum |
|
0x0065, // Range Maximum |
|
0x00, // Alignment |
|
0x0B, // Length |
|
) |
|
IO (Decode16, |
|
0x0072, // Range Minimum |
|
0x0072, // Range Maximum |
|
0x00, // Alignment |
|
0x0E, // Length |
|
) |
|
IO (Decode16, |
|
0x0080, // Range Minimum |
|
0x0080, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0084, // Range Minimum |
|
0x0084, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0088, // Range Minimum |
|
0x0088, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x008C, // Range Minimum |
|
0x008C, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0090, // Range Minimum |
|
0x0090, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x00A2, // Range Minimum |
|
0x00A2, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x00E0, // Range Minimum |
|
0x00E0, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x04D0, // Range Minimum |
|
0x04D0, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
}) |
|
Name (CRS2, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0010, // Range Minimum |
|
0x0010, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x0022, // Range Minimum |
|
0x0022, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x0044, // Range Minimum |
|
0x0044, // Range Maximum |
|
0x00, // Alignment |
|
0x1C, // Length |
|
) |
|
IO (Decode16, |
|
0x0072, // Range Minimum |
|
0x0072, // Range Maximum |
|
0x00, // Alignment |
|
0x0E, // Length |
|
) |
|
IO (Decode16, |
|
0x0080, // Range Minimum |
|
0x0080, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0084, // Range Minimum |
|
0x0084, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0088, // Range Minimum |
|
0x0088, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x008C, // Range Minimum |
|
0x008C, // Range Maximum |
|
0x00, // Alignment |
|
0x03, // Length |
|
) |
|
IO (Decode16, |
|
0x0090, // Range Minimum |
|
0x0090, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x00A2, // Range Minimum |
|
0x00A2, // Range Maximum |
|
0x00, // Alignment |
|
0x1E, // Length |
|
) |
|
IO (Decode16, |
|
0x00E0, // Range Minimum |
|
0x00E0, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IO (Decode16, |
|
0x04D0, // Range Minimum |
|
0x04D0, // Range Maximum |
|
0x00, // Alignment |
|
0x02, // Length |
|
) |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
If ((MBEC & 0xFFFF)) |
|
{ |
|
Return (CRS1) /* \_SB_.PCI0.SBRG.RMSC.CRS1 */ |
|
} |
|
Else |
|
{ |
|
Return (CRS2) /* \_SB_.PCI0.SBRG.RMSC.CRS2 */ |
|
} |
|
} |
|
} |
|
|
|
Device (COPR) |
|
{ |
|
Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID |
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x00F0, // Range Minimum |
|
0x00F0, // Range Maximum |
|
0x00, // Alignment |
|
0x10, // Length |
|
) |
|
IRQNoFlags () |
|
{13} |
|
}) |
|
} |
|
|
|
Device (ADBG) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x13) // _UID: Unique ID |
|
Name (CRS1, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0240, // Range Minimum |
|
0x0240, // Range Maximum |
|
0x01, // Alignment |
|
0x1A, // Length |
|
) |
|
}) |
|
OperationRegion (DBGC, SystemIO, 0x0259, 0x10) |
|
Field (DBGC, ByteAcc, Lock, Preserve) |
|
{ |
|
DBGP, 8 |
|
} |
|
|
|
OperationRegion (DBPP, SystemIO, 0x0250, 0x02) |
|
Field (DBPP, ByteAcc, Lock, Preserve) |
|
{ |
|
PPDT, 8, |
|
PPST, 8 |
|
} |
|
|
|
OperationRegion (DB80, SystemIO, 0x80, One) |
|
Field (DB80, ByteAcc, Lock, Preserve) |
|
{ |
|
DP80, 8 |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
Return (CRS1) /* \_SB_.PCI0.SBRG.ADBG.CRS1 */ |
|
} |
|
|
|
Method (CALL, 0, Serialized) |
|
{ |
|
ISMI (0x96) |
|
} |
|
|
|
Method (PUTD, 1, Serialized) |
|
{ |
|
Local0 = ((Arg0 & 0x0F) | 0x10) |
|
Local1 = ((Arg0 >> 0x04) & 0x0F) |
|
Local2 = (~Local1 & 0x0F) |
|
Local4 = 0xFFFF |
|
PPDT = Local0 |
|
Local3 = ((PPST ^ 0x80) >> 0x03) |
|
While (((Local3 != 0x10) && (Local4 != Zero))) |
|
{ |
|
Local3 = ((PPST ^ 0x80) >> 0x03) |
|
Local4-- |
|
Stall (0x1E) |
|
} |
|
|
|
If ((Local4 == Zero)) |
|
{ |
|
PPDT = Zero |
|
Return (Zero) |
|
} |
|
|
|
Local4 = 0xFFFF |
|
PPDT = Local1 |
|
Local3 = ((PPST ^ 0x80) >> 0x03) |
|
While (((Local3 != Zero) && (Local4 != Zero))) |
|
{ |
|
Local3 = ((PPST ^ 0x80) >> 0x03) |
|
Local4-- |
|
Stall (0x1E) |
|
} |
|
|
|
If ((Local4 == Zero)) |
|
{ |
|
PPDT = Zero |
|
Return (Zero) |
|
} |
|
|
|
PPDT = Local2 |
|
Return (One) |
|
} |
|
|
|
Method (OUTS, 1, Serialized) |
|
{ |
|
If ((DBGP != 0xFF)) |
|
{ |
|
Local0 = (SizeOf (Arg0) + One) |
|
Local1 = Zero |
|
Name (BUFF, Buffer (Local0){}) |
|
BUFF = Arg0 |
|
Local0 -= One |
|
If ((PUTD (0x53) == Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
While ((DerefOf (BUFF [Local1]) != Zero)) |
|
{ |
|
If ((PUTD (DerefOf (BUFF [Local1])) == Zero)) |
|
{ |
|
PUTD (Zero) |
|
Return (Zero) |
|
} |
|
|
|
Local1++ |
|
} |
|
|
|
PUTD (Zero) |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (OUTD, 1, Serialized) |
|
{ |
|
Name (DEC, Buffer (0x0B) |
|
{ |
|
"0123456789" |
|
}) |
|
Name (TMP, Buffer (0x0B){}) |
|
Local0 = Zero |
|
Local1 = Arg0 |
|
If ((Local1 == Zero)) |
|
{ |
|
OUTS ("0") |
|
} |
|
Else |
|
{ |
|
While ((Local1 > Zero)) |
|
{ |
|
Divide (Local1, 0x0A, Local2, Local1) |
|
TMP [Local0] = DerefOf (DEC [Local2]) |
|
Local0++ |
|
TMP [Local0] = Zero |
|
} |
|
|
|
Local2 = Zero |
|
Local0-- |
|
While ((Local2 < Local0)) |
|
{ |
|
Local3 = DerefOf (TMP [Local2]) |
|
TMP [Local2] = DerefOf (TMP [Local0]) |
|
TMP [Local0] = Local3 |
|
Local2++ |
|
Local0-- |
|
} |
|
|
|
OUTS (TMP) |
|
} |
|
} |
|
|
|
Method (OUTH, 1, Serialized) |
|
{ |
|
Name (HEX, Buffer (0x11) |
|
{ |
|
"0123456789ABCDEF" |
|
}) |
|
Name (TMP, Buffer (0x0A){}) |
|
Local0 = Zero |
|
Local1 = Arg0 |
|
While ((Local0 < 0x08)) |
|
{ |
|
Local2 = (Local1 & 0x0F) |
|
TMP [Local0] = DerefOf (HEX [Local2]) |
|
Local1 >>= 0x04 |
|
Local0++ |
|
TMP [Local0] = Zero |
|
} |
|
|
|
Local2 = Zero |
|
Local0-- |
|
While ((Local2 < Local0)) |
|
{ |
|
Local3 = DerefOf (TMP [Local2]) |
|
TMP [Local2] = DerefOf (TMP [Local0]) |
|
TMP [Local0] = Local3 |
|
Local2++ |
|
Local0-- |
|
} |
|
|
|
OUTS (TMP) |
|
} |
|
} |
|
|
|
Device (PS2M) |
|
{ |
|
Method (_HID, 0, NotSerialized) // _HID: Hardware ID |
|
{ |
|
If (\WMI0.SYNA) |
|
{ |
|
Return (0x191D2E4F) |
|
} |
|
|
|
If (\WMI0.ALPS) |
|
{ |
|
Return (0x09018416) |
|
} |
|
|
|
Return (0x060A2E4F) |
|
} |
|
|
|
Name (_CID, Package (0x03) // _CID: Compatible ID |
|
{ |
|
EisaId ("SYN1D00"), |
|
EisaId ("SYN0002"), |
|
EisaId ("PNP0F13") /* PS/2 Mouse */ |
|
}) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Local0 = (One << 0x0E) |
|
If ((IOST & Local0)) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Name (CRS1, ResourceTemplate () |
|
{ |
|
IRQNoFlags () |
|
{12} |
|
}) |
|
Name (CRS2, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0060, // Range Minimum |
|
0x0060, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0064, // Range Minimum |
|
0x0064, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IRQNoFlags () |
|
{12} |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
Local0 = (One << 0x0A) |
|
If ((IOST & Local0)) |
|
{ |
|
Return (CRS1) /* \_SB_.PCI0.SBRG.PS2M.CRS1 */ |
|
} |
|
Else |
|
{ |
|
Return (CRS2) /* \_SB_.PCI0.SBRG.PS2M.CRS2 */ |
|
} |
|
} |
|
} |
|
|
|
Device (PS2K) |
|
{ |
|
Name (_HID, "ATK3001") // _HID: Hardware ID |
|
Name (_CID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _CID: Compatible ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Local0 = (One << 0x0A) |
|
If ((IOST & Local0)) |
|
{ |
|
Return (0x0F) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
|
{ |
|
IO (Decode16, |
|
0x0060, // Range Minimum |
|
0x0060, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0064, // Range Minimum |
|
0x0064, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IRQNoFlags () |
|
{1} |
|
}) |
|
} |
|
} |
|
|
|
Device (P0PC) |
|
{ |
|
Name (_ADR, 0x00140004) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x04, 0x04)) |
|
} |
|
} |
|
|
|
Device (OHC1) |
|
{ |
|
Name (_ADR, 0x00120000) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (EHC1) |
|
{ |
|
Name (_ADR, 0x00120002) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (OHC2) |
|
{ |
|
Name (_ADR, 0x00130000) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (EHC2) |
|
{ |
|
Name (_ADR, 0x00130002) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (OHC3) |
|
{ |
|
Name (_ADR, 0x00160000) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (EHC3) |
|
{ |
|
Name (_ADR, 0x00160002) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (OHC4) |
|
{ |
|
Name (_ADR, 0x00140005) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (XHC0) |
|
{ |
|
Name (_ADR, 0x00100000) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (XHC1) |
|
{ |
|
Name (_ADR, 0x00100001) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x0B, 0x03)) |
|
} |
|
} |
|
|
|
Device (PE20) |
|
{ |
|
Name (_ADR, 0x00150000) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
|
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR20) /* \_SB_.AR20 */ |
|
} |
|
|
|
Return (PR20) /* \_SB_.PR20 */ |
|
} |
|
} |
|
|
|
Device (PE21) |
|
{ |
|
Name (_ADR, 0x00150001) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
|
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR21) /* \_SB_.AR21 */ |
|
} |
|
|
|
Return (PR21) /* \_SB_.PR21 */ |
|
} |
|
|
|
Device (WLAN) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
OperationRegion (MINP, PCI_Config, Zero, 0x68) |
|
Field (MINP, ByteAcc, NoLock, Preserve) |
|
{ |
|
VNUM, 32, |
|
Offset (0x09), |
|
PINF, 8, |
|
SBCC, 8, |
|
BSCC, 8, |
|
Offset (0x2C), |
|
SNUM, 32, |
|
Offset (0x34) |
|
} |
|
|
|
Method (MPDP, 0, NotSerialized) |
|
{ |
|
If ((SNUM == 0xFFFFFFFF)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((BSCC != 0x02)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
} |
|
} |
|
|
|
Device (PE22) |
|
{ |
|
Name (_ADR, 0x00150002) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
|
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR22) /* \_SB_.AR22 */ |
|
} |
|
|
|
Return (PR22) /* \_SB_.PR22 */ |
|
} |
|
|
|
Device (GLAN) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
OperationRegion (LANR, PCI_Config, Zero, 0x0100) |
|
Field (LANR, ByteAcc, NoLock, Preserve) |
|
{ |
|
VID, 16, |
|
Offset (0xE0), |
|
, 15, |
|
PMES, 1 |
|
} |
|
|
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
} |
|
} |
|
|
|
Device (PE23) |
|
{ |
|
Name (_ADR, 0x00150003) // _ADR: Address |
|
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
|
{ |
|
Return (GPRW (0x09, 0x04)) |
|
} |
|
|
|
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
|
{ |
|
If (PICM) |
|
{ |
|
Return (AR23) /* \_SB_.AR23 */ |
|
} |
|
|
|
Return (PR23) /* \_SB_.PR23 */ |
|
} |
|
} |
|
|
|
Device (VGA) |
|
{ |
|
Name (_ADR, 0x00010000) // _ADR: Address |
|
OperationRegion (VSID, PCI_Config, Zero, 0x20) |
|
Field (VSID, ByteAcc, NoLock, Preserve) |
|
{ |
|
REG0, 32, |
|
REG4, 32, |
|
REG8, 32 |
|
} |
|
|
|
Method (PRST, 0, NotSerialized) |
|
{ |
|
If ((REG0 == 0xFFFFFFFF)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf (((REG8 & 0xFFFFFF00) == 0x03000000)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (DVIM, 0x10) |
|
Name (HDMM, 0x08) |
|
Name (PCTG, Package (0x0D){}) |
|
Name (PCW8, Package (0x67){}) |
|
Name (LCDM, One) |
|
Name (CRTM, 0x02) |
|
Name (TVOM, 0x04) |
|
Name (DO1M, 0x10) |
|
Name (DO2M, 0x08) |
|
Name (DONE, Zero) |
|
Name (DOSF, One) |
|
Name (BRNC, Zero) |
|
Name (UPDN, One) |
|
Name (NXTD, One) |
|
Name (GADD, Zero) |
|
Method (MD2A, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
If ((Arg0 & LCDM)) |
|
{ |
|
Local0 |= One |
|
} |
|
|
|
If ((Arg0 & CRTM)) |
|
{ |
|
Local0 |= 0x02 |
|
} |
|
|
|
If ((Arg0 & TVOM)) |
|
{ |
|
Local0 |= 0x04 |
|
} |
|
|
|
If ((Arg0 & DVIM)) |
|
{ |
|
Local0 |= 0x08 |
|
} |
|
|
|
If ((Arg0 & HDMM)) |
|
{ |
|
Local0 |= 0x10 |
|
} |
|
|
|
If (!Local0) |
|
{ |
|
Return (NXTD) /* \_SB_.PCI0.VGA_.NXTD */ |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (MA2D, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
If ((Arg0 & One)) |
|
{ |
|
Local0 |= LCDM /* \_SB_.PCI0.VGA_.LCDM */ |
|
} |
|
|
|
If ((Arg0 & 0x02)) |
|
{ |
|
Local0 |= CRTM /* \_SB_.PCI0.VGA_.CRTM */ |
|
} |
|
|
|
If ((Arg0 & 0x04)) |
|
{ |
|
Local0 |= TVOM /* \_SB_.PCI0.VGA_.TVOM */ |
|
} |
|
|
|
If ((Arg0 & 0x08)) |
|
{ |
|
Local0 |= DVIM /* \_SB_.PCI0.VGA_.DVIM */ |
|
} |
|
|
|
If ((Arg0 & 0x10)) |
|
{ |
|
Local0 |= HDMM /* \_SB_.PCI0.VGA_.HDMM */ |
|
} |
|
|
|
If (!Local0) |
|
{ |
|
Return (LCDM) /* \_SB_.PCI0.VGA_.LCDM */ |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize |
|
{ |
|
} |
|
|
|
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching |
|
{ |
|
DOSF = (Arg0 & 0x03) |
|
BRNC = (Arg0 >> 0x02) |
|
BRNC &= One |
|
If ((OSFG >= OSW8)) |
|
{ |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
AF7E |= One |
|
} |
|
} |
|
} |
|
|
|
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices |
|
{ |
|
Name (ADOD, Package (0x03) |
|
{ |
|
0x00010110, |
|
0x00010100, |
|
0x0210 |
|
}) |
|
Name (NDOD, Package (0x03) |
|
{ |
|
0x00010110, |
|
0x00010100, |
|
0x0121 |
|
}) |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
Return (ADOD) /* \_SB_.PCI0.VGA_._DOD.ADOD */ |
|
} |
|
Else |
|
{ |
|
Return (NDOD) /* \_SB_.PCI0.VGA_._DOD.NDOD */ |
|
} |
|
} |
|
|
|
Device (LCDD) |
|
{ |
|
Name (_ADR, 0x0110) // _ADR: Address |
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & LCDM)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & LCDM)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
|
|
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Local0 = Zero |
|
Local1 = ((\WMI0.AB00 * 0x64) / 0xFF) |
|
While ((Local0 < 0x65)) |
|
{ |
|
If ((Local0 < Local1)) |
|
{ |
|
PCW8 [(Local0 + 0x02)] = Local1 |
|
} |
|
Else |
|
{ |
|
PCW8 [(Local0 + 0x02)] = Local0 |
|
} |
|
|
|
Local0++ |
|
} |
|
|
|
PCW8 [Zero] = 0x64 |
|
PCW8 [One] = 0x28 |
|
Return (PCW8) /* \_SB_.PCI0.VGA_.PCW8 */ |
|
} |
|
|
|
Local0 = (0x0B - One) |
|
Local1 = ^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [Zero] = Local2 |
|
Local0 = (0x0B - 0x04) |
|
Local1 = ^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [One] = Local2 |
|
Local0 = Zero |
|
While ((Local0 < 0x0B)) |
|
{ |
|
Local1 = ^^^SBRG.HEC.PWAC (Local0) |
|
Local2 = ((Local1 * 0x64) / 0xFF) |
|
PCTG [(Local0 + 0x02)] = Local2 |
|
Local0++ |
|
} |
|
|
|
Return (PCTG) /* \_SB_.PCI0.VGA_.PCTG */ |
|
} |
|
|
|
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method |
|
{ |
|
Local0 = GCBL (Arg0) |
|
\WMI0.LBTN = Local0 |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Local1 = ((Local0 * 0xFF) / 0x64) |
|
If ((AF7E == 0x80000001)) |
|
{ |
|
AFN7 (Local1) |
|
} |
|
} |
|
Else |
|
{ |
|
^^^SBRG.HEC.STBR () |
|
} |
|
} |
|
|
|
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Return (DerefOf (PCW8 [(Local0 + 0x02)])) |
|
} |
|
Else |
|
{ |
|
Return (DerefOf (PCTG [(Local0 + 0x02)])) |
|
} |
|
} |
|
} |
|
|
|
Device (CRTD) |
|
{ |
|
Name (_ADR, 0x0100) // _ADR: Address |
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & CRTM)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & CRTM)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
} |
|
|
|
Device (DO2D) |
|
{ |
|
Method (_ADR, 0, NotSerialized) // _ADR: Address |
|
{ |
|
If ((\WMI0.VGAF == 0x02)) |
|
{ |
|
Return (0x0210) |
|
} |
|
Else |
|
{ |
|
Return (0x0121) |
|
} |
|
} |
|
|
|
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status |
|
{ |
|
If ((\WMI0.AVLD & DO2M)) |
|
{ |
|
Return (0x1F) |
|
} |
|
|
|
Return (0x1D) |
|
} |
|
|
|
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State |
|
{ |
|
If ((\WMI0.SETD & DO2M)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State |
|
{ |
|
If ((Arg0 & 0x40000000)) |
|
{ |
|
If ((Arg0 & 0x80000000)) |
|
{ |
|
DONE = One |
|
} |
|
} |
|
} |
|
} |
|
|
|
Method (SWHD, 1, Serialized) |
|
{ |
|
UPDN = One |
|
If ((DOSF & 0x03)) |
|
{ |
|
\WMI0.SETD = MA2D (Arg0) |
|
ISMI (0x94) |
|
} |
|
Else |
|
{ |
|
\WMI0.SETD = MA2D (Arg0) |
|
Notify (VGA, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Method (GETD, 0, NotSerialized) |
|
{ |
|
GADD = One |
|
AFN0 () |
|
Local0 = Zero |
|
While (((Local0 < 0x0A) && GADD)) |
|
{ |
|
Sleep (0x64) |
|
Local0++ |
|
} |
|
|
|
GADD = Zero |
|
Return (\WMI0.ACTD) |
|
} |
|
|
|
Method (GNDD, 0, NotSerialized) |
|
{ |
|
ISMI (0xA0) |
|
Return (\WMI0.SETD) |
|
} |
|
|
|
Method (ADVD, 0, NotSerialized) |
|
{ |
|
If (UPDN) |
|
{ |
|
GETD () |
|
\WMI0.SETD = \WMI0.ACTD |
|
UPDN = Zero |
|
} |
|
|
|
GNDD () |
|
NXTD = \WMI0.SETD |
|
NXTD = MD2A (NXTD) |
|
Return (NXTD) /* \_SB_.PCI0.VGA_.NXTD */ |
|
} |
|
|
|
Method (NATK, 0, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (UPBL, 0, NotSerialized) |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Notify (LCDD, 0x86) // Device-Specific |
|
Sleep (0x19) |
|
Return (Zero) |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((\WMI0.LBTN < 0x0A)) |
|
{ |
|
Local0++ |
|
} |
|
Else |
|
{ |
|
Local0 = 0x0A |
|
} |
|
|
|
\WMI0.LBTN = Local0 |
|
^^^ATKD.NTFY ((Local0 + 0x10)) |
|
} |
|
|
|
Notify (LCDD, 0x86) // Device-Specific |
|
} |
|
|
|
Method (DWBL, 0, NotSerialized) |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
Notify (LCDD, 0x87) // Device-Specific |
|
Sleep (0x19) |
|
Return (Zero) |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
Local0 = \WMI0.LBTN |
|
If ((\WMI0.LBTN > Zero)) |
|
{ |
|
Local0-- |
|
} |
|
|
|
If ((\WMI0.LBTN > 0x0A)) |
|
{ |
|
Local0 = 0x0A |
|
} |
|
|
|
\WMI0.LBTN = Local0 |
|
^^^ATKD.NTFY ((Local0 + 0x20)) |
|
} |
|
|
|
Notify (LCDD, 0x87) // Device-Specific |
|
} |
|
|
|
Method (GCBL, 1, NotSerialized) |
|
{ |
|
Local0 = Zero |
|
Arg0 &= 0x7FFFFFFF |
|
While ((Local0 < 0x0B)) |
|
{ |
|
Local1 = DerefOf (PCTG [(Local0 + 0x02)]) |
|
If ((Local1 >= Arg0)) |
|
{ |
|
Break |
|
} |
|
|
|
Local0++ |
|
} |
|
|
|
If ((Local0 >= 0x0B)) |
|
{ |
|
Local2 = 0x0A |
|
} |
|
Else |
|
{ |
|
Local2 = Local0 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
} |
|
|
|
Device (SATA) |
|
{ |
|
Name (_ADR, 0x00110000) // _ADR: Address |
|
Method (_INI, 0, NotSerialized) // _INI: Initialize |
|
{ |
|
} |
|
|
|
OperationRegion (SACS, PCI_Config, Zero, 0x40) |
|
Field (SACS, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x24), |
|
STB5, 32 |
|
} |
|
|
|
Name (SPTM, Buffer (0x14) |
|
{ |
|
/* 0000 */ 0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, // x....... |
|
/* 0008 */ 0x78, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, // x....... |
|
/* 0010 */ 0x1F, 0x00, 0x00, 0x00 // .... |
|
}) |
|
Device (PRID) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
|
{ |
|
Return (SPTM) /* \_SB_.PCI0.SATA.SPTM */ |
|
} |
|
|
|
Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
|
{ |
|
} |
|
|
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If ((STCL == 0x0101)) |
|
{ |
|
Local1 = 0x0F |
|
} |
|
Else |
|
{ |
|
Local1 = Zero |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Name (PRIS, Zero) |
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x120), |
|
, 7, |
|
PMBY, 1, |
|
Offset (0x128), |
|
PMS0, 4, |
|
Offset (0x129), |
|
PMS1, 4, |
|
Offset (0x220), |
|
, 7, |
|
PSBY, 1, |
|
Offset (0x228), |
|
PSS0, 4, |
|
Offset (0x229), |
|
PSS1, 4, |
|
Offset (0x2A0), |
|
, 7 |
|
} |
|
|
|
If (((OSVR == 0x06) || (OSVR == 0x04))) |
|
{ |
|
If (PMS1) |
|
{ |
|
Local0 = 0x32 |
|
While (((PMBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
} |
|
|
|
If (PSS1) |
|
{ |
|
Local0 = 0x32 |
|
While (((PSBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
PRIS = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
PRIS = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (PRIS) /* \_SB_.PCI0.SATA.PRID.PRIS */ |
|
} |
|
|
|
Device (P_D0) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x128), |
|
PMS0, 4, |
|
Offset (0x129), |
|
PMS1, 4 |
|
} |
|
|
|
If (~(PMS1 == Zero)) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (S12P, Zero) |
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x120), |
|
, 7, |
|
PMBY, 1 |
|
} |
|
|
|
Local0 = 0x32 |
|
While (((PMBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
|
|
S12P = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
S12P = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (S12P) /* \_SB_.PCI0.SATA.PRID.P_D0.S12P */ |
|
} |
|
} |
|
|
|
Device (P_D1) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x228), |
|
PSS0, 4, |
|
Offset (0x229), |
|
PSS1, 4 |
|
} |
|
|
|
If (~(PSS1 == Zero)) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (S12P, Zero) |
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x220), |
|
, 7, |
|
PSBY, 1 |
|
} |
|
|
|
Local0 = 0x32 |
|
While (((PSBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
|
|
S12P = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
S12P = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (S12P) /* \_SB_.PCI0.SATA.PRID.P_D1.S12P */ |
|
} |
|
} |
|
} |
|
|
|
Device (SECD) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
|
{ |
|
Return (SPTM) /* \_SB_.PCI0.SATA.SPTM */ |
|
} |
|
|
|
Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
|
{ |
|
} |
|
|
|
Name (SECS, Zero) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If ((STCL == 0x0101)) |
|
{ |
|
Local1 = 0x0F |
|
} |
|
Else |
|
{ |
|
Local1 = Zero |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x1A0), |
|
, 7, |
|
SMBY, 1, |
|
Offset (0x1A8), |
|
SMS0, 4, |
|
Offset (0x1A9), |
|
SMS1, 4, |
|
Offset (0x2A0), |
|
, 7, |
|
SSBY, 1, |
|
Offset (0x2A8), |
|
SSS0, 4, |
|
Offset (0x2A9), |
|
SSS1, 4, |
|
Offset (0x2AC) |
|
} |
|
|
|
If (((OSVR == 0x06) || (OSVR == 0x04))) |
|
{ |
|
If (SMS1) |
|
{ |
|
Local0 = 0x32 |
|
While (((SMBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
} |
|
|
|
If (SSS1) |
|
{ |
|
Local0 = 0x32 |
|
While (((SSBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
SECS = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
SECS = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (SECS) /* \_SB_.PCI0.SATA.SECD.SECS */ |
|
} |
|
|
|
Device (S_D0) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x1A8), |
|
SMS0, 4, |
|
Offset (0x1A9), |
|
SMS1, 4 |
|
} |
|
|
|
If (~(SMS1 == Zero)) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (S12P, Zero) |
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x1000) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x1A0), |
|
, 7, |
|
SMBY, 1 |
|
} |
|
|
|
Local0 = 0x32 |
|
While (((SMBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
|
|
S12P = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
S12P = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (S12P) /* \_SB_.PCI0.SATA.SECD.S_D0.S12P */ |
|
} |
|
} |
|
|
|
Device (S_D1) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x2A8), |
|
SSS0, 4, |
|
Offset (0x2A9), |
|
SSS1, 4 |
|
} |
|
|
|
If (~(SSS1 == Zero)) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (S12P, Zero) |
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
OperationRegion (BAR, SystemMemory, STB5, 0x0400) |
|
Field (BAR, AnyAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x2A0), |
|
, 7, |
|
SSBY, 1 |
|
} |
|
|
|
Local0 = 0x32 |
|
While (((SSBY == One) && Local0)) |
|
{ |
|
Sleep (0xFA) |
|
Local0-- |
|
} |
|
|
|
S12P = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
S12P = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (S12P) /* \_SB_.PCI0.SATA.SECD.S_D1.S12P */ |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02) |
|
Field (PIRQ, ByteAcc, NoLock, Preserve) |
|
{ |
|
PIDX, 8, |
|
PDAT, 8 |
|
} |
|
|
|
IndexField (PIDX, PDAT, ByteAcc, NoLock, Preserve) |
|
{ |
|
PIRA, 8, |
|
PIRB, 8, |
|
PIRC, 8, |
|
PIRD, 8, |
|
PIRE, 8, |
|
PIRF, 8, |
|
PIRG, 8, |
|
PIRH, 8, |
|
Offset (0x10), |
|
PIRS, 8, |
|
Offset (0x13), |
|
HDAD, 8, |
|
Offset (0x15), |
|
GEC, 8, |
|
Offset (0x30), |
|
USB1, 8, |
|
USB2, 8, |
|
USB3, 8, |
|
USB4, 8, |
|
USB5, 8, |
|
USB6, 8, |
|
USB7, 8, |
|
Offset (0x40), |
|
IDE, 8, |
|
SATA, 8, |
|
Offset (0x50), |
|
GPP0, 8, |
|
GPP1, 8, |
|
GPP2, 8, |
|
GPP3, 8 |
|
} |
|
|
|
OperationRegion (KBDD, SystemIO, 0x64, One) |
|
Field (KBDD, ByteAcc, NoLock, Preserve) |
|
{ |
|
PD64, 8 |
|
} |
|
|
|
Method (IRQC, 0, NotSerialized) |
|
{ |
|
INTA (0x1F) |
|
INTB (0x1F) |
|
INTC (0x1F) |
|
INTD (0x1F) |
|
Local1 = PD64 /* \_SB_.PD64 */ |
|
PIRE = 0x1F |
|
PIRF = 0x1F |
|
PIRG = 0x1F |
|
PIRH = 0x1F |
|
} |
|
|
|
Method (INTA, 1, NotSerialized) |
|
{ |
|
PIRA = Arg0 |
|
HDAD = Arg0 |
|
GEC = Arg0 |
|
GPP0 = Arg0 |
|
GPP0 = Arg0 |
|
} |
|
|
|
Method (INTB, 1, NotSerialized) |
|
{ |
|
PIRB = Arg0 |
|
USB2 = Arg0 |
|
USB4 = Arg0 |
|
USB6 = Arg0 |
|
GPP1 = Arg0 |
|
IDE = Arg0 |
|
} |
|
|
|
Method (INTC, 1, NotSerialized) |
|
{ |
|
PIRC = Arg0 |
|
USB1 = Arg0 |
|
USB3 = Arg0 |
|
USB5 = Arg0 |
|
USB7 = Arg0 |
|
GPP2 = Arg0 |
|
} |
|
|
|
Method (INTD, 1, NotSerialized) |
|
{ |
|
PIRD = Arg0 |
|
SATA = Arg0 |
|
GPP3 = Arg0 |
|
} |
|
|
|
Name (BUFA, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{15} |
|
}) |
|
Name (IPRA, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{5,10,11} |
|
}) |
|
Name (IPRB, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{5,10,11} |
|
}) |
|
Name (IPRC, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{5,10,11} |
|
}) |
|
Name (IPRD, ResourceTemplate () |
|
{ |
|
IRQ (Level, ActiveLow, Shared, ) |
|
{5,10,11} |
|
}) |
|
Device (LNKA) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, One) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRA) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSA) /* \_SB_.PRSA */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
INTA (0x1F) |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRA) /* \_SB_.PIRA */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
INTA (Local0) |
|
} |
|
} |
|
|
|
Device (LNKB) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x02) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRB) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSB) /* \_SB_.PRSB */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
INTB (0x1F) |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRB) /* \_SB_.PIRB */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
INTB (Local0) |
|
} |
|
} |
|
|
|
Device (LNKC) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x03) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRC) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSC) /* \_SB_.PRSC */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
INTC (0x1F) |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRC) /* \_SB_.PIRC */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
INTC (Local0) |
|
} |
|
} |
|
|
|
Device (LNKD) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x04) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRD) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSD) /* \_SB_.PRSD */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
INTD (0x1F) |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRD) /* \_SB_.PIRD */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
INTD (Local0) |
|
} |
|
} |
|
|
|
Device (LNKE) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x05) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRE) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSE) /* \_SB_.PRSE */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
PIRE = 0x1F |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRE) /* \_SB_.PIRE */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (PIRE, Local0) |
|
Local0-- |
|
PIRE = Local0 |
|
} |
|
} |
|
|
|
Device (LNKF) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x02) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRF) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSF) /* \_SB_.PRSF */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
PIRF = 0x1F |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRF) /* \_SB_.PIRF */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
PIRF = Local0 |
|
} |
|
} |
|
|
|
Device (LNKG) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x03) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRG) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSG) /* \_SB_.PRSG */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
PIRG = 0x1F |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRG) /* \_SB_.PIRG */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
PIRG = Local0 |
|
} |
|
} |
|
|
|
Device (LNKH) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
|
Name (_UID, 0x04) // _UID: Unique ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (PIRH) |
|
{ |
|
Return (0x0B) |
|
} |
|
Else |
|
{ |
|
Return (0x09) |
|
} |
|
} |
|
|
|
Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
|
{ |
|
Return (PRSH) /* \_SB_.PRSH */ |
|
} |
|
|
|
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
|
{ |
|
PIRH = 0x1F |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateWordField (BUFA, One, IRQX) |
|
IRQX = (One << PIRH) /* \_SB_.PIRH */ |
|
Return (BUFA) /* \_SB_.BUFA */ |
|
} |
|
|
|
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
|
{ |
|
CreateWordField (Arg0, One, IRA) |
|
FindSetRightBit (IRA, Local0) |
|
Local0-- |
|
PIRH = Local0 |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Method (_INI, 0, NotSerialized) // _INI: Initialize |
|
{ |
|
OSFL () |
|
If ((RVID <= 0x13)){} |
|
If (IMCS) |
|
{ |
|
IBWE () |
|
} |
|
|
|
PINI () |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Scope (PCI0) |
|
{ |
|
Scope (SBRG) |
|
{ |
|
Method (RRIO, 4, NotSerialized) |
|
{ |
|
Debug = "RRIO" |
|
} |
|
|
|
Method (RDMA, 3, NotSerialized) |
|
{ |
|
Debug = "rDMA" |
|
} |
|
} |
|
} |
|
} |
|
|
|
Device (HPET) |
|
{ |
|
Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID |
|
Name (CRS, ResourceTemplate () |
|
{ |
|
Memory32Fixed (ReadOnly, |
|
0xFED00000, // Address Base |
|
0x00000400, // Address Length |
|
_Y16) |
|
}) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (0x0F) |
|
} |
|
|
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateDWordField (CRS, \HPET._Y16._BAS, HPT) // _BAS: Base Address |
|
HPT = 0xFED00000 |
|
Return (CRS) /* \HPET.CRS_ */ |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities |
|
{ |
|
Name (SUPP, Zero) |
|
Name (CTRL, Zero) |
|
If ((Arg0 == ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)) |
|
{ |
|
CreateDWordField (Arg3, Zero, CDW1) |
|
CreateDWordField (Arg3, 0x04, CDW2) |
|
CreateDWordField (Arg3, 0x08, CDW3) |
|
SUPP = CDW2 /* \_SB_.PCI0._OSC.CDW2 */ |
|
CTRL = CDW3 /* \_SB_.PCI0._OSC.CDW3 */ |
|
If (((SUPP & 0x16) != 0x16)) |
|
{ |
|
(CTRL & 0x1E) |
|
} |
|
|
|
If (!PEHP) |
|
{ |
|
CTRL &= 0x1E |
|
} |
|
|
|
If (!SHPC) |
|
{ |
|
CTRL &= 0x1D |
|
} |
|
|
|
If (!PEPM) |
|
{ |
|
CTRL &= 0x1B |
|
} |
|
|
|
If (!PEER) |
|
{ |
|
CTRL &= 0x15 |
|
} |
|
|
|
If (!PECS) |
|
{ |
|
CTRL &= 0x0F |
|
} |
|
|
|
If (\OSCF) |
|
{ |
|
If (~(CDW1 & One)) |
|
{ |
|
If ((CTRL & One)){} |
|
If ((CTRL & 0x04)) |
|
{ |
|
EPNM = One |
|
} |
|
Else |
|
{ |
|
EPNM = Zero |
|
} |
|
|
|
If ((CTRL & 0x10)){} |
|
} |
|
} |
|
|
|
If ((Arg1 != One)) |
|
{ |
|
CDW1 |= 0x08 |
|
} |
|
|
|
If ((CDW3 != CTRL)) |
|
{ |
|
CDW1 |= 0x10 |
|
} |
|
|
|
CDW3 = CTRL /* \_SB_.PCI0._OSC.CTRL */ |
|
Return (Arg3) |
|
} |
|
Else |
|
{ |
|
CDW1 |= 0x04 |
|
Return (Arg3) |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.VGA) |
|
{ |
|
Name (PXEN, 0x80000001) |
|
Name (PXID, 0x00020000) |
|
Name (PXMX, 0x80000001) |
|
Name (LCDT, 0x80000000) |
|
Name (DSCT, 0x80000000) |
|
Name (AF7E, 0x80000001) |
|
Name (PXDY, 0x80000001) |
|
Name (PXFX, 0x80000000) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (0x0F) |
|
} |
|
|
|
Scope (\_SB.PCI0.VGA) |
|
{ |
|
Name (ATIB, Buffer (0x0100){}) |
|
Method (ATIF, 2, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Return (AF00 ()) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
Return (AF01 ()) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (AF02 ()) |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
Return (AF03 (DerefOf (Arg1 [0x02]), DerefOf (Arg1 [0x04]))) |
|
} |
|
|
|
If ((Arg0 == 0x0F)) |
|
{ |
|
Return (AF15 ()) |
|
} |
|
Else |
|
{ |
|
CreateWordField (ATIB, Zero, SSZE) |
|
CreateWordField (ATIB, 0x02, VERN) |
|
CreateDWordField (ATIB, 0x04, NMSK) |
|
CreateDWordField (ATIB, 0x08, SFUN) |
|
SSZE = Zero |
|
VERN = Zero |
|
NMSK = Zero |
|
SFUN = Zero |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
} |
|
|
|
Method (AF00, 0, NotSerialized) |
|
{ |
|
P80H = 0xF0 |
|
AZPS &= 0xC0000001 |
|
CreateWordField (ATIB, Zero, SSZE) |
|
CreateWordField (ATIB, 0x02, VERN) |
|
CreateDWordField (ATIB, 0x04, NMSK) |
|
CreateDWordField (ATIB, 0x08, SFUN) |
|
SSZE = 0x0C |
|
VERN = One |
|
If ((PXEN == 0x80000000)) |
|
{ |
|
NMSK = 0x11 |
|
} |
|
Else |
|
{ |
|
NMSK = 0x51 |
|
} |
|
|
|
If ((AF7E == 0x80000001)) |
|
{ |
|
NMSK |= 0x80 |
|
} |
|
|
|
MSKN = NMSK /* \_SB_.PCI0.VGA_.AF00.NMSK */ |
|
SFUN = 0x07 |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Name (NCOD, 0x81) |
|
Method (AF01, 0, NotSerialized) |
|
{ |
|
P80H = 0xF1 |
|
CreateWordField (ATIB, Zero, SSZE) |
|
CreateDWordField (ATIB, 0x02, VMSK) |
|
CreateDWordField (ATIB, 0x06, FLGS) |
|
SSZE = 0x0A |
|
VMSK = 0x03 |
|
SSZE = 0x0A |
|
FLGS = One |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Name (PSBR, Buffer (0x04) |
|
{ |
|
0x00, 0x00, 0x00, 0x00 // .... |
|
}) |
|
Name (MSKN, Zero) |
|
Name (SEXM, Zero) |
|
Name (STHG, Zero) |
|
Name (STHI, Zero) |
|
Name (SFPG, Zero) |
|
Name (SFPI, Zero) |
|
Name (SSPS, Zero) |
|
Name (SSDM, 0x0A) |
|
Name (SCDY, Zero) |
|
Name (SACT, Buffer (0x07) |
|
{ |
|
0x01, 0x02, 0x08, 0x80, 0x03, 0x09, 0x81 // ....... |
|
}) |
|
Method (AF02, 0, NotSerialized) |
|
{ |
|
P80H = 0xF2 |
|
CreateBitField (PSBR, Zero, PDSW) |
|
CreateBitField (PSBR, One, PEXM) |
|
CreateBitField (PSBR, 0x02, PTHR) |
|
CreateBitField (PSBR, 0x03, PFPS) |
|
CreateBitField (PSBR, 0x04, PSPS) |
|
CreateBitField (PSBR, 0x05, PDCC) |
|
CreateBitField (PSBR, 0x06, PXPS) |
|
CreateBitField (PSBR, 0x07, PBRT) |
|
CreateWordField (ATIB, Zero, SSZE) |
|
CreateDWordField (ATIB, 0x02, PSBI) |
|
CreateByteField (ATIB, 0x06, EXPM) |
|
CreateByteField (ATIB, 0x07, THRM) |
|
CreateByteField (ATIB, 0x08, THID) |
|
CreateByteField (ATIB, 0x09, FPWR) |
|
CreateByteField (ATIB, 0x0A, FPID) |
|
CreateByteField (ATIB, 0x0B, SPWR) |
|
CreateByteField (ATIB, 0x0C, BRTL) |
|
SSZE = 0x0D |
|
PSBI = PSBR /* \_SB_.PCI0.VGA_.PSBR */ |
|
If (PDSW) |
|
{ |
|
P80H = 0x82 |
|
PDSW = Zero |
|
} |
|
|
|
If (PEXM) |
|
{ |
|
EXPM = SEXM /* \_SB_.PCI0.VGA_.SEXM */ |
|
SEXM = Zero |
|
PEXM = Zero |
|
} |
|
|
|
If (PTHR) |
|
{ |
|
THRM = STHG /* \_SB_.PCI0.VGA_.STHG */ |
|
THID = STHI /* \_SB_.PCI0.VGA_.STHI */ |
|
STHG = Zero |
|
STHI = Zero |
|
PTHR = Zero |
|
} |
|
|
|
If (PFPS) |
|
{ |
|
FPWR = SFPG /* \_SB_.PCI0.VGA_.SFPG */ |
|
FPWR = SFPI /* \_SB_.PCI0.VGA_.SFPI */ |
|
SFPG = Zero |
|
SFPI = Zero |
|
PFPS = Zero |
|
} |
|
|
|
If (PSPS) |
|
{ |
|
SPWR = SSPS /* \_SB_.PCI0.VGA_.SSPS */ |
|
PSPS = Zero |
|
} |
|
|
|
If (PXPS) |
|
{ |
|
P80H = 0xA2 |
|
PXPS = Zero |
|
} |
|
|
|
If (PBRT) |
|
{ |
|
P80H = 0xF7 |
|
PBRT = Zero |
|
} |
|
|
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Method (AF03, 2, NotSerialized) |
|
{ |
|
P80H = 0xF3 |
|
CreateWordField (ATIB, Zero, SSZE) |
|
CreateWordField (ATIB, 0x02, SSDP) |
|
CreateWordField (ATIB, 0x04, SCDP) |
|
SSDP = Arg0 |
|
SCDP = Arg1 |
|
If (GADD) |
|
{ |
|
GADD = Zero |
|
\WMI0.ACTD = SSDP /* \_SB_.PCI0.VGA_.AF03.SSDP */ |
|
\WMI0.AVLD = SCDP /* \_SB_.PCI0.VGA_.AF03.SCDP */ |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Name (NXTD, 0x06) |
|
Name (CIDX, 0x06) |
|
Local1 = SSDP /* \_SB_.PCI0.VGA_.AF03.SSDP */ |
|
Local1 &= 0x8B |
|
Local2 = SCDP /* \_SB_.PCI0.VGA_.AF03.SCDP */ |
|
If (CondRefOf (^^^LID._LID, Local4)) |
|
{ |
|
Local2 &= 0xFFFFFFFFFFFFFFFE |
|
Local2 |= One |
|
} |
|
Else |
|
{ |
|
Local2 |= One |
|
} |
|
|
|
P80H = Local2 |
|
Local0 = Zero |
|
While ((Local0 < SizeOf (SACT))) |
|
{ |
|
Local3 = DerefOf (SACT [Local0]) |
|
If ((Local3 == Local1)) |
|
{ |
|
CIDX = Local0 |
|
Local0 = SizeOf (SACT) |
|
} |
|
Else |
|
{ |
|
Local0++ |
|
} |
|
} |
|
|
|
Local0 = CIDX /* \_SB_.PCI0.VGA_.AF03.CIDX */ |
|
While ((Local0 < SizeOf (SACT))) |
|
{ |
|
Local0++ |
|
If ((Local0 == SizeOf (SACT))) |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Local3 = DerefOf (SACT [Local0]) |
|
If (((Local3 & Local2) == Local3)) |
|
{ |
|
NXTD = Local0 |
|
Local0 = SizeOf (SACT) |
|
} |
|
} |
|
|
|
If ((NXTD == SizeOf (SACT))) |
|
{ |
|
SSDP = Zero |
|
} |
|
Else |
|
{ |
|
Local0 = NXTD /* \_SB_.PCI0.VGA_.AF03.NXTD */ |
|
Local3 = DerefOf (SACT [Local0]) |
|
SSDP &= 0xFFFFFFFFFFFFFFF4 |
|
SSDP |= Local3 |
|
} |
|
|
|
SSZE = 0x04 |
|
P80H = SSDP /* \_SB_.PCI0.VGA_.AF03.SSDP */ |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Method (AFN0, 0, Serialized) |
|
{ |
|
If ((MSKN & One)) |
|
{ |
|
CreateBitField (PSBR, Zero, PDSW) |
|
PDSW = One |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
|
|
Method (AFN3, 2, Serialized) |
|
{ |
|
If ((MSKN & 0x08)) |
|
{ |
|
Local0 = Arg0 |
|
SFPI = Local0 |
|
Local0 = Arg1 |
|
SFPG = Local0 &= 0x03 |
|
CreateBitField (PSBR, 0x03, PFPS) |
|
PFPS = One |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
|
|
Method (AFN4, 1, Serialized) |
|
{ |
|
If ((MSKN & 0x10)) |
|
{ |
|
Local0 = Arg0 |
|
Local1 = SSPS /* \_SB_.PCI0.VGA_.SSPS */ |
|
SSPS = Local0 |
|
If ((Local0 == Local1)){} |
|
Else |
|
{ |
|
CreateBitField (PSBR, 0x04, PSPS) |
|
PSPS = One |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
} |
|
|
|
Method (AFN5, 0, Serialized) |
|
{ |
|
If ((MSKN & 0x20)) |
|
{ |
|
CreateBitField (PSBR, 0x05, PDCC) |
|
PDCC = One |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
|
|
Method (AFN6, 0, Serialized) |
|
{ |
|
If ((MSKN & 0x40)) |
|
{ |
|
CreateBitField (PSBR, 0x06, PXPS) |
|
PXPS = One |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
|
|
Method (AFN7, 1, Serialized) |
|
{ |
|
If ((MSKN & 0x80)) |
|
{ |
|
CreateBitField (PSBR, 0x07, PBRT) |
|
PBRT = One |
|
CreateByteField (ATIB, 0x0C, BRTL) |
|
BRTL = Arg0 |
|
Notify (VGA, NCOD) |
|
} |
|
} |
|
|
|
Method (AF15, 0, NotSerialized) |
|
{ |
|
P80H = 0xFF |
|
CreateWordField (ATIB, Zero, DNUM) |
|
CreateWordField (ATIB, 0x02, DSZE) |
|
DSZE = 0x08 |
|
Acquire (PXPX, 0xFFFF) |
|
BCMD = 0x8D |
|
DID = 0x0F |
|
INFO = ATIB /* \_SB_.PCI0.VGA_.ATIB */ |
|
^^SBRG.SMIC = ATIS /* \ATIS */ |
|
ATIB = INFO /* \INFO */ |
|
Release (PXPX) |
|
Return (ATIB) /* \_SB_.PCI0.VGA_.ATIB */ |
|
} |
|
|
|
Name (AT00, Buffer (0xFF){}) |
|
Name (AT01, Buffer (0x03){}) |
|
Method (ATCS, 2, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
ATC0 () |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
ATC1 () |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
ATC2 (Arg1) |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
ATC3 () |
|
} |
|
|
|
If ((Arg0 == 0x04)) |
|
{ |
|
ATC4 (Arg1) |
|
} |
|
|
|
Return (AT00) /* \_SB_.PCI0.VGA_.AT00 */ |
|
} |
|
|
|
Method (ATC0, 0, NotSerialized) |
|
{ |
|
CreateWordField (AT00, Zero, SZZE) |
|
CreateWordField (AT00, 0x02, INTF) |
|
CreateDWordField (AT00, 0x04, SUPP) |
|
SZZE = 0x08 |
|
INTF = One |
|
SUPP = 0x0F |
|
} |
|
|
|
Method (ATC1, 0, Serialized) |
|
{ |
|
CreateWordField (AT00, Zero, SZZE) |
|
CreateDWordField (AT00, 0x02, VFMK) |
|
CreateDWordField (AT00, 0x06, FLAG) |
|
CreateField (AT00, 0x30, One, DOCK) |
|
SZZE = 0x0A |
|
VFMK = One |
|
FLAG = Zero |
|
DOCK = One |
|
} |
|
|
|
Method (ATC2, 1, Serialized) |
|
{ |
|
CreateField (Arg0, 0x10, 0x03, FUCC) |
|
CreateField (Arg0, 0x13, 0x06, DEVV) |
|
CreateByteField (Arg0, 0x03, BUSS) |
|
CreateDWordField (Arg0, 0x04, VFMK) |
|
CreateDWordField (Arg0, 0x06, FLAG) |
|
CreateField (Arg0, 0x30, One, ADVC) |
|
CreateField (Arg0, 0x31, One, WFCM) |
|
CreateByteField (Arg0, 0x08, RQST) |
|
CreateByteField (Arg0, 0x09, PFRQ) |
|
CreateWordField (AT00, Zero, SZZE) |
|
CreateByteField (AT00, 0x02, RETV) |
|
SZZE = 0x03 |
|
RETV = One |
|
0x02 = ALIB /* External reference */ |
|
Arg0 |
|
AT00 |
|
} |
|
|
|
Method (ATC3, 0, Serialized) |
|
{ |
|
CreateWordField (AT00, Zero, SZZE) |
|
CreateByteField (AT00, 0x02, RETV) |
|
CreateWordField (AT01, Zero, SZZB) |
|
CreateByteField (AT01, 0x02, PSPP) |
|
SZZE = 0x03 |
|
RETV = One |
|
SZZB = 0x03 |
|
PSPP = One |
|
0x03 = ALIB /* External reference */ |
|
AT01 |
|
AT00 |
|
} |
|
|
|
Method (ATC4, 1, Serialized) |
|
{ |
|
CreateField (Arg0, 0x10, 0x03, FUCC) |
|
CreateField (Arg0, 0x13, 0x06, DEVV) |
|
CreateByteField (Arg0, 0x03, BUSS) |
|
CreateByteField (Arg0, 0x04, NULN) |
|
CreateWordField (AT00, Zero, SZZE) |
|
CreateByteField (AT00, 0x02, NULM) |
|
SZZE = 0x03 |
|
NULM = One |
|
0x04 = ALIB /* External reference */ |
|
Arg0 |
|
AT00 |
|
} |
|
} |
|
|
|
Name (ATPB, Buffer (0x0100){}) |
|
Name (DSID, 0xFFFFFFFF) |
|
Name (HSID, 0xFFFFFFFF) |
|
Name (CNT0, Buffer (0x05) |
|
{ |
|
0x05, 0x00, 0x00, 0x10, 0x01 // ..... |
|
}) |
|
Name (CNT1, Buffer (0x05) |
|
{ |
|
0x05, 0x01, 0x00, 0x00, 0x01 // ..... |
|
}) |
|
Name (CNT2, Buffer (0x05) |
|
{ |
|
0x07, 0x03, 0x00, 0x10, 0x02 // ..... |
|
}) |
|
Name (CNT3, Buffer (0x05) |
|
{ |
|
0x07, 0x07, 0x00, 0x20, 0x02 // ... . |
|
}) |
|
Name (CNT4, Buffer (0x05) |
|
{ |
|
0x00, 0x09, 0x00, 0x30, 0x02 // ...0. |
|
}) |
|
Name (CNT5, Buffer (0x05) |
|
{ |
|
0x01, 0x00, 0x01, 0x10, 0x01 // ..... |
|
}) |
|
Name (CNT6, Buffer (0x05) |
|
{ |
|
0x01, 0x01, 0x01, 0x00, 0x01 // ..... |
|
}) |
|
Name (CNT7, Buffer (0x05) |
|
{ |
|
0x03, 0x03, 0x01, 0x10, 0x02 // ..... |
|
}) |
|
Name (CNT8, Buffer (0x05) |
|
{ |
|
0x03, 0x07, 0x01, 0x20, 0x02 // ... . |
|
}) |
|
Name (CNT9, Buffer (0x05) |
|
{ |
|
0x00, 0x09, 0x01, 0x30, 0x02 // ...0. |
|
}) |
|
OperationRegion (REVD, SystemMemory, 0x7E3A411D, 0x00008204) |
|
Field (REVD, AnyAcc, NoLock, Preserve) |
|
{ |
|
SROM, 32, |
|
VROM, 266240 |
|
} |
|
|
|
Name (TVGA, Buffer (0x8200) |
|
{ |
|
0x00 // . |
|
}) |
|
Method (ATRM, 2, Serialized) |
|
{ |
|
Local0 = (Arg0 + Arg1) |
|
If ((Local0 <= SROM)) |
|
{ |
|
Local1 = (Arg1 * 0x08) |
|
Local2 = (Arg0 * 0x08) |
|
TVGA = VROM /* \_SB_.PCI0.VGA_.VROM */ |
|
CreateField (TVGA, Local2, Local1, TEMP) |
|
Name (RETB, Buffer (Arg1){}) |
|
RETB = TEMP /* \_SB_.PCI0.VGA_.ATRM.TEMP */ |
|
Return (RETB) /* \_SB_.PCI0.VGA_.ATRM.RETB */ |
|
} |
|
ElseIf ((Arg0 < SROM)) |
|
{ |
|
Local3 = (SROM - Arg0) |
|
Local1 = (Local3 * 0x08) |
|
Local2 = (Arg0 * 0x08) |
|
TVGA = VROM /* \_SB_.PCI0.VGA_.VROM */ |
|
CreateField (TVGA, Local2, Local1, TEM) |
|
Name (RETC, Buffer (Local3){}) |
|
RETC = TEM /* \_SB_.PCI0.VGA_.ATRM.TEM_ */ |
|
Return (RETC) /* \_SB_.PCI0.VGA_.ATRM.RETC */ |
|
} |
|
Else |
|
{ |
|
Name (RETD, Buffer (One){}) |
|
Return (RETD) /* \_SB_.PCI0.VGA_.ATRM.RETD */ |
|
} |
|
} |
|
|
|
Method (ATPX, 2, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Return (PX00 ()) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
Return (PX01 ()) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
PX02 (DerefOf (Arg1 [0x02])) |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
PX03 (DerefOf (Arg1 [0x02])) |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
If ((Arg0 == 0x04)) |
|
{ |
|
PX04 (DerefOf (Arg1 [0x02])) |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
If ((Arg0 == 0x08)) |
|
{ |
|
Return (PX08 ()) |
|
} |
|
|
|
If ((Arg0 == 0x09)) |
|
{ |
|
Return (PX09 ()) |
|
} |
|
|
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateWordField (ATPB, 0x02, VERN) |
|
CreateDWordField (ATPB, 0x04, SFUN) |
|
SSZE = Zero |
|
VERN = Zero |
|
SFUN = Zero |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
Method (PX00, 0, NotSerialized) |
|
{ |
|
P80H = 0xE0 |
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateWordField (ATPB, 0x02, VERN) |
|
CreateDWordField (ATPB, 0x04, SFUN) |
|
SSZE = 0x08 |
|
VERN = One |
|
If ((PXEN == 0x80000000)) |
|
{ |
|
SFUN = Zero |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
If ((PXMX == 0x80000000)) |
|
{ |
|
SFUN = 0x018F |
|
} |
|
Else |
|
{ |
|
SFUN = 0x03 |
|
} |
|
|
|
Local0 = ^^PCED.VGA.SVID /* \_SB_.PCI0.PCED.VGA_.SVID */ |
|
Local1 = ^^PCED.HDAU.SVID /* \_SB_.PCI0.PCED.HDAU.SVID */ |
|
If ((Local0 != 0xFFFFFFFF)) |
|
{ |
|
DSID = Local0 |
|
} |
|
|
|
If ((Local1 != 0xFFFFFFFF)) |
|
{ |
|
HSID = Local1 |
|
} |
|
|
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
Method (PX01, 0, NotSerialized) |
|
{ |
|
P80H = 0xE1 |
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateDWordField (ATPB, 0x02, VMSK) |
|
CreateDWordField (ATPB, 0x06, FLGS) |
|
SSZE = 0x0A |
|
VMSK = 0x07FF |
|
If ((PXMX == 0x80000000)) |
|
{ |
|
FLGS = 0x4B |
|
} |
|
Else |
|
{ |
|
FLGS = Zero |
|
If ((PXDY == 0x80000001)) |
|
{ |
|
FLGS |= 0x0680 |
|
} |
|
|
|
If ((PXDY == 0x80000002)) |
|
{ |
|
FLGS |= 0x0280 |
|
} |
|
} |
|
|
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
Method (PX02, 1, NotSerialized) |
|
{ |
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateByteField (ATPB, 0x02, PWST) |
|
SSZE = 0x03 |
|
Local7 = Buffer (0x05){} |
|
CreateWordField (Local7, Zero, SZZE) |
|
CreateField (Local7, 0x10, 0x03, FUCC) |
|
CreateField (Local7, 0x13, 0x05, DEVV) |
|
CreateByteField (Local7, 0x03, BUSS) |
|
CreateByteField (Local7, 0x04, HPST) |
|
SZZE = 0x05 |
|
BUSS = Zero |
|
FUCC = Zero |
|
Local6 = Buffer (0x04){} |
|
CreateByteField (Local6, 0x02, HPOX) |
|
PWST = (Arg0 & One) |
|
Name (HPOK, Zero) |
|
If (PWST) |
|
{ |
|
P80H = 0x11E2 |
|
^^PCED.PDC8 = Zero |
|
^^PCED.PDS8 = Zero |
|
^^PCED.HPC8 = Zero |
|
DPON () |
|
HPOK = Zero |
|
Sleep (0x64) |
|
Sleep (0x64) |
|
DEVV = 0x02 |
|
HPST = One |
|
0x06 = ALIB /* External reference */ |
|
Local7 |
|
Local6 |
|
Sleep (0x14) |
|
Local2 = Zero |
|
While ((Local2 < 0x0F)) |
|
{ |
|
^^PCED.PDC2 = One |
|
Local4 = One |
|
Local5 = 0xC8 |
|
While ((Local4 && Local5)) |
|
{ |
|
Local0 = ^^PCED.XPRD (0xA5) |
|
Local0 &= 0x7F |
|
If (((Local0 >= 0x10) && (Local0 != 0x7F))) |
|
{ |
|
Local4 = Zero |
|
} |
|
Else |
|
{ |
|
Sleep (0x05) |
|
Local5-- |
|
} |
|
} |
|
|
|
If (!Local4) |
|
{ |
|
Local5 = ^^PCED.XPDL () |
|
If (Local5) |
|
{ |
|
^^PCED.XPRT () |
|
Sleep (0x05) |
|
Local2++ |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
If ((^^PCED.XPR2 () == Ones)) |
|
{ |
|
Local0 = One |
|
} |
|
|
|
If (Local0) |
|
{ |
|
HPOK = One |
|
Local2 = 0x10 |
|
} |
|
Else |
|
{ |
|
HPOK = Zero |
|
Local2 = 0x10 |
|
} |
|
} |
|
} |
|
Else |
|
{ |
|
Local2 = 0x10 |
|
} |
|
} |
|
|
|
If (!HPOK) |
|
{ |
|
P80H = 0x13E2 |
|
Local1 = ^^PCED.VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x0A) |
|
Local4 = One |
|
Local5 = 0x05 |
|
While ((Local4 && Local5)) |
|
{ |
|
Local0 = ^^PCED.XPRD (0xA5) |
|
Local0 &= 0x7F |
|
If ((Local0 <= 0x04)) |
|
{ |
|
Local4 = Zero |
|
} |
|
Else |
|
{ |
|
Local1 = ^^PCED.VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x05) |
|
Local5-- |
|
} |
|
} |
|
|
|
DEVV = 0x02 |
|
HPST = Zero |
|
ALIB |
|
0x06 |
|
Local7 |
|
} |
|
|
|
P80H = 0x14E2 |
|
} |
|
Else |
|
{ |
|
P80H = 0x02E2 |
|
DPOF () |
|
^^PCED.PDC2 = One |
|
Local1 = ^^PCED.VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x0A) |
|
Local4 = One |
|
Local5 = 0x05 |
|
While ((Local4 && Local5)) |
|
{ |
|
Local0 = ^^PCED.XPRD (0xA5) |
|
Local0 &= 0x7F |
|
If ((Local0 <= 0x04)) |
|
{ |
|
Local4 = Zero |
|
} |
|
Else |
|
{ |
|
Local1 = ^^PCED.VGA.DVID /* \_SB_.PCI0.PCED.VGA_.DVID */ |
|
Sleep (0x05) |
|
Local5-- |
|
} |
|
} |
|
|
|
DEVV = 0x02 |
|
HPST = Zero |
|
ALIB |
|
0x06 |
|
Local7 |
|
HPOK = 0x02 |
|
P80H = 0x04E2 |
|
} |
|
|
|
If (HPOK) |
|
{ |
|
If (((HPOK == One) && (DSID != 0xFFFFFFFF))) |
|
{ |
|
Local1 = DSID /* \_SB_.PCI0.VGA_.DSID */ |
|
^^PCED.VGA.SMID = Local1 |
|
Sleep (0x0A) |
|
Local1 = HSID /* \_SB_.PCI0.VGA_.HSID */ |
|
If ((Local1 != 0xFFFFFFFF)) |
|
{ |
|
^^PCED.HDAU.SMID = Local1 |
|
} |
|
|
|
Sleep (0x0A) |
|
} |
|
} |
|
} |
|
|
|
Method (PX03, 1, NotSerialized) |
|
{ |
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateWordField (ATPB, 0x02, DPSW) |
|
SSZE = 0x04 |
|
DPSW = (Arg0 & One) |
|
} |
|
|
|
Method (PX04, 1, NotSerialized) |
|
{ |
|
P80H = 0xE4 |
|
CreateWordField (ATPB, Zero, SSZE) |
|
CreateWordField (ATPB, 0x02, ICSW) |
|
SSZE = 0x04 |
|
ICSW = (Arg0 & One) |
|
} |
|
|
|
Method (PX08, 0, NotSerialized) |
|
{ |
|
P80H = 0xE8 |
|
CreateWordField (ATPB, Zero, CNUM) |
|
CreateWordField (ATPB, 0x02, CSSZ) |
|
CNUM = 0x0A |
|
CSSZ = 0x05 |
|
CreateField (ATPB, 0x20, 0x28, CTI0) |
|
CTI0 = CNT0 /* \_SB_.PCI0.VGA_.CNT0 */ |
|
CreateField (ATPB, 0x48, 0x28, CTI1) |
|
CTI1 = CNT1 /* \_SB_.PCI0.VGA_.CNT1 */ |
|
CreateField (ATPB, 0x70, 0x28, CTI2) |
|
CreateByteField (CNT2, Zero, FLG2) |
|
If ((LCDT == 0x80000001)) |
|
{ |
|
If ((DSCT == 0x80000001)) |
|
{ |
|
FLG2 = Zero |
|
} |
|
|
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG2 = 0x07 |
|
} |
|
} |
|
|
|
CTI2 = CNT2 /* \_SB_.PCI0.VGA_.CNT2 */ |
|
CreateField (ATPB, 0x98, 0x28, CTI3) |
|
CreateByteField (CNT3, Zero, FLG3) |
|
If ((LCDT == 0x80000000)) |
|
{ |
|
FLG3 = 0x07 |
|
} |
|
|
|
If ((LCDT == 0x80000001)) |
|
{ |
|
FLG3 = Zero |
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG3 = Zero |
|
} |
|
} |
|
|
|
If ((LCDT == 0x80000002)) |
|
{ |
|
FLG3 = Zero |
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG3 = 0x07 |
|
} |
|
} |
|
|
|
CTI3 = CNT3 /* \_SB_.PCI0.VGA_.CNT3 */ |
|
CreateField (ATPB, 0xC0, 0x28, CTI4) |
|
CTI4 = CNT4 /* \_SB_.PCI0.VGA_.CNT4 */ |
|
CreateField (ATPB, 0xE8, 0x28, CTI5) |
|
CTI5 = CNT5 /* \_SB_.PCI0.VGA_.CNT5 */ |
|
CreateField (ATPB, 0x0110, 0x28, CTI6) |
|
CTI6 = CNT6 /* \_SB_.PCI0.VGA_.CNT6 */ |
|
CreateField (ATPB, 0x0138, 0x28, CTI7) |
|
CreateByteField (CNT7, Zero, FLG7) |
|
If ((LCDT == 0x80000001)) |
|
{ |
|
If ((DSCT == 0x80000001)) |
|
{ |
|
FLG7 = Zero |
|
} |
|
|
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG7 = Zero |
|
} |
|
} |
|
|
|
CTI7 = CNT7 /* \_SB_.PCI0.VGA_.CNT7 */ |
|
CreateField (ATPB, 0x0160, 0x28, CTI8) |
|
CreateByteField (CNT8, Zero, FLG8) |
|
If ((LCDT == 0x80000000)) |
|
{ |
|
FLG8 = 0x07 |
|
} |
|
|
|
If ((LCDT == 0x80000001)) |
|
{ |
|
FLG8 = Zero |
|
} |
|
|
|
If ((LCDT == 0x80000002)) |
|
{ |
|
FLG8 = Zero |
|
} |
|
|
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG8 = 0x07 |
|
} |
|
|
|
CTI8 = CNT8 /* \_SB_.PCI0.VGA_.CNT8 */ |
|
CreateField (ATPB, 0x0188, 0x28, CTI9) |
|
CreateByteField (CNT9, Zero, FLG9) |
|
If ((DSCT == 0x80000002)) |
|
{ |
|
FLG9 = 0x07 |
|
} |
|
|
|
CTI9 = CNT9 /* \_SB_.PCI0.VGA_.CNT9 */ |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
|
|
Method (PX09, 0, NotSerialized) |
|
{ |
|
P80H = 0xE9 |
|
CreateWordField (ATPB, Zero, CNUM) |
|
CreateWordField (ATPB, 0x02, CSSZ) |
|
CNUM = Zero |
|
CSSZ = Zero |
|
CreateByteField (ATPB, 0x04, ATI0) |
|
CreateByteField (ATPB, 0x05, HPD0) |
|
CreateByteField (ATPB, 0x06, DDC0) |
|
ATI0 = Zero |
|
HPD0 = Zero |
|
DDC0 = Zero |
|
CreateByteField (ATPB, 0x07, ATI1) |
|
CreateByteField (ATPB, 0x08, HPD1) |
|
CreateByteField (ATPB, 0x09, DDC1) |
|
ATI1 = Zero |
|
HPD1 = Zero |
|
DDC1 = Zero |
|
Return (ATPB) /* \_SB_.PCI0.VGA_.ATPB */ |
|
} |
|
} |
|
|
|
Method (DPON, 0, NotSerialized) |
|
{ |
|
DGSW (One) |
|
} |
|
|
|
Method (DPOF, 0, NotSerialized) |
|
{ |
|
DGSW (Zero) |
|
} |
|
|
|
Scope (_PR) |
|
{ |
|
OperationRegion (SSDT, SystemMemory, 0xFFFF0000, 0xFFFF) |
|
Name (DCOR, 0x02) |
|
Name (TBLD, 0x04) |
|
Name (NPSS, 0x05) |
|
Name (HNDL, 0x80000000) |
|
Name (APSS, Package (0x0A) |
|
{ |
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
}, |
|
|
|
Package (0x06) |
|
{ |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF, |
|
0xFFFF |
|
} |
|
}) |
|
Processor (P000, 0x01, 0x00000810, 0x06) |
|
{ |
|
Name (TYPE, 0x80000000) |
|
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
|
{ |
|
CreateDWordField (Arg0, 0x08, DAT0) |
|
TYPE = DAT0 /* \_PR_.P000._PDC.DAT0 */ |
|
If (((TBLD == Zero) && (NPSS != Zero))) |
|
{ |
|
If ((((TYPE & 0x1B) == 0x1B) || (DCOR == Zero))) |
|
{ |
|
TBLD = One |
|
Load (SSDT, HNDL) /* \_PR_.HNDL */ |
|
} |
|
} |
|
} |
|
} |
|
|
|
Processor (P001, 0x02, 0x00000810, 0x06) |
|
{ |
|
Name (TYPE, 0x80000000) |
|
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
|
{ |
|
CreateDWordField (Arg0, 0x08, DAT0) |
|
TYPE = DAT0 /* \_PR_.P001._PDC.DAT0 */ |
|
If (((TBLD == Zero) && (NPSS != Zero))) |
|
{ |
|
If ((((TYPE & 0x1B) == 0x1B) || (DCOR == Zero))) |
|
{ |
|
TBLD = One |
|
Load (SSDT, HNDL) /* \_PR_.HNDL */ |
|
} |
|
} |
|
} |
|
} |
|
|
|
Processor (P002, 0x03, 0x00000810, 0x06) |
|
{ |
|
Name (TYPE, 0x80000000) |
|
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
|
{ |
|
CreateDWordField (Arg0, 0x08, DAT0) |
|
TYPE = DAT0 /* \_PR_.P002._PDC.DAT0 */ |
|
If (((TBLD == Zero) && (NPSS != Zero))) |
|
{ |
|
If ((((TYPE & 0x1B) == 0x1B) || (DCOR == Zero))) |
|
{ |
|
TBLD = One |
|
Load (SSDT, HNDL) /* \_PR_.HNDL */ |
|
} |
|
} |
|
} |
|
} |
|
|
|
Processor (P003, 0x04, 0x00000810, 0x06) |
|
{ |
|
Name (TYPE, 0x80000000) |
|
Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
|
{ |
|
CreateDWordField (Arg0, 0x08, DAT0) |
|
TYPE = DAT0 /* \_PR_.P003._PDC.DAT0 */ |
|
If (((TBLD == Zero) && (NPSS != Zero))) |
|
{ |
|
If ((((TYPE & 0x1B) == 0x1B) || (DCOR == Zero))) |
|
{ |
|
TBLD = One |
|
Load (SSDT, HNDL) /* \_PR_.HNDL */ |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
Method (CHKH, 0, NotSerialized) |
|
{ |
|
E06C = ~GE06 |
|
E1DC = ~GE16 |
|
GABO = ~GE16 |
|
} |
|
|
|
Name (WOTB, Zero) |
|
Name (WSSB, Zero) |
|
Name (WAXB, Zero) |
|
Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep |
|
{ |
|
DBG8 = Arg0 |
|
If (((Arg0 == 0x04) && (OSFL () == 0x02))) |
|
{ |
|
Sleep (0x0BB8) |
|
} |
|
|
|
PTS (Arg0) |
|
WAKP [Zero] = Zero |
|
WAKP [One] = Zero |
|
WSSB = ASSB /* \ASSB */ |
|
WOTB = AOTB /* \AOTB */ |
|
WAXB = AAXB /* \AAXB */ |
|
ASSB = Arg0 |
|
AOTB = OSFL () |
|
AAXB = Zero |
|
} |
|
|
|
Method (_WAK, 1, NotSerialized) // _WAK: Wake |
|
{ |
|
DBG8 = (Arg0 << 0x04) |
|
WAK (Arg0) |
|
If (ASSB) |
|
{ |
|
ASSB = WSSB /* \WSSB */ |
|
AOTB = WOTB /* \WOTB */ |
|
AAXB = WAXB /* \WAXB */ |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
CHKH () |
|
} |
|
|
|
If (DerefOf (WAKP [Zero])) |
|
{ |
|
WAKP [One] = Zero |
|
} |
|
Else |
|
{ |
|
WAKP [One] = Arg0 |
|
} |
|
|
|
Return (WAKP) /* \WAKP */ |
|
} |
|
|
|
Device (OMSC) |
|
{ |
|
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
|
Name (_UID, 0x0E11) // _UID: Unique ID |
|
} |
|
|
|
Device (_SB.RMEM) |
|
{ |
|
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID |
|
Name (_UID, One) // _UID: Unique ID |
|
} |
|
|
|
Scope (_SB.PCI0.VGA) |
|
{ |
|
OperationRegion (PCFG, PCI_Config, Zero, 0x50) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
DVID, 32, |
|
Offset (0x2C), |
|
SVID, 32, |
|
Offset (0x4C), |
|
SMID, 32 |
|
} |
|
|
|
OperationRegion (PCIG, PCI_Config, Zero, 0x50) |
|
Field (PCIG, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x18), |
|
GBA2, 32 |
|
} |
|
|
|
OperationRegion (GFMM, SystemMemory, GBA2, 0x6000) |
|
Field (GFMM, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x5F68), |
|
AZPS, 32 |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Mutex (PXPX, 0x00) |
|
} |
|
|
|
Name (DOSP, Zero) |
|
Name (BLVL, Buffer (0x10) |
|
{ |
|
/* 0000 */ 0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x70, // . 0@PX`p |
|
/* 0008 */ 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xFF // ........ |
|
}) |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Name (XCPD, Zero) |
|
Name (XNPT, One) |
|
Name (XCAP, 0x02) |
|
Name (XDCP, 0x04) |
|
Name (XDCT, 0x08) |
|
Name (XDST, 0x0A) |
|
Name (XLCP, 0x0C) |
|
Name (XLCT, 0x10) |
|
Name (XLST, 0x12) |
|
Name (XSCP, 0x14) |
|
Name (XSCT, 0x18) |
|
Name (XSST, 0x1A) |
|
Name (XRCT, 0x1C) |
|
Mutex (MUTE, 0x00) |
|
Method (RBPE, 1, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, One) |
|
Field (PCFG, ByteAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 8 |
|
} |
|
|
|
Release (MUTE) |
|
Return (XCFG) /* \_SB_.RBPE.XCFG */ |
|
} |
|
|
|
Method (RWPE, 1, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Arg0 &= 0xFFFFFFFE |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, 0x02) |
|
Field (PCFG, WordAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 16 |
|
} |
|
|
|
Release (MUTE) |
|
Return (XCFG) /* \_SB_.RWPE.XCFG */ |
|
} |
|
|
|
Method (RDPE, 1, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Arg0 &= 0xFFFFFFFC |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 32 |
|
} |
|
|
|
Release (MUTE) |
|
Return (XCFG) /* \_SB_.RDPE.XCFG */ |
|
} |
|
|
|
Method (WBPE, 2, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x0FFF) |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, One) |
|
Field (PCFG, ByteAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 8 |
|
} |
|
|
|
XCFG = Arg1 |
|
Release (MUTE) |
|
} |
|
|
|
Method (WWPE, 2, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Arg0 &= 0xFFFFFFFE |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, 0x02) |
|
Field (PCFG, WordAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 16 |
|
} |
|
|
|
XCFG = Arg1 |
|
Release (MUTE) |
|
} |
|
|
|
Method (WDPE, 2, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Arg0 &= 0xFFFFFFFC |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 32 |
|
} |
|
|
|
XCFG = Arg1 |
|
Release (MUTE) |
|
} |
|
|
|
Method (RWDP, 3, NotSerialized) |
|
{ |
|
Acquire (MUTE, 0x03E8) |
|
Arg0 &= 0xFFFFFFFC |
|
Local0 = (Arg0 + PEBS) /* \PEBS */ |
|
OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
|
Field (PCFG, DWordAcc, NoLock, Preserve) |
|
{ |
|
XCFG, 32 |
|
} |
|
|
|
Local1 = (XCFG & Arg2) |
|
XCFG = (Local1 | Arg1) |
|
Release (MUTE) |
|
} |
|
|
|
Method (RPME, 1, NotSerialized) |
|
{ |
|
Local0 = (Arg0 + 0x84) |
|
Local1 = RDPE (Local0) |
|
If ((Local1 == 0xFFFFFFFF)) |
|
{ |
|
Return (Zero) |
|
} |
|
Else |
|
{ |
|
If ((Local1 && 0x00010000)) |
|
{ |
|
WDPE (Local0, (Local1 & 0x00010000)) |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Device (WMI0) |
|
{ |
|
Name (_HID, "PNP0C14" /* Windows Management Instrumentation Device */) // _HID: Hardware ID |
|
Name (_UID, Zero) // _UID: Unique ID |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Method (DIAG, 1, NotSerialized) |
|
{ |
|
P8XH (Zero, Arg0) |
|
SBYT (Zero, Arg0) |
|
} |
|
|
|
OperationRegion (GPSC, SystemIO, 0xB2, 0x02) |
|
Field (GPSC, ByteAcc, NoLock, Preserve) |
|
{ |
|
SMCM, 8, |
|
SMST, 8 |
|
} |
|
|
|
Method (ISMI, 1, Serialized) |
|
{ |
|
SMCM = Arg0 |
|
} |
|
|
|
Method (ASMI, 1, Serialized) |
|
{ |
|
\WMI0.ALPR = Arg0 |
|
SMCM = 0xA3 |
|
Return (\WMI0.ALPR) |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
OperationRegion (\ECMS, SystemIO, 0x72, 0x02) |
|
Field (ECMS, ByteAcc, Lock, Preserve) |
|
{ |
|
EIND, 8, |
|
EDAT, 8 |
|
} |
|
|
|
IndexField (EIND, EDAT, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0xA0), |
|
IKFG, 8, |
|
IKF2, 8, |
|
FRPN, 16, |
|
RAMB, 32, |
|
AVOL, 8, |
|
LBTN, 8, |
|
LBT2, 8, |
|
ERRF, 8, |
|
OCLK, 8, |
|
WIDE, 1, |
|
OVCK, 2, |
|
SLPN, 3, |
|
ACRD, 1, |
|
VGAS, 1, |
|
CPUR, 6, |
|
CPUF, 2, |
|
CLKS, 8, |
|
CLKL, 8, |
|
ALSL, 8, |
|
ALAE, 1, |
|
ALDE, 1, |
|
ALSP, 1, |
|
SYNA, 1, |
|
ALPS, 1, |
|
SIDE, 1, |
|
PWBS, 1, |
|
WFFG, 1, |
|
WLDP, 1, |
|
WRST, 1, |
|
BTDP, 1, |
|
BRST, 1, |
|
WWDP, 1, |
|
WWST, 1, |
|
WRPS, 1, |
|
BRPS, 1, |
|
WMDP, 1, |
|
WMST, 1, |
|
Offset (0xB5), |
|
UHDB, 8, |
|
OSPM, 8, |
|
SP80, 1, |
|
B1OF, 1, |
|
B1CS, 5, |
|
Offset (0xB8), |
|
FBDP, 8, |
|
SWD2, 1, |
|
F9KP, 1, |
|
LSDF, 1, |
|
MANF, 1, |
|
RRSF, 1, |
|
Offset (0xBA), |
|
USBD, 16, |
|
FDAY, 8, |
|
FMON, 8, |
|
FYER, 8, |
|
FPRC, 8, |
|
EDID, 8, |
|
NCPP, 8, |
|
HEM1, 32, |
|
HEM2, 32, |
|
DS3F, 1, |
|
Offset (0xCB), |
|
WFOK, 8, |
|
UWDP, 1, |
|
GPDP, 1, |
|
TGDP, 1, |
|
UWST, 1, |
|
GPST, 1, |
|
TGST, 1, |
|
Offset (0xCD) |
|
} |
|
|
|
OperationRegion (RAMW, SystemMemory, RAMB, 0x1000) |
|
Field (RAMW, AnyAcc, NoLock, Preserve) |
|
{ |
|
NRSN, 8, |
|
TRTY, 8, |
|
FSFN, 8, |
|
FSTA, 16, |
|
FADR, 32, |
|
FSIZ, 16, |
|
GNBF, 32, |
|
BIPA, 32, |
|
RTCW, 16, |
|
DBR1, 32, |
|
DBR2, 32, |
|
DBR3, 32, |
|
DBR4, 32, |
|
ACTD, 8, |
|
AVLD, 8, |
|
SETD, 8, |
|
PADL, 16, |
|
CADL, 16, |
|
CSTE, 16, |
|
NSTE, 16, |
|
SSTE, 16, |
|
SFUN, 8, |
|
VGAF, 16, |
|
LCDV, 32, |
|
LCDR, 8, |
|
VBIF, 16, |
|
GCDF, 16, |
|
AB00, 8, |
|
AB01, 8, |
|
AB02, 8, |
|
AB03, 8, |
|
AB04, 8, |
|
AB05, 8, |
|
AB06, 8, |
|
AB07, 8, |
|
AB08, 8, |
|
AB09, 8, |
|
AB0A, 8, |
|
AB0B, 8, |
|
AB0C, 8, |
|
AB0D, 8, |
|
AB0E, 8, |
|
AB0F, 8, |
|
AB10, 8, |
|
AB11, 8, |
|
AB12, 8, |
|
AB13, 8, |
|
AB14, 8, |
|
AB15, 8, |
|
AB16, 8, |
|
AB17, 8, |
|
AB18, 8, |
|
AB19, 8, |
|
AB1A, 8, |
|
AB1B, 8, |
|
AB1C, 8, |
|
AB1D, 8, |
|
AB1E, 8, |
|
AB1F, 8, |
|
DB00, 8, |
|
DB01, 8, |
|
DB02, 8, |
|
DB03, 8, |
|
DB04, 8, |
|
DB05, 8, |
|
DB06, 8, |
|
DB07, 8, |
|
DB08, 8, |
|
DB09, 8, |
|
DB0A, 8, |
|
DB0B, 8, |
|
DB0C, 8, |
|
DB0D, 8, |
|
DB0E, 8, |
|
DB0F, 8, |
|
DB10, 8, |
|
DB11, 8, |
|
DB12, 8, |
|
DB13, 8, |
|
DB14, 8, |
|
DB15, 8, |
|
DB16, 8, |
|
DB17, 8, |
|
DB18, 8, |
|
DB19, 8, |
|
DB1A, 8, |
|
DB1B, 8, |
|
DB1C, 8, |
|
DB1D, 8, |
|
DB1E, 8, |
|
DB1F, 8, |
|
ACPF, 8, |
|
DCPF, 8, |
|
DCP2, 8, |
|
DCTP, 8, |
|
TPSV, 8, |
|
TAC0, 8, |
|
TCRT, 8, |
|
PPSV, 8, |
|
LUXS, 8, |
|
LUXL, 8, |
|
LUXH, 8, |
|
LUXF, 8, |
|
PTIM, 8, |
|
PTMP, 8, |
|
QFAN, 8, |
|
CPUN, 8, |
|
CIST, 8, |
|
CPUP, 16, |
|
SLMT, 16, |
|
PSTN, 16, |
|
TJMX, 16, |
|
SLPT, 8, |
|
ALPR, 32, |
|
IDES, 8, |
|
HDDF, 8, |
|
MNAM, 64, |
|
OSVR, 32, |
|
SGRQ, 32, |
|
SGFN, 8, |
|
SGMD, 8, |
|
B0DP, 8, |
|
B1DP, 8, |
|
WMIB, 32, |
|
WMIS, 8, |
|
LDST, 8, |
|
TBOT, 16, |
|
TRTC, 32, |
|
EXPC, 64, |
|
MEMS, 8, |
|
BAML, 8, |
|
AMLA, 32, |
|
AICD, 32, |
|
AIST, 8 |
|
} |
|
} |
|
|
|
OperationRegion (DBGM, SystemMemory, 0x000D0000, 0x04) |
|
Field (DBGM, DWordAcc, NoLock, Preserve) |
|
{ |
|
DBGG, 32 |
|
} |
|
|
|
Name (OSFG, Zero) |
|
Name (OS9X, One) |
|
Name (OS98, 0x02) |
|
Name (OSME, 0x04) |
|
Name (OS2K, 0x08) |
|
Name (OSLX, 0x09) |
|
Name (OSXP, 0x10) |
|
Name (OSVT, 0x20) |
|
Name (OSW7, 0x40) |
|
Name (OSW8, 0x80) |
|
Method (MSOS, 0, NotSerialized) |
|
{ |
|
If (CondRefOf (_OSI, Local0)) |
|
{ |
|
If (_OSI ("Windows 2001")) |
|
{ |
|
OSFG = OSXP /* \OSXP */ |
|
} |
|
|
|
If (_OSI ("Windows 2001 SP1")) |
|
{ |
|
OSFG = OSXP /* \OSXP */ |
|
} |
|
|
|
If (_OSI ("Windows 2001 SP2")) |
|
{ |
|
OSFG = OSXP /* \OSXP */ |
|
} |
|
|
|
If (_OSI ("Windows 2006")) |
|
{ |
|
OSFG = OSVT /* \OSVT */ |
|
} |
|
|
|
If (_OSI ("Windows 2009")) |
|
{ |
|
OSFG = OSW7 /* \OSW7 */ |
|
} |
|
|
|
If (_OSI ("Windows 2012")) |
|
{ |
|
OSFG = OSW8 /* \OSW8 */ |
|
} |
|
|
|
\WMI0.OSVR = OSFG /* \OSFG */ |
|
Return (OSFG) /* \OSFG */ |
|
} |
|
ElseIf (MCTH (_OS, "Microsoft Windows")) |
|
{ |
|
OSFG = OS98 /* \OS98 */ |
|
} |
|
ElseIf (MCTH (_OS, "Microsoft WindowsME: Millennium Edition")) |
|
{ |
|
OSFG = OSME /* \OSME */ |
|
} |
|
ElseIf (MCTH (_OS, "Microsoft Windows NT")) |
|
{ |
|
OSFG = OS2K /* \OS2K */ |
|
} |
|
Else |
|
{ |
|
OSFG = OSXP /* \OSXP */ |
|
} |
|
|
|
Return (OSFG) /* \OSFG */ |
|
} |
|
|
|
Method (DBGR, 4, NotSerialized) |
|
{ |
|
\WMI0.DBR1 = Arg0 |
|
\WMI0.DBR2 = Arg1 |
|
\WMI0.DBR3 = Arg2 |
|
\WMI0.DBR4 = Arg3 |
|
ASMI (0x80) |
|
} |
|
|
|
Name (ONAM, "ASUS") |
|
Method (ADVG, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
Return (\_SB.PCI0.VGA.ADVD ()) |
|
} |
|
|
|
Return (0x03) |
|
} |
|
|
|
Method (SWHG, 1, Serialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
\_SB.PCI0.VGA.SWHD (Arg0) |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (NATK, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
Return (\_SB.PCI0.VGA.NATK ()) |
|
} |
|
|
|
Return (One) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Method (PINI, 0, NotSerialized) |
|
{ |
|
\WMI0.OSPM = MSOS () |
|
If ((\WMI0.OSPM == OSW8)) |
|
{ |
|
^SBRG.HEC.WRAM (0x0C0C, 0x80) |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Name (ATKP, Zero) |
|
Name (AITM, Zero) |
|
Name (PLMD, Zero) |
|
Name (MUTX, One) |
|
Name (LEDS, Zero) |
|
Name (LIDP, Zero) |
|
Device (ATKD) |
|
{ |
|
Name (_HID, "pnp0c14") // _HID: Hardware ID |
|
Name (_UID, "ATK") // _UID: Unique ID |
|
Name (ATKQ, Package (0x10) |
|
{ |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF |
|
}) |
|
Name (AQHI, Zero) |
|
Name (AQTI, 0x0F) |
|
Name (AQNO, Zero) |
|
Name (WAPF, Zero) |
|
Name (PCDV, Zero) |
|
Method (IANQ, 1, Serialized) |
|
{ |
|
If ((AQNO >= 0x10)) |
|
{ |
|
Local0 = 0x64 |
|
While ((Local0 && (AQNO >= 0x10))) |
|
{ |
|
Local0-- |
|
Sleep (0x0A) |
|
} |
|
|
|
If ((Local0 && (AQNO >= 0x10))) |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
AQTI++ |
|
AQTI &= 0x0F |
|
ATKQ [AQTI] = Arg0 |
|
AQNO++ |
|
Return (One) |
|
} |
|
|
|
Method (GANQ, 0, Serialized) |
|
{ |
|
If (AQNO) |
|
{ |
|
AQNO-- |
|
Local0 = DerefOf (ATKQ [AQHI]) |
|
AQHI++ |
|
AQHI &= 0x0F |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (IANE, 1, Serialized) |
|
{ |
|
IANQ (Arg0) |
|
Notify (ATKD, 0xFF) // Hardware-Specific |
|
} |
|
|
|
Name (_WDG, Buffer (0x28) |
|
{ |
|
/* 0000 */ 0xD0, 0x5E, 0x84, 0x97, 0x6D, 0x4E, 0xDE, 0x11, // .^..mN.. |
|
/* 0008 */ 0x8A, 0x39, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66, // .9.. ..f |
|
/* 0010 */ 0x4E, 0x42, 0x01, 0x02, 0x35, 0xBB, 0x3C, 0x0B, // NB..5.<. |
|
/* 0018 */ 0xC2, 0xE3, 0xED, 0x45, 0x91, 0xC2, 0x4C, 0x5A, // ...E..LZ |
|
/* 0020 */ 0x6D, 0x19, 0x5D, 0x1C, 0xFF, 0x00, 0x01, 0x08 // m.]..... |
|
}) |
|
Method (HKEY, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.CDTD /* \_SB_.PCI0.SBRG.HEC_.CDTD */ |
|
} |
|
|
|
Method (KBFT, 1, NotSerialized) |
|
{ |
|
^^PCI0.SBRG.HEC.HKEN = Arg0 |
|
If ((OSFG == OSW8)) |
|
{ |
|
^^PCI0.SBRG.HEC.WRAM (0x0C25, 0x80) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (NTFY, 1, Serialized) |
|
{ |
|
IANE (Arg0) |
|
} |
|
|
|
Method (AICH, 0, NotSerialized) |
|
{ |
|
Local0 = (\WMI0.AIST | 0x04) |
|
Return (Local0) |
|
} |
|
|
|
Method (AICG, 1, Serialized) |
|
{ |
|
\WMI0.AICD = Arg0 |
|
ISMI (0xE7) |
|
Return (Zero) |
|
} |
|
|
|
Method (WMNB, 3, NotSerialized) |
|
{ |
|
CreateDWordField (Arg2, Zero, IIA0) |
|
Local0 = (Arg1 & 0xFFFFFFFF) |
|
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler, x=0-9, A-Z |
|
_T_0 = Local0 |
|
If ((_T_0 == 0x54494E49)) |
|
{ |
|
INIT (IIA0) |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x53545342)) |
|
{ |
|
Return (BSTS ()) |
|
} |
|
ElseIf ((_T_0 == 0x4E554653)) |
|
{ |
|
Return (SFUN ()) |
|
} |
|
ElseIf ((_T_0 == 0x474F4457)) |
|
{ |
|
Return (WDOG (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x494E424B)) |
|
{ |
|
Return (KBNI ()) |
|
} |
|
ElseIf ((_T_0 == 0x43455053)) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (One) |
|
} |
|
} |
|
ElseIf ((_T_0 == 0x5256534F)) |
|
{ |
|
OSVR (IIA0) |
|
Return (Zero) |
|
} |
|
ElseIf ((_T_0 == 0x48534C46)) |
|
{ |
|
FLSH (IIA0) |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x494E4946)) |
|
{ |
|
Return (FINI (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x53524546)) |
|
{ |
|
Return (FERS (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x49525746)) |
|
{ |
|
Return (FWRI (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x50525746)) |
|
{ |
|
Return (FWRP ()) |
|
} |
|
ElseIf ((_T_0 == 0x52534345)) |
|
{ |
|
Return (ECSR (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x43534C46)) |
|
{ |
|
Return (FLSC (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x57504346)) |
|
{ |
|
Return (FCPW (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x50504346)) |
|
{ |
|
Return (FCPP ()) |
|
} |
|
ElseIf ((_T_0 == 0x4C425053)) |
|
{ |
|
Return (SPBL (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x50534453)) |
|
{ |
|
SDSP (IIA0) |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x50534447)) |
|
{ |
|
Return (GDSP (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x44495047)) |
|
{ |
|
Return (GPID ()) |
|
} |
|
ElseIf ((_T_0 == 0x44434C47)) |
|
{ |
|
Return (GLCD ()) |
|
} |
|
ElseIf ((_T_0 == 0x444F4D51)) |
|
{ |
|
Return (QMOD (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x44424653)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf ((_T_0 == 0x49564E41)) |
|
{ |
|
Return (ANVI (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x46494243)) |
|
{ |
|
Return (CBIF (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x5453424B)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf ((_T_0 == 0x4E554647)) |
|
{ |
|
Return (AGFN (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x4E464741)) |
|
{ |
|
Return (AGFN (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x53545344)) |
|
{ |
|
If ((IIA0 == 0x00010002)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((IIA0 == 0x00020011)) |
|
{ |
|
Return ((GALE (One) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00020012)) |
|
{ |
|
Return ((GALE (0x02) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00020013)) |
|
{ |
|
Return ((GALE (0x04) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00040015)) |
|
{ |
|
Return ((GALE (0x08) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00020014)) |
|
{ |
|
Return ((GALE (0x10) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00020015)) |
|
{ |
|
Return ((GALE (0x20) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00020016)) |
|
{ |
|
Return ((GALE (0x40) | 0x00050000)) |
|
} |
|
|
|
If ((IIA0 == 0x00110011)) |
|
{ |
|
Return ((TMPR () & 0xFFFF)) |
|
} |
|
|
|
If ((IIA0 == 0x00110012)) |
|
{ |
|
Local0 = TMPR () |
|
Local1 = Local0 |
|
Local0 = ((Local0 & 0xF0000000) >> 0x1C) |
|
Local1 = ((Local1 & 0x0F000000) >> 0x18) |
|
Local1 <<= 0x08 |
|
Return ((Local0 + Local1)) |
|
} |
|
|
|
If ((IIA0 == 0x00050012)) |
|
{ |
|
Local0 = 0x0A |
|
Local0 <<= 0x08 |
|
Local1 = (GPLV () + Local0) |
|
Return (Local1) |
|
} |
|
|
|
If ((IIA0 == 0x00010011)) |
|
{ |
|
If (\WMI0.WLDP) |
|
{ |
|
Return ((\WMI0.WRST + 0x00030000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010013)) |
|
{ |
|
If (\WMI0.BTDP) |
|
{ |
|
Return ((\WMI0.BRST + 0x00050000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010021)) |
|
{ |
|
If (\WMI0.UWDP) |
|
{ |
|
Return ((\WMI0.UWST + 0x00050000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010017)) |
|
{ |
|
If (\WMI0.WMDP) |
|
{ |
|
Return ((\WMI0.WMST + 0x00050000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010015)) |
|
{ |
|
If (\WMI0.GPDP) |
|
{ |
|
Return ((\WMI0.GPST + 0x00050000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010019)) |
|
{ |
|
If (\WMI0.TGDP) |
|
{ |
|
Return ((\WMI0.TGST + 0x00050000)) |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00120012)) |
|
{ |
|
Return (PSTC (Zero)) |
|
} |
|
|
|
If ((IIA0 == 0x00120031)) |
|
{ |
|
Return (GDS3 (Arg0)) |
|
} |
|
|
|
If ((IIA0 == 0x00120032)){} |
|
If ((IIA0 == 0x00130001)){} |
|
If ((IIA0 == 0x00050021)) |
|
{ |
|
If (GLKB (One)) |
|
{ |
|
Local0 = GLKB (0x03) |
|
Local0 <<= 0x08 |
|
Local0 += GLKB (0x02) |
|
Local0 |= 0x00050000 |
|
Return (Local0) |
|
} |
|
|
|
Return (0x8000) |
|
} |
|
|
|
If ((IIA0 == 0x00060023)) |
|
{ |
|
Return (AICH ()) |
|
} |
|
|
|
If ((IIA0 == 0x00060024)) |
|
{ |
|
Name (BBUF, Buffer (0x14){}) |
|
CreateDWordField (BBUF, Zero, DAT1) |
|
CreateDWordField (BBUF, 0x04, DAT2) |
|
CreateDWordField (BBUF, 0x08, DAT3) |
|
CreateDWordField (BBUF, 0x0C, DAT4) |
|
CreateDWordField (BBUF, 0x10, DAT5) |
|
DAT1 = 0x78141022 |
|
DAT2 = 0x03 |
|
DAT3 = 0x78141022 |
|
DAT4 = 0x04 |
|
DAT5 = 0xFFFFFFFF |
|
Return (BBUF) /* \_SB_.ATKD.WMNB.BBUF */ |
|
} |
|
|
|
If ((IIA0 == 0x00060025)) |
|
{ |
|
Name (INFO, Buffer (0x08){}) |
|
CreateDWordField (INFO, Zero, INF1) |
|
CreateDWordField (INFO, 0x04, INF2) |
|
INF1 = 0x1000 |
|
INF2 = 0xFFFFFFFF |
|
Return (INFO) /* \_SB_.ATKD.WMNB.INFO */ |
|
} |
|
|
|
If ((IIA0 == 0x00120041)) |
|
{ |
|
Return (NS3P ()) |
|
} |
|
|
|
If ((IIA0 == 0x00120042)) |
|
{ |
|
Return (DS3P ()) |
|
} |
|
|
|
If ((IIA0 == 0x00120043)) |
|
{ |
|
Return (T2BF ()) |
|
} |
|
|
|
If ((IIA0 == 0x00120037)) |
|
{ |
|
Return (0x00010000) |
|
} |
|
|
|
If ((IIA0 == 0x00120038)) |
|
{ |
|
Return (0x00010000) |
|
} |
|
|
|
If ((IIA0 == 0x00120044)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= ^^PCI0.SBRG.HEC.BRCP () |
|
Return (Local0) |
|
} |
|
|
|
If ((IIA0 == 0x00120045)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= N3MV () |
|
Return (Local0) |
|
} |
|
|
|
If ((IIA0 == 0x00120046)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= D3MV () |
|
Return (Local0) |
|
} |
|
|
|
If ((IIA0 == 0x00120047)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= ^^PCI0.SBRG.HEC.BIF4 () |
|
Return (Local0) |
|
} |
|
|
|
If ((IIA0 == 0x00120048)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= S4PC () |
|
Return (Local0) |
|
} |
|
|
|
If ((IIA0 == 0x00120049)) |
|
{ |
|
Local0 = 0x00010000 |
|
Local0 |= ^^PCI0.SBRG.HEC.BIF2 () |
|
Return (Local0) |
|
} |
|
|
|
Return (0x02) |
|
} |
|
ElseIf ((_T_0 == 0x53564544)) |
|
{ |
|
CreateDWordField (Arg2, 0x04, IIA1) |
|
If ((IIA0 == 0x00020011)) |
|
{ |
|
Return (SALE ((IIA1 + 0x02))) |
|
} |
|
|
|
If ((IIA0 == 0x00020012)) |
|
{ |
|
Return (SALE ((IIA1 + 0x04))) |
|
} |
|
|
|
If ((IIA0 == 0x00020013)) |
|
{ |
|
Return (SALE ((IIA1 + 0x08))) |
|
} |
|
|
|
If ((IIA0 == 0x00040015)) |
|
{ |
|
Return (SALE ((IIA1 + 0x10))) |
|
} |
|
|
|
If ((IIA0 == 0x00020014)) |
|
{ |
|
Return (SALE ((IIA1 + 0x20))) |
|
} |
|
|
|
If ((IIA0 == 0x00020015)) |
|
{ |
|
Return (SALE ((IIA1 + 0x40))) |
|
} |
|
|
|
If ((IIA0 == 0x00020016)) |
|
{ |
|
Return (SALE ((IIA1 + 0x80))) |
|
} |
|
|
|
If ((IIA0 == 0x00020019)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00020020)) |
|
{ |
|
CPCS (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00050012)) |
|
{ |
|
SPLV (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00050011)) |
|
{ |
|
If ((IIA1 == 0x02)) |
|
{ |
|
LIDP = One |
|
} |
|
Else |
|
{ |
|
LIDP = Zero |
|
} |
|
} |
|
|
|
If ((IIA0 == 0x00010002)) |
|
{ |
|
OWGD (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010012)) |
|
{ |
|
If (\WMI0.WLDP) |
|
{ |
|
WLED (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010013)) |
|
{ |
|
If (\WMI0.BTDP) |
|
{ |
|
BLED (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010003)) |
|
{ |
|
Return (CWAP (IIA1)) |
|
} |
|
|
|
If ((IIA0 == 0x00010015)) |
|
{ |
|
If (\WMI0.GPDP) |
|
{ |
|
GPSC (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010019)) |
|
{ |
|
If (\WMI0.TGDP) |
|
{ |
|
GSMC (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010017)) |
|
{ |
|
If (\WMI0.WMDP) |
|
{ |
|
WMXC (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00010021)) |
|
{ |
|
If (\WMI0.UWDP) |
|
{ |
|
UWBC (IIA1) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00120012)) |
|
{ |
|
Return (PSTC ((IIA1 + One))) |
|
} |
|
|
|
If ((IIA0 == 0x00100012)) |
|
{ |
|
TLED (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00020018)) |
|
{ |
|
EGCR (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00120031)) |
|
{ |
|
DESP (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00120037)) |
|
{ |
|
IOMB (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00120038)) |
|
{ |
|
IOMT (IIA1) |
|
Return (One) |
|
} |
|
|
|
If ((IIA0 == 0x00120032)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((IIA0 == 0x00060023)) |
|
{ |
|
AICG (IIA1) |
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
ElseIf ((_T_0 == 0x50564544)) |
|
{ |
|
Return (GSRD (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x59454B48)) |
|
{ |
|
HKEY () |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x5446424B)) |
|
{ |
|
KBFT (IIA0) |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x46494643)) |
|
{ |
|
Return (One) |
|
} |
|
ElseIf ((_T_0 == 0x44495046)) |
|
{ |
|
Return (FPID ()) |
|
} |
|
ElseIf ((_T_0 == 0x424D5352)) |
|
{ |
|
Return (RSMB (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x424D5357)) |
|
{ |
|
Return (WSMB (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x574D5352)) |
|
{ |
|
Return (RSMW (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x574D5357)) |
|
{ |
|
Return (WSMW (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x4B4D5352)) |
|
{ |
|
Return (RSMK (IIA0)) |
|
} |
|
ElseIf ((_T_0 == 0x4B4D5357)) |
|
{ |
|
Return (WSMK (IIA0)) |
|
} |
|
Else |
|
{ |
|
Return (0xFFFFFFFE) |
|
} |
|
} |
|
|
|
Method (_WED, 1, NotSerialized) // _Wxx: Wake Event, xx=0x00-0xFF |
|
{ |
|
If ((Arg0 == 0xFF)) |
|
{ |
|
Return (GANQ ()) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (INIT, 1, NotSerialized) |
|
{ |
|
ATKP = One |
|
Return (\WMI0.MNAM) |
|
} |
|
|
|
Method (BSTS, 0, NotSerialized) |
|
{ |
|
If (((^^PCI0.SBRG.HEC.RRAM (0x04FE) == 0x34) || (^^PCI0.SBRG.HEC.RRAM (0x04FE) == 0x39))) |
|
{ |
|
Return (0x05) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (TMPR, 0, NotSerialized) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Method (SFUN, 0, NotSerialized) |
|
{ |
|
Local0 = 0x37 |
|
Local0 |= 0x40 |
|
Local0 |= 0x80 |
|
Local0 |= 0x0800 |
|
Local0 |= 0x00020000 |
|
Local0 |= 0x00080000 |
|
Local0 |= 0x00400000 |
|
Return (Local0) |
|
} |
|
|
|
Method (OSVR, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (GPLV, 0, NotSerialized) |
|
{ |
|
Return (\WMI0.LBTN) |
|
} |
|
|
|
Method (SPLV, 1, NotSerialized) |
|
{ |
|
\WMI0.LBTN = Arg0 |
|
^^PCI0.SBRG.HEC.STBR () |
|
Return (One) |
|
} |
|
|
|
Method (SPBL, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == 0x0100)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x80)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 >= 0x0B)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 < Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
\WMI0.LBTN = Arg0 |
|
^^PCI0.SBRG.HEC.STBR () |
|
Return (One) |
|
} |
|
|
|
Method (GSRD, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (OWGD, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (WLED, 1, NotSerialized) |
|
{ |
|
OWLD (Arg0) |
|
Return (One) |
|
} |
|
|
|
Method (BLED, 1, NotSerialized) |
|
{ |
|
OBTD (Arg0) |
|
Return (One) |
|
} |
|
|
|
Method (UWBC, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (WMXC, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (GPSC, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (GSMC, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (KBNI, 0, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (GALE, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == 0x04)) |
|
{ |
|
If ((LEDS && 0x04)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
If ((Arg0 == 0x08)) |
|
{ |
|
If ((LEDS && 0x08)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
If ((Arg0 == 0x10)) |
|
{ |
|
If ((LEDS && 0x10)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Return (0x02) |
|
} |
|
|
|
Method (SALE, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (GMLE, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (SMLE, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (GDSP, 1, NotSerialized) |
|
{ |
|
If (NATK ()) |
|
{ |
|
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler, x=0-9, A-Z |
|
_T_0 = Arg0 |
|
If ((_T_0 == Zero)) |
|
{ |
|
Return (OGND ()) |
|
} |
|
ElseIf ((_T_0 == One)) |
|
{ |
|
Return (OEAD ()) |
|
} |
|
ElseIf ((_T_0 == 0x02)) |
|
{ |
|
Return (OGCD ()) |
|
} |
|
ElseIf ((_T_0 == 0x80)) |
|
{ |
|
Return (One) |
|
} |
|
} |
|
} |
|
|
|
Method (SDSP, 1, NotSerialized) |
|
{ |
|
SWHG (Arg0) |
|
} |
|
|
|
Method (GPID, 0, NotSerialized) |
|
{ |
|
Return (\WMI0.LCDR) |
|
} |
|
|
|
Method (FPID, 0, NotSerialized) |
|
{ |
|
Return (0x0118) |
|
} |
|
|
|
Method (ALSC, 1, NotSerialized) |
|
{ |
|
If (Arg0){} |
|
Else |
|
{ |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (ALSL, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (HWRS, 0, NotSerialized) |
|
{ |
|
Return (OHWR ()) |
|
} |
|
|
|
Method (GLCD, 0, NotSerialized) |
|
{ |
|
Return (\WMI0.LCDV) |
|
} |
|
|
|
Method (CWAP, 1, NotSerialized) |
|
{ |
|
WAPF |= Arg0 /* \_SB_.ATKD.WAPF */ |
|
Return (One) |
|
} |
|
|
|
Method (WDOG, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
PCDV = \WMI0.PTIM |
|
Return (0x3C) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
If (^^LID._LID ()) |
|
{ |
|
PCDV = \WMI0.PTIM |
|
Return (One) |
|
} |
|
|
|
If ((\_TZ.RLTM () < \WMI0.PTMP)) |
|
{ |
|
PCDV = \WMI0.PTIM |
|
Return (One) |
|
} |
|
|
|
PCDV-- |
|
If ((PCDV == Zero)) |
|
{ |
|
PCDV = \WMI0.PTIM |
|
NTFY (0x6D) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (DPWR, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (QDEV, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
If ((Arg0 == 0x04)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
If ((Arg0 == 0x08)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
Return (0x02) |
|
} |
|
|
|
Method (SDON, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x04)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x08)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (SDOF, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x04)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == 0x08)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (QMOD, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg0 == One)){} |
|
If ((Arg0 == 0x02)){} |
|
Return (One) |
|
} |
|
|
|
Method (ANVI, 1, Serialized) |
|
{ |
|
Local0 = ASMI (Arg0) |
|
Return (Local0) |
|
} |
|
|
|
Method (PSTC, 1, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Return (\WMI0.PSTN) |
|
} |
|
|
|
If (\WMI0.ACPF) |
|
{ |
|
Local0 = (\WMI0.PSTN >> 0x08) |
|
} |
|
Else |
|
{ |
|
Local0 = (\WMI0.PSTN & 0xFF) |
|
} |
|
|
|
If ((Arg0 > Local0)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
\WMI0.SLMT = Arg0 |
|
PNOT () |
|
Return (Zero) |
|
} |
|
|
|
Method (SMBB, 1, Serialized) |
|
{ |
|
Local0 = (Arg0 >> 0x10) |
|
Local0 &= 0xFF |
|
Local1 = (Arg0 >> 0x18) |
|
Local2 = (Arg0 & 0xFF) |
|
If ((Local1 & One)) |
|
{ |
|
Return (RBYT (Local1, Local0)) |
|
} |
|
Else |
|
{ |
|
Return (WBYT (Local1, Local0, Local2)) |
|
} |
|
} |
|
|
|
Method (SMBW, 1, Serialized) |
|
{ |
|
Local0 = (Arg0 >> 0x10) |
|
Local0 &= 0xFF |
|
Local1 = (Arg0 >> 0x18) |
|
Local2 = (Arg0 & 0xFF) |
|
If ((Local1 & One)) |
|
{ |
|
Return (RWRD (Local1, Local0)) |
|
} |
|
Else |
|
{ |
|
Return (WWRD (Local1, Local0, Local2)) |
|
} |
|
} |
|
|
|
Method (SMBK, 1, Serialized) |
|
{ |
|
Local0 = (Arg0 >> 0x08) |
|
Local0 &= 0xFF |
|
If (Local0) |
|
{ |
|
Local0 = (Arg0 >> 0x10) |
|
Local0 &= 0xFF |
|
Local1 = (Arg0 >> 0x18) |
|
Local1 &= 0xFF |
|
Local3 = (Arg0 & 0x0F) |
|
If ((Local1 & One)) |
|
{ |
|
RBLK (Local1, Local0, Local3) |
|
} |
|
Else |
|
{ |
|
WBLK (Local1, Local0, Local3) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
Else |
|
{ |
|
Local2 = (Arg0 >> 0x10) |
|
Local2 &= 0xFF |
|
Local1 = (Arg0 >> 0x18) |
|
If ((Local1 & One)) |
|
{ |
|
Return (DerefOf (RBUF [Local2])) |
|
} |
|
Else |
|
{ |
|
Local1 = (Arg0 & 0xFF) |
|
RBUF [Local2] = Local1 |
|
Return (Zero) |
|
} |
|
} |
|
} |
|
|
|
Method (ECRW, 1, Serialized) |
|
{ |
|
Local0 = (Arg0 >> 0x18) |
|
Local0 &= 0xFF |
|
Local1 = (Arg0 >> 0x10) |
|
Local1 &= 0xFF |
|
Local2 = (Arg0 >> 0x08) |
|
Local2 &= 0xFF |
|
Local3 = (Arg0 & 0xFF) |
|
If ((Acquire (^^PCI0.SBRG.HEC.MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
^^PCI0.SBRG.HEC.CDT3 = Local0 |
|
^^PCI0.SBRG.HEC.CDT2 = Local1 |
|
^^PCI0.SBRG.HEC.CDT1 = Local2 |
|
^^PCI0.SBRG.HEC.CMD1 = Local3 |
|
Local0 = 0x05 |
|
While ((Local0 && ^^PCI0.SBRG.HEC.CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
Local0 = ^^PCI0.SBRG.HEC.CDT3 /* \_SB_.PCI0.SBRG.HEC_.CDT3 */ |
|
Local1 = ^^PCI0.SBRG.HEC.CDT2 /* \_SB_.PCI0.SBRG.HEC_.CDT2 */ |
|
Local2 = ^^PCI0.SBRG.HEC.CDT1 /* \_SB_.PCI0.SBRG.HEC_.CDT1 */ |
|
Local3 = ^^PCI0.SBRG.HEC.CMD1 /* \_SB_.PCI0.SBRG.HEC_.CMD1 */ |
|
Release (^^PCI0.SBRG.HEC.MUEC) |
|
Local0 <<= 0x08 |
|
Local0 |= Local1 |
|
Local0 <<= 0x08 |
|
Local0 |= Local2 |
|
Local0 <<= 0x08 |
|
Local0 |= Local3 |
|
Return (Local0) |
|
} |
|
|
|
Method (CBIF, 1, Serialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (TLED, 1, NotSerialized) |
|
{ |
|
OTLD (Arg0) |
|
} |
|
|
|
Method (GLED, 1, NotSerialized) |
|
{ |
|
OGLD (Arg0) |
|
} |
|
|
|
Method (GLKB, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == One)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf ((Arg0 == 0x02)) |
|
{ |
|
Return (Zero) |
|
} |
|
ElseIf ((Arg0 == 0x03)) |
|
{ |
|
Return (0x80) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (SLKB, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (RLKB, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (CPCS, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (EGCR, 1, Serialized) |
|
{ |
|
} |
|
|
|
Method (RSMB, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (WSMB, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (RSMW, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (WSMW, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (RSMK, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (WSMK, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
|
|
Method (USBC, 1, NotSerialized) |
|
{ |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Device (ASHS) |
|
{ |
|
Name (_HID, "ATK4001" /* Asus Radio Control Button */) // _HID: Hardware ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (_OSI ("Windows 2012")) |
|
{ |
|
Return (0x0F) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (NTFY, 1, Serialized) |
|
{ |
|
Notify (ASHS, Arg0) |
|
} |
|
|
|
Method (HSWC, 1, Serialized) |
|
{ |
|
If ((Arg0 < 0x02)) |
|
{ |
|
If (\WMI0.WLDP) |
|
{ |
|
OWLD (Arg0) |
|
} |
|
|
|
If (\WMI0.BTDP) |
|
{ |
|
OBTD (Arg0) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Return (\WMI0.BRST) |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
Return (OHWR ()) |
|
} |
|
|
|
If ((Arg0 == 0x80)) |
|
{ |
|
Return (One) |
|
Return (0x03) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG) |
|
{ |
|
Device (HEC) |
|
{ |
|
Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID |
|
Name (CRS, ResourceTemplate () |
|
{ |
|
IO (Decode16, |
|
0x0062, // Range Minimum |
|
0x0062, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
IO (Decode16, |
|
0x0066, // Range Minimum |
|
0x0066, // Range Maximum |
|
0x00, // Alignment |
|
0x01, // Length |
|
) |
|
Memory32Fixed (ReadOnly, |
|
0x00000000, // Address Base |
|
0x00000500, // Address Length |
|
_Y17) |
|
}) |
|
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
|
{ |
|
CreateDWordField (CRS, \_SB.PCI0.SBRG.HEC._Y17._BAS, HB01) // _BAS: Base Address |
|
HB01 = \WMI0.HEM1 |
|
Return (CRS) /* \_SB_.PCI0.SBRG.HEC_.CRS_ */ |
|
} |
|
|
|
Name (_GPE, 0x0C) // _GPE: General Purpose Events |
|
Mutex (MUEC, 0x00) |
|
Mutex (ASIO, 0x00) |
|
Name (ECFL, Ones) |
|
Method (ECAV, 0, NotSerialized) |
|
{ |
|
If ((_REV >= 0x02)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If ((\WMI0.SLPT >= 0x04)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((ECFL == Ones)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Return (ECFL) /* \_SB_.PCI0.SBRG.HEC_.ECFL */ |
|
} |
|
|
|
OperationRegion (ECOR, EmbeddedControl, Zero, 0xFF) |
|
Field (ECOR, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x04), |
|
Offset (0x05), |
|
CDTD, 8, |
|
Offset (0x8A), |
|
HKEN, 1 |
|
} |
|
|
|
OperationRegion (ECW1, SystemMemory, \WMI0.HEM1, 0x80) |
|
Field (ECW1, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x01), |
|
EPWS, 8, |
|
EB0S, 8, |
|
EB1S, 8, |
|
EB0R, 8, |
|
EB1R, 8, |
|
EB0T, 8, |
|
EB1T, 8, |
|
Offset (0x10), |
|
B0PN, 16, |
|
B0VL, 16, |
|
B0RC, 16, |
|
B0FC, 16, |
|
B0ST, 16, |
|
B0CC, 16, |
|
B0TM, 16, |
|
B0C1, 16, |
|
B0CV, 16, |
|
Offset (0x30), |
|
B1PN, 16, |
|
B1VL, 16, |
|
B1RC, 16, |
|
B1FC, 16, |
|
B1ST, 16, |
|
B1CC, 16, |
|
B1TM, 16, |
|
B1C1, 16, |
|
B1CV, 16, |
|
Offset (0x50), |
|
B0DC, 16, |
|
B0DV, 16, |
|
B0SN, 16, |
|
B0MD, 16, |
|
B1DC, 16, |
|
B1DV, 8, |
|
B1SN, 8, |
|
B1MD, 8, |
|
Offset (0x60), |
|
TH1R, 8, |
|
TH1L, 8, |
|
TH0R, 8, |
|
TH0L, 8, |
|
ECRT, 8, |
|
EPSV, 8, |
|
EACT, 8, |
|
TERR, 8, |
|
F0TS, 16, |
|
F1TS, 16, |
|
F0CS, 8, |
|
F1CS, 8, |
|
PCPT, 16 |
|
} |
|
|
|
OperationRegion (ECW2, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECW2, ByteAcc, Lock, Preserve) |
|
{ |
|
ESEM, 8, |
|
CMD1, 8, |
|
CDT1, 8, |
|
CDT2, 8, |
|
CDT3, 8, |
|
CDT4, 8, |
|
CDT5, 8, |
|
CDT6, 8, |
|
CDT7, 8, |
|
CDT8, 8, |
|
CDT9, 8, |
|
CD10, 8, |
|
Offset (0x40), |
|
EDA1, 8, |
|
EDA2, 8, |
|
EDA3, 8, |
|
EDA4, 8, |
|
EDA5, 8, |
|
EDA6, 8, |
|
EDA7, 8, |
|
EDA8, 8, |
|
EDA9, 8, |
|
ED10, 8 |
|
} |
|
|
|
OperationRegion (ECWB, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECWB, ByteAcc, Lock, Preserve) |
|
{ |
|
ESEB, 8, |
|
CMDB, 8, |
|
CDTB, 256, |
|
Offset (0x40), |
|
EDAB, 256 |
|
} |
|
|
|
Method (_INI, 0, NotSerialized) // _INI: Initialize |
|
{ |
|
If ((OSFG <= OSME)) |
|
{ |
|
ECFL = One |
|
} |
|
} |
|
|
|
Method (_REG, 2, NotSerialized) // _REG: Region Availability |
|
{ |
|
If ((Arg0 == 0x03)) |
|
{ |
|
ECFL = Arg1 |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (CPUX, 4, NotSerialized) |
|
{ |
|
If ((Arg1 == 0x31)) |
|
{ |
|
If ((Arg2 == 0x02)) |
|
{ |
|
GCPU (Arg0, Arg1, Arg2, Arg3) |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
SCPU (Arg0, Arg1, Arg2, Arg3) |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (GCPU, 4, NotSerialized) |
|
{ |
|
OperationRegion (\F31A, SystemMemory, Arg0, 0x10) |
|
Field (F31A, DWordAcc, NoLock, Preserve) |
|
{ |
|
MFUN, 16, |
|
SFUN, 16, |
|
LEN, 16, |
|
STAS, 8, |
|
EROR, 8, |
|
PSIN, 16 |
|
} |
|
|
|
PSIN = PSTC (Zero) |
|
STAS = 0x80 |
|
} |
|
|
|
Method (SCPU, 4, NotSerialized) |
|
{ |
|
OperationRegion (\F31B, SystemMemory, Arg0, 0x10) |
|
Field (F31B, DWordAcc, NoLock, Preserve) |
|
{ |
|
MFUN, 16, |
|
SFUN, 16, |
|
LEN, 16, |
|
STAS, 8, |
|
EROR, 8, |
|
PSTL, 8 |
|
} |
|
|
|
If (PSTC (PSTL)) |
|
{ |
|
STAS = 0x82 |
|
EROR = One |
|
} |
|
Else |
|
{ |
|
STAS = 0x80 |
|
} |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Method (PNOT, 0, Serialized) |
|
{ |
|
Notify (\_PR.P000, 0x80) // Performance Capability Change |
|
Sleep (0x64) |
|
Notify (\_PR.P000, 0x81) // C-State Change |
|
Notify (\_PR.P001, 0x80) // Performance Capability Change |
|
Sleep (0x64) |
|
Notify (\_PR.P001, 0x81) // C-State Change |
|
If ((\WMI0.CPUN > 0x02)) |
|
{ |
|
Notify (\_PR.P002, 0x80) // Performance Capability Change |
|
Sleep (0x64) |
|
Notify (\_PR.P002, 0x81) // C-State Change |
|
} |
|
|
|
If ((\WMI0.CPUN > 0x03)) |
|
{ |
|
Notify (\_PR.P003, 0x80) // Performance Capability Change |
|
Sleep (0x64) |
|
Notify (\_PR.P003, 0x81) // C-State Change |
|
} |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
OperationRegion (SMIX, SystemMemory, SMIB, 0x0100) |
|
Field (SMIX, ByteAcc, Lock, Preserve) |
|
{ |
|
SEST, 32, |
|
SEEN, 32, |
|
SETR, 32, |
|
SEEL, 32, |
|
SSCS, 32, |
|
SSCE, 32, |
|
SWSE, 32, |
|
SWSD, 32, |
|
Offset (0xA0), |
|
SCT0, 32, |
|
SCT1, 32, |
|
SCT2, 32, |
|
SCT3, 32, |
|
SCT4, 32, |
|
SCT5, 32, |
|
SCT6, 32, |
|
SCT7, 32, |
|
SCT8, 32, |
|
SCT9, 32 |
|
} |
|
|
|
OperationRegion (IOMX, SystemMemory, IOMB, 0x0100) |
|
Field (IOMX, ByteAcc, Lock, Preserve) |
|
{ |
|
IM00, 8 |
|
} |
|
|
|
OperationRegion (P80X, SystemIO, 0x80, 0x04) |
|
Field (P80X, DWordAcc, Lock, Preserve) |
|
{ |
|
P80D, 32 |
|
} |
|
|
|
Method (P8XH, 2, Serialized) |
|
{ |
|
Local0 = P80D /* \P80D */ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Local0 = ((Local0 & 0xFFFFFF00) | Arg1) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
Local0 = ((Local0 & 0xFFFF00FF) | (Arg1 << 0x08)) |
|
} |
|
|
|
If ((Arg0 == 0x02)) |
|
{ |
|
Local0 = ((Local0 & 0xFF00FFFF) | (Arg1 << 0x10)) |
|
} |
|
|
|
If ((Arg0 == 0x03)) |
|
{ |
|
Local0 = ((Local0 & 0x00FFFFFF) | (Arg1 << 0x18)) |
|
} |
|
|
|
P80D = Local0 |
|
} |
|
|
|
Method (RGLV, 1, Serialized) |
|
{ |
|
Local0 = (Arg0 + GIOB) /* \GIOB */ |
|
OperationRegion (GLVX, SystemMemory, Local0, 0x08) |
|
Field (GLVX, ByteAcc, Lock, Preserve) |
|
{ |
|
GPXX, 8 |
|
} |
|
|
|
If ((GPXX & 0x80)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (SGLV, 2, Serialized) |
|
{ |
|
Local0 = (Arg0 + GIOB) /* \GIOB */ |
|
OperationRegion (GLVX, SystemMemory, Local0, 0x08) |
|
Field (GLVX, ByteAcc, Lock, Preserve) |
|
{ |
|
GPXX, 8 |
|
} |
|
|
|
If (Arg1) |
|
{ |
|
GPXX |= 0x40 |
|
} |
|
Else |
|
{ |
|
GPXX &= 0xBF |
|
} |
|
} |
|
|
|
Method (RGPL, 2, Serialized) |
|
{ |
|
Local0 = Arg0 |
|
Local1 = Arg1 |
|
Local3 = Zero |
|
Local4 = Zero |
|
While (Local1) |
|
{ |
|
If (RGLV (Local0)) |
|
{ |
|
Local3 |= (One << Local4) |
|
} |
|
|
|
Local0++ |
|
Local1-- |
|
Local4++ |
|
} |
|
|
|
Return (Local3) |
|
} |
|
|
|
Method (SGPL, 3, Serialized) |
|
{ |
|
Local0 = Arg0 |
|
Local1 = Arg1 |
|
Local3 = Arg2 |
|
Local4 = Zero |
|
While (Local1) |
|
{ |
|
Local2 = (One << Local4) |
|
If ((Local2 & Local3)) |
|
{ |
|
SGLV (Local0, One) |
|
} |
|
Else |
|
{ |
|
SGLV (Local0, Zero) |
|
} |
|
|
|
Local0++ |
|
Local1-- |
|
Local4++ |
|
} |
|
} |
|
|
|
Method (RGPP, 1, Serialized) |
|
{ |
|
If ((Arg0 < 0x60)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local1 = (Arg0 - 0x60) |
|
If ((Local1 >= 0x18)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0 = SETR /* \SETR */ |
|
If ((Local1 < 0x10)) |
|
{ |
|
Local1 += 0x10 |
|
} |
|
ElseIf ((Local1 < 0x13)) |
|
{ |
|
Local1 -= 0x0D |
|
} |
|
ElseIf ((Local1 == 0x13)) |
|
{ |
|
Local1 = 0x07 |
|
} |
|
ElseIf ((Local1 == 0x14)) |
|
{ |
|
Local1 = 0x0A |
|
} |
|
ElseIf ((Local1 == 0x15)) |
|
{ |
|
Local1 = 0x0C |
|
} |
|
ElseIf ((Local1 == 0x16)) |
|
{ |
|
Local1 = 0x0E |
|
} |
|
ElseIf ((Local1 == 0x17)) |
|
{ |
|
Local1 = 0x0F |
|
} |
|
|
|
Local1 = (One << Local1) |
|
If ((Local0 & Local1)) |
|
{ |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (TGPP, 1, Serialized) |
|
{ |
|
If ((Arg0 < 0x60)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local1 = (Arg0 - 0x60) |
|
If ((Local1 >= 0x18)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0 = SETR /* \SETR */ |
|
If ((Local1 < 0x10)) |
|
{ |
|
Local1 += 0x10 |
|
} |
|
ElseIf ((Local1 < 0x13)) |
|
{ |
|
Local1 -= 0x0D |
|
} |
|
ElseIf ((Local1 == 0x13)) |
|
{ |
|
Local1 = 0x07 |
|
} |
|
ElseIf ((Local1 == 0x14)) |
|
{ |
|
Local1 = 0x0A |
|
} |
|
ElseIf ((Local1 == 0x15)) |
|
{ |
|
Local1 = 0x0C |
|
} |
|
ElseIf ((Local1 == 0x16)) |
|
{ |
|
Local1 = 0x0E |
|
} |
|
ElseIf ((Local1 == 0x17)) |
|
{ |
|
Local1 = 0x0F |
|
} |
|
|
|
Local1 = (One << Local1) |
|
SETR = (Local0 ^ Local1) |
|
Return (Zero) |
|
} |
|
|
|
Method (SGPP, 2, Serialized) |
|
{ |
|
If ((Arg0 < 0x60)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local1 = (Arg0 - 0x60) |
|
If ((Local1 >= 0x18)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0 = SETR /* \SETR */ |
|
If ((Local1 < 0x10)) |
|
{ |
|
Local1 += 0x10 |
|
} |
|
ElseIf ((Local1 < 0x13)) |
|
{ |
|
Local1 -= 0x0D |
|
} |
|
ElseIf ((Local1 == 0x13)) |
|
{ |
|
Local1 = 0x07 |
|
} |
|
ElseIf ((Local1 == 0x14)) |
|
{ |
|
Local1 = 0x0A |
|
} |
|
ElseIf ((Local1 == 0x15)) |
|
{ |
|
Local1 = 0x0C |
|
} |
|
ElseIf ((Local1 == 0x16)) |
|
{ |
|
Local1 = 0x0E |
|
} |
|
ElseIf ((Local1 == 0x17)) |
|
{ |
|
Local1 = 0x0F |
|
} |
|
|
|
Local1 = (One << Local1) |
|
If (Arg1) |
|
{ |
|
SETR = (Local0 | Local1) |
|
} |
|
Else |
|
{ |
|
SETR = (Local0 & ~Local1) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Name (PMEW, Zero) |
|
Method (SBRS, 1, NotSerialized) |
|
{ |
|
CPXS () |
|
} |
|
|
|
Method (SBRW, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (STRP, 1, NotSerialized) |
|
{ |
|
Local0 = SCT4 /* \SCT4 */ |
|
If (Arg0) |
|
{ |
|
Local0 &= 0xFFFFFFFFFFFFFFF3 |
|
Local0 |= 0x04 |
|
} |
|
Else |
|
{ |
|
Local0 &= 0xFFFFFFFFFFFFFFF3 |
|
} |
|
|
|
SCT4 = Local0 |
|
} |
|
|
|
Method (HKTH, 0, Serialized) |
|
{ |
|
Return (0xFFFF) |
|
} |
|
|
|
Method (CPXS, 0, NotSerialized) |
|
{ |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
OperationRegion (SMBX, SystemIO, 0x0B00, 0x10) |
|
Field (SMBX, ByteAcc, NoLock, Preserve) |
|
{ |
|
HSTS, 8, |
|
SSTS, 8, |
|
HSTC, 8, |
|
HCMD, 8, |
|
HADR, 8, |
|
HDT0, 8, |
|
HDT1, 8, |
|
BLKD, 8, |
|
SPEC, 8, |
|
SRCV, 8, |
|
SLVD, 16, |
|
AUXS, 8, |
|
AUXC, 8 |
|
} |
|
|
|
Name (RBUF, Package (0x20){}) |
|
Method (HBSY, 0, NotSerialized) |
|
{ |
|
Local0 = 0x000FFFFF |
|
While (Local0) |
|
{ |
|
Local1 = (HSTS & One) |
|
If (!Local1) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0-- |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (WTSB, 0, NotSerialized) |
|
{ |
|
Local0 = 0x000FFFFF |
|
While (Local0) |
|
{ |
|
Local0-- |
|
Local1 = (HSTS & 0x1E) |
|
If ((Local1 == 0x02)) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If (Local1) |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Mutex (P4SM, 0x00) |
|
Method (SBYT, 2, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
AUXC = Zero |
|
HADR = Arg0 |
|
HCMD = Arg1 |
|
HSTS = 0xFF |
|
HSTC = 0x44 |
|
If (WTSB ()) |
|
{ |
|
Release (P4SM) |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Release (P4SM) |
|
Return (Zero) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (WBYT, 3, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = Arg0 |
|
HCMD = Arg1 |
|
HDT0 = Arg2 |
|
HSTS = 0xFF |
|
HSTC = 0x48 |
|
If (WTSB ()) |
|
{ |
|
Release (P4SM) |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (WWRD, 3, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = Arg0 |
|
HCMD = Arg1 |
|
Local1 = (Arg2 & 0xFF) |
|
Local2 = (Arg2 >> 0x08) |
|
Local2 &= 0xFF |
|
HDT0 = Local2 |
|
HDT1 = Local1 |
|
HSTS = 0xFF |
|
HSTC = 0x4C |
|
If (WTSB ()) |
|
{ |
|
Release (P4SM) |
|
Return (One) |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (WBLK, 3, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = Arg0 |
|
HCMD = Arg1 |
|
HDT0 = Arg2 |
|
HSTS = 0xFF |
|
Local2 = Arg2 |
|
Local1 = Zero |
|
While (Local2) |
|
{ |
|
BLKD = DerefOf (RBUF [Local1]) |
|
HSTS = 0x80 |
|
If ((Local1 == Zero)) |
|
{ |
|
HSTC = 0x54 |
|
} |
|
|
|
Local3 = 0xFFFF |
|
While (Local3) |
|
{ |
|
Local4 = HSTS /* \HSTS */ |
|
If (Local5 = (Local4 & 0x80)) |
|
{ |
|
Local3 = Zero |
|
} |
|
Else |
|
{ |
|
Local3-- |
|
} |
|
} |
|
|
|
If (Local5) |
|
{ |
|
Local2-- |
|
Local1++ |
|
If (Local5 = (Local4 & 0x02)) |
|
{ |
|
Release (P4SM) |
|
Return (One) |
|
} |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
Local2 = Zero |
|
HSTC = 0x02 |
|
} |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (RSBT, 2, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = (Arg0 | One) |
|
HCMD = Arg1 |
|
HSTS = 0xFF |
|
HSTC = 0x44 |
|
If (WTSB ()) |
|
{ |
|
Release (P4SM) |
|
Return (HDT0) /* \HDT0 */ |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (RBYT, 2, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = (Arg0 | One) |
|
HCMD = Arg1 |
|
HSTS = 0xFF |
|
HSTC = 0x48 |
|
If (WTSB ()) |
|
{ |
|
Release (P4SM) |
|
Return (HDT0) /* \HDT0 */ |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (RWRD, 2, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = (Arg0 | One) |
|
HCMD = Arg1 |
|
HSTS = 0xFF |
|
HSTC = 0x4C |
|
If (WTSB ()) |
|
{ |
|
Local1 = HDT0 /* \HDT0 */ |
|
Local1 <<= 0x08 |
|
Local2 = HDT1 /* \HDT1 */ |
|
Local1 += Local2 |
|
Release (P4SM) |
|
Return (Local1) |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
|
|
Method (RBLK, 3, Serialized) |
|
{ |
|
If ((Acquire (P4SM, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
Local0 = 0x05 |
|
While (Local0) |
|
{ |
|
If (HBSY ()) |
|
{ |
|
Local0-- |
|
} |
|
Else |
|
{ |
|
HADR = (Arg0 | One) |
|
HCMD = Arg1 |
|
HSTS = 0xFF |
|
HSTC = 0x54 |
|
If (WTSB ()) |
|
{ |
|
Local1 = HSTC /* \HSTC */ |
|
Local2 = HDT0 /* \HDT0 */ |
|
Local3 = Local2 |
|
RBUF = Zero |
|
Local1 = Zero |
|
While (Local2) |
|
{ |
|
RBUF [Local1] = BLKD /* \BLKD */ |
|
Local2-- |
|
Local1++ |
|
} |
|
|
|
Release (P4SM) |
|
Return (Local3) |
|
} |
|
Else |
|
{ |
|
Local0-- |
|
} |
|
} |
|
} |
|
|
|
Release (P4SM) |
|
Return (Ones) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Name (SUPP, Zero) |
|
Name (CTRL, Zero) |
|
Name (OSCF, Zero) |
|
Method (OSCW, 0, NotSerialized) |
|
{ |
|
} |
|
} |
|
|
|
Scope (_GPE) |
|
{ |
|
Method (_L0B, 0, Serialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF |
|
{ |
|
Sleep (One) |
|
Notify (\_SB.SLPB, 0x02) // Device Wake |
|
} |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Name (CNTB, Buffer (0x0E) |
|
{ |
|
/* 0000 */ 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, // ........ |
|
/* 0008 */ 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00 // ...... |
|
}) |
|
Name (VISB, Buffer (0x0E) |
|
{ |
|
/* 0000 */ 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, // ........ |
|
/* 0008 */ 0x00, 0x00, 0x01, 0x01, 0x00, 0x00 // ...... |
|
}) |
|
Name (SHPB, Buffer (0x0E) |
|
{ |
|
/* 0000 */ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, // ........ |
|
/* 0008 */ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07 // ...... |
|
}) |
|
Name (BUPC, Package (0x04) |
|
{ |
|
0xFF, |
|
Zero, |
|
Zero, |
|
Zero |
|
}) |
|
Name (BPLD, Buffer (0x10) |
|
{ |
|
/* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ |
|
/* 0008 */ 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 1....... |
|
}) |
|
Method (OUPC, 1, Serialized) |
|
{ |
|
Local0 = DerefOf (CNTB [Arg0]) |
|
BUPC [Zero] = Local0 |
|
} |
|
|
|
Method (OPLD, 1, Serialized) |
|
{ |
|
Local0 = DerefOf (VISB [Arg0]) |
|
Local1 = DerefOf (BPLD [0x08]) |
|
Local1 &= 0xFE |
|
Local1 |= Local0 |
|
BPLD [0x08] = Local1 |
|
Local0 = DerefOf (SHPB [Arg0]) |
|
Local1 = DerefOf (BPLD [0x09]) |
|
Local1 &= 0xC3 |
|
Local1 |= Local0 |
|
BPLD [0x09] = Local1 |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.OHC2) |
|
{ |
|
Device (RHUB) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Device (PRT5) |
|
{ |
|
Name (_ADR, 0x05) // _ADR: Address |
|
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities |
|
{ |
|
\WMI0.OUPC (0x09) |
|
Return (\WMI0.BUPC) |
|
} |
|
|
|
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device |
|
{ |
|
\WMI0.OPLD (0x09) |
|
Return (\WMI0.BPLD) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.EHC2) |
|
{ |
|
Device (RHUB) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Device (PRT4) |
|
{ |
|
Name (_ADR, 0x04) // _ADR: Address |
|
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities |
|
{ |
|
\WMI0.OUPC (0x08) |
|
Return (\WMI0.BUPC) |
|
} |
|
|
|
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device |
|
{ |
|
\WMI0.OPLD (0x08) |
|
Return (\WMI0.BPLD) |
|
} |
|
} |
|
|
|
Device (PRT5) |
|
{ |
|
Name (_ADR, 0x05) // _ADR: Address |
|
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities |
|
{ |
|
\WMI0.OUPC (0x09) |
|
Return (\WMI0.BUPC) |
|
} |
|
|
|
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device |
|
{ |
|
\WMI0.OPLD (0x09) |
|
Return (\WMI0.BPLD) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.EHC2.RHUB.PRT4) |
|
{ |
|
Device (CAM0) |
|
{ |
|
Name (_ADR, 0x04) // _ADR: Address |
|
Name (_PLD, Package (0x01) // _PLD: Physical Location of Device |
|
{ |
|
ToPLD ( |
|
PLD_Revision = 0x2, |
|
PLD_IgnoreColor = 0x1, |
|
PLD_Red = 0x0, |
|
PLD_Green = 0x0, |
|
PLD_Blue = 0x0, |
|
PLD_Width = 0x0, |
|
PLD_Height = 0x0, |
|
PLD_UserVisible = 0x1, |
|
PLD_Dock = 0x0, |
|
PLD_Lid = 0x0, |
|
PLD_Panel = "FRONT", |
|
PLD_VerticalPosition = "LOWER", |
|
PLD_HorizontalPosition = "RIGHT", |
|
PLD_Shape = "UNKNOWN", |
|
PLD_GroupOrientation = 0x0, |
|
PLD_GroupToken = 0x0, |
|
PLD_GroupPosition = 0x0, |
|
PLD_Bay = 0x0, |
|
PLD_Ejectable = 0x0, |
|
PLD_EjectRequired = 0x0, |
|
PLD_CabinetNumber = 0x0, |
|
PLD_CardCageNumber = 0x0, |
|
PLD_Reference = 0x0, |
|
PLD_Rotation = 0x0, |
|
PLD_Order = 0x0, |
|
PLD_VerticalOffset = 0xFFFF, |
|
PLD_HorizontalOffset = 0xFFFF) |
|
|
|
}) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Device (AC0) |
|
{ |
|
Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID |
|
Name (XBUF, Buffer (0x03){}) |
|
Method (_PSR, 0, NotSerialized) // _PSR: Power Source |
|
{ |
|
CreateWordField (XBUF, Zero, SSZE) |
|
CreateByteField (XBUF, 0x02, ACST) |
|
SSZE = 0x03 |
|
Local0 = ^^SBRG.HEC.ACAP () |
|
If (Local0) |
|
{ |
|
^^VGA.AFN4 (One) |
|
ACST = Zero |
|
} |
|
Else |
|
{ |
|
^^VGA.AFN4 (0x02) |
|
ACST = One |
|
} |
|
|
|
ALIB |
|
One |
|
XBUF |
|
Return (^^SBRG.HEC.ACAP ()) |
|
} |
|
|
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List |
|
{ |
|
PCI0 |
|
}) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (ACAP, 0, Serialized) |
|
{ |
|
Return (\WMI0.ACPF) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Device (BAT0) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID |
|
Name (_UID, Zero) // _UID: Unique ID |
|
Name (_PCL, Package (0x01) // _PCL: Power Consumer List |
|
{ |
|
PCI0 |
|
}) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If (\WMI0.B0DP) |
|
{ |
|
If (^^SBRG.HEC.BATP (Zero)) |
|
{ |
|
Return (0x1F) |
|
} |
|
Else |
|
{ |
|
Return (0x0F) |
|
} |
|
} |
|
Else |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Name (LOW2, 0x012C) |
|
Name (DVOT, 0x0E) |
|
Name (PUNT, One) |
|
Name (LFCC, 0x1770) |
|
Name (NBIF, Package (0x0D) |
|
{ |
|
Zero, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
One, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
"", |
|
"", |
|
"", |
|
"" |
|
}) |
|
Name (PBIF, Package (0x0D) |
|
{ |
|
One, |
|
0x1770, |
|
0x1770, |
|
One, |
|
0x39D0, |
|
0x0258, |
|
0x012C, |
|
0x3C, |
|
0x3C, |
|
"M3N", |
|
" ", |
|
"LIon", |
|
"ASUS" |
|
}) |
|
Name (NBIX, Package (0x14) |
|
{ |
|
One, |
|
One, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
One, |
|
0xFFFFFFFF, |
|
0xFA, |
|
0x96, |
|
Zero, |
|
0x00100000, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0x0A, |
|
0x19, |
|
"M3N", |
|
" ", |
|
"LIon", |
|
"ASUS" |
|
}) |
|
Name (PBIX, Package (0x14) |
|
{ |
|
One, |
|
One, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
One, |
|
0xFFFFFFFF, |
|
0xFA, |
|
0x96, |
|
Zero, |
|
0x00100000, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0x0A, |
|
0x19, |
|
"M3N", |
|
" ", |
|
"LIon", |
|
"ASUS" |
|
}) |
|
Name (PBST, Package (0x04) |
|
{ |
|
Zero, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF, |
|
0xFFFFFFFF |
|
}) |
|
Method (FBIF, 5, NotSerialized) |
|
{ |
|
PUNT = Arg0 |
|
Local1 = Arg1 |
|
Local2 = Arg2 |
|
If ((PUNT == Zero)) |
|
{ |
|
Local1 *= 0x0A |
|
Local2 *= 0x0A |
|
} |
|
|
|
PBIF [Zero] = Arg0 |
|
PBIF [One] = Local1 |
|
PBIF [0x02] = Local2 |
|
LFCC = Local2 |
|
PBIF [0x03] = Arg3 |
|
PBIF [0x04] = Arg4 |
|
If ((OSFG < OSVT)) |
|
{ |
|
Divide (Local1, 0x64, Local3, Local5) |
|
} |
|
Else |
|
{ |
|
Divide (Local2, 0x64, Local3, Local5) |
|
} |
|
|
|
Local6 = (Local5 * 0x0A) |
|
PBIF [0x05] = Local6 |
|
Local6 = (Local5 * One) |
|
PBIF [0x06] = Local6 |
|
LOW2 = Local6 |
|
Divide (Local1, 0x64, Local3, Local7) |
|
PBIF [0x07] = Local7 |
|
PBIF [0x08] = Local7 |
|
} |
|
|
|
Method (CBIF, 0, NotSerialized) |
|
{ |
|
If (PUNT) |
|
{ |
|
Local0 = DerefOf (PBIF [0x04]) |
|
Local0 += 0x01F4 |
|
Divide (Local0, 0x03E8, Local1, DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [Zero] = Zero |
|
PBIF [One] = (DerefOf (PBIF [One]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [0x02] = (DerefOf (PBIF [0x02]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [0x05] = (DerefOf (PBIF [0x05]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [0x06] = (DerefOf (PBIF [0x06]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [0x07] = (DerefOf (PBIF [0x07]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBIF [0x08] = (DerefOf (PBIF [0x08]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
} |
|
} |
|
|
|
Method (_BIF, 0, Serialized) // _BIF: Battery Information |
|
{ |
|
If (!^^SBRG.HEC.BATP (Zero)) |
|
{ |
|
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ |
|
} |
|
|
|
If ((^^SBRG.HEC.GBTT (Zero) == 0xFF)) |
|
{ |
|
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ |
|
} |
|
|
|
BATS (Zero) |
|
PBIF [0x09] = ^^SBRG.HEC.BIF9 () |
|
PBIF [0x0C] = ONAM /* \ONAM */ |
|
Local0 = ^^SBRG.HEC.BIF0 () |
|
Local1 = ^^SBRG.HEC.BIF1 () |
|
Local2 = ^^SBRG.HEC.BIF2 () |
|
Local3 = ^^SBRG.HEC.BIF3 () |
|
Local4 = ^^SBRG.HEC.BIF4 () |
|
If ((Local0 != Ones)) |
|
{ |
|
If ((Local1 != Ones)) |
|
{ |
|
If ((Local2 != Ones)) |
|
{ |
|
If ((Local3 != Ones)) |
|
{ |
|
If ((Local4 != Ones)) |
|
{ |
|
FBIF (Local0, Local1, Local2, Local3, Local4) |
|
CBIF () |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
If ((PUNT == Zero)) |
|
{ |
|
Local2 *= 0x0A |
|
} |
|
|
|
LFCC = Local2 |
|
Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */ |
|
} |
|
|
|
Method (_BIX, 0, NotSerialized) // _BIX: Battery Information Extended |
|
{ |
|
If (!^^SBRG.HEC.BATP (Zero)) |
|
{ |
|
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ |
|
} |
|
|
|
If ((^^SBRG.HEC.GBTT (Zero) == 0xFF)) |
|
{ |
|
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ |
|
} |
|
|
|
_BIF () |
|
PBIX [Zero] = Zero |
|
PBIX [One] = DerefOf (PBIF [Zero]) |
|
PBIX [0x02] = DerefOf (PBIF [One]) |
|
PBIX [0x03] = DerefOf (PBIF [0x02]) |
|
PBIX [0x04] = DerefOf (PBIF [0x03]) |
|
PBIX [0x05] = DerefOf (PBIF [0x04]) |
|
PBIX [0x06] = DerefOf (PBIF [0x05]) |
|
PBIX [0x07] = DerefOf (PBIF [0x06]) |
|
PBIX [0x08] = 0x1000 |
|
PBIX [0x09] = 0x00080000 |
|
PBIX [0x0A] = 0xFFFFFFFF |
|
PBIX [0x0B] = 0xFFFFFFFF |
|
PBIX [0x0C] = 0xEA60 |
|
PBIX [0x0D] = 0xEA60 |
|
PBIX [0x0E] = DerefOf (PBIF [0x07]) |
|
PBIX [0x0F] = DerefOf (PBIF [0x08]) |
|
PBIX [0x10] = DerefOf (PBIF [0x09]) |
|
PBIX [0x11] = DerefOf (PBIF [0x0A]) |
|
PBIX [0x12] = DerefOf (PBIF [0x0B]) |
|
PBIX [0x13] = DerefOf (PBIF [0x0C]) |
|
Return (PBIX) /* \_SB_.PCI0.BAT0.PBIX */ |
|
} |
|
|
|
Method (FBST, 4, NotSerialized) |
|
{ |
|
Local1 = (Arg1 & 0xFFFF) |
|
Local0 = Zero |
|
If (^^SBRG.HEC.ACAP ()) |
|
{ |
|
Local0 = One |
|
} |
|
|
|
If (Local0) |
|
{ |
|
If (CHGS (Zero)) |
|
{ |
|
Local0 = 0x02 |
|
} |
|
Else |
|
{ |
|
Local0 = One |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = One |
|
} |
|
|
|
Local2 = (Arg0 & 0x0300) |
|
If (Local2) |
|
{ |
|
Local2 = (One << 0x02) |
|
Local0 |= Local2 |
|
} |
|
|
|
If ((Local1 >= 0x8000)) |
|
{ |
|
Local1 = (0xFFFF - Local1) |
|
} |
|
|
|
Local2 = Arg2 |
|
If ((PUNT == Zero)) |
|
{ |
|
Local1 *= DVOT /* \_SB_.PCI0.BAT0.DVOT */ |
|
Local2 *= 0x0A |
|
} |
|
|
|
Local3 = (Local0 & 0x02) |
|
If (!Local3) |
|
{ |
|
Local3 = (LFCC - Local2) |
|
Divide (LFCC, 0xC8, Local4, Local5) |
|
If ((Local3 < Local5)) |
|
{ |
|
Local2 = LFCC /* \_SB_.PCI0.BAT0.LFCC */ |
|
} |
|
} |
|
Else |
|
{ |
|
Divide (LFCC, 0xC8, Local4, Local5) |
|
Local4 = (LFCC - Local5) |
|
If ((Local2 > Local4)) |
|
{ |
|
Local2 = Local4 |
|
} |
|
} |
|
|
|
If (!^^SBRG.HEC.ACAP ()) |
|
{ |
|
Divide (Local2, MBLF, Local3, Local4) |
|
If ((Local1 < Local4)) |
|
{ |
|
Local1 = Local4 |
|
} |
|
} |
|
|
|
PBST [Zero] = Local0 |
|
PBST [One] = Local1 |
|
PBST [0x02] = Local2 |
|
PBST [0x03] = Arg3 |
|
} |
|
|
|
Method (CBST, 0, NotSerialized) |
|
{ |
|
If (PUNT) |
|
{ |
|
PBST [One] = (DerefOf (PBST [One]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
PBST [0x02] = (DerefOf (PBST [0x02]) * DVOT) /* \_SB_.PCI0.BAT0.DVOT */ |
|
} |
|
} |
|
|
|
Method (_BST, 0, Serialized) // _BST: Battery Status |
|
{ |
|
PBST [Zero] = Zero |
|
PBST [One] = Ones |
|
PBST [0x02] = Ones |
|
PBST [0x03] = Ones |
|
If (!^^SBRG.HEC.BATP (Zero)) |
|
{ |
|
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ |
|
} |
|
|
|
If ((^^SBRG.HEC.GBTT (Zero) == 0xFF)) |
|
{ |
|
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ |
|
} |
|
|
|
If (MES4) |
|
{ |
|
MES4-- |
|
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ |
|
} |
|
|
|
BATS (Zero) |
|
Local0 = ^^SBRG.HEC.BSTS () |
|
Local1 = ^^SBRG.HEC.BCRT () |
|
Local2 = ^^SBRG.HEC.BRCP () |
|
Local3 = ^^SBRG.HEC.BVOT () |
|
BATR () |
|
If ((Local0 != Ones)) |
|
{ |
|
If ((Local1 != Ones)) |
|
{ |
|
If ((Local2 != Ones)) |
|
{ |
|
If ((Local3 != Ones)) |
|
{ |
|
FBST (Local0, Local1, Local2, Local3) |
|
CBST () |
|
} |
|
} |
|
} |
|
} |
|
|
|
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0) |
|
{ |
|
Name (B0CR, Zero) |
|
Name (B1CR, Zero) |
|
Method (GGCC, 1, Serialized) |
|
{ |
|
BATS (Arg0) |
|
Local0 = ^SBRG.HEC.BCRT () |
|
BATR () |
|
If ((Local0 == Ones)) |
|
{ |
|
If (Arg0) |
|
{ |
|
Local0 = B1CR /* \_SB_.PCI0.B1CR */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0CR /* \_SB_.PCI0.B0CR */ |
|
} |
|
} |
|
|
|
Local1 = (Local0 & 0x8000) |
|
If (Local1) |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
If (Arg0) |
|
{ |
|
B1CR = Local0 |
|
} |
|
Else |
|
{ |
|
B0CR = Local0 |
|
} |
|
|
|
Return (Local0) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Name (BADR, 0x0B) |
|
Name (CADR, 0x09) |
|
Name (SADR, 0x0A) |
|
Method (BIF0, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1MD /* \_SB_.PCI0.SBRG.HEC_.B1MD */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0MD /* \_SB_.PCI0.SBRG.HEC_.B0MD */ |
|
} |
|
|
|
If ((Local0 != 0xFFFF)) |
|
{ |
|
Local1 = (Local0 >> 0x0F) |
|
Local1 &= One |
|
Local0 = (Local1 ^ One) |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BIF1, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Local0 = Ones |
|
Return (Local0) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1DC /* \_SB_.PCI0.SBRG.HEC_.B1DC */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0DC /* \_SB_.PCI0.SBRG.HEC_.B0DC */ |
|
} |
|
|
|
Local0 &= 0xFFFF |
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BIF2, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1FC /* \_SB_.PCI0.SBRG.HEC_.B1FC */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0FC /* \_SB_.PCI0.SBRG.HEC_.B0FC */ |
|
} |
|
|
|
Local0 &= 0xFFFF |
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BIF3, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1MD /* \_SB_.PCI0.SBRG.HEC_.B1MD */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0MD /* \_SB_.PCI0.SBRG.HEC_.B0MD */ |
|
} |
|
|
|
If ((Local0 != 0xFFFF)) |
|
{ |
|
Local0 >>= 0x09 |
|
Local0 &= One |
|
Local0 ^= One |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BIF4, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1DV /* \_SB_.PCI0.SBRG.HEC_.B1DV */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0DV /* \_SB_.PCI0.SBRG.HEC_.B0DV */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BIF9, 0, NotSerialized) |
|
{ |
|
Name (BSTR, Buffer (0x20){}) |
|
Local0 = SMBR (RDBL, BADR, 0x21) |
|
If ((DerefOf (Local0 [Zero]) != Zero)) |
|
{ |
|
BSTR = \WMI0.MNAM |
|
BSTR [0x04] = Zero |
|
} |
|
Else |
|
{ |
|
BSTR = DerefOf (Local0 [0x02]) |
|
BSTR [DerefOf (Local0 [One])] = Zero |
|
} |
|
|
|
Return (BSTR) /* \_SB_.PCI0.SBRG.HEC_.BIF9.BSTR */ |
|
} |
|
|
|
Method (BIFA, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1SN /* \_SB_.PCI0.SBRG.HEC_.B1SN */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0SN /* \_SB_.PCI0.SBRG.HEC_.B0SN */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BSTS, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1ST /* \_SB_.PCI0.SBRG.HEC_.B1ST */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0ST /* \_SB_.PCI0.SBRG.HEC_.B0ST */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BCRT, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1CC /* \_SB_.PCI0.SBRG.HEC_.B1CC */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0CC /* \_SB_.PCI0.SBRG.HEC_.B0CC */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BRCP, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1RC /* \_SB_.PCI0.SBRG.HEC_.B1RC */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0RC /* \_SB_.PCI0.SBRG.HEC_.B0RC */ |
|
} |
|
|
|
If ((Local0 == 0xFFFF)) |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (BVOT, 0, Serialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) != Zero)) |
|
{ |
|
Return (Ones) |
|
} |
|
|
|
If (BSLF) |
|
{ |
|
Local0 = B1VL /* \_SB_.PCI0.SBRG.HEC_.B1VL */ |
|
} |
|
Else |
|
{ |
|
Local0 = B0VL /* \_SB_.PCI0.SBRG.HEC_.B0VL */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Method (CHGS, 1, Serialized) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.BCHG (Arg0) |
|
Return (Local0) |
|
} |
|
|
|
Name (BSLF, Zero) |
|
Method (BATS, 1, Serialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
BSLF = One |
|
} |
|
Else |
|
{ |
|
BSLF = Zero |
|
} |
|
} |
|
|
|
Method (BATR, 0, Serialized) |
|
{ |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (_QA1, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
\WMI0.DCPF = DCPS (Zero) |
|
If (\WMI0.DCPF) |
|
{ |
|
Sleep (0x07D0) |
|
} |
|
|
|
Notify (BAT0, 0x80) // Status Change |
|
Notify (BAT0, 0x81) // Information Change |
|
} |
|
|
|
Method (BATP, 1, Serialized) |
|
{ |
|
If (!(RRAM (0x0620) & 0x80)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If (Arg0) |
|
{ |
|
Return (\WMI0.DCP2) |
|
} |
|
Else |
|
{ |
|
Return (\WMI0.DCPF) |
|
} |
|
} |
|
|
|
Method (NBAT, 1, NotSerialized) |
|
{ |
|
If (BATP (Zero)) |
|
{ |
|
Notify (BAT0, Arg0) |
|
} |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Name (MES4, Zero) |
|
Method (OEMS, 1, NotSerialized) |
|
{ |
|
SBRS (Arg0) |
|
\_SB.PCI0.SBRG.HEC.EC0S (Arg0) |
|
\WMI0.SLPN = Arg0 |
|
\WMI0.SLPT = Arg0 |
|
DIAG ((Arg0 + 0xD0)) |
|
If (Arg0) |
|
{ |
|
STRP (One) |
|
} |
|
|
|
PRJS (Arg0) |
|
ISMI (0x9D) |
|
} |
|
|
|
Method (OEMW, 1, NotSerialized) |
|
{ |
|
ISMI (0x9E) |
|
\WMI0.SLPT = Zero |
|
\_SB.PCI0.SBRG.HEC.EC0W (Arg0) |
|
If ((Arg0 == 0x03)){} |
|
SBRW (Arg0) |
|
If ((Arg0 == 0x04)) |
|
{ |
|
Notify (\_SB.SLPB, 0x02) // Device Wake |
|
} |
|
|
|
PRJW (Arg0) |
|
DIAG ((Arg0 + 0xF0)) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (AGFN, 1, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Return (\WMI0.GNBF) |
|
} |
|
|
|
Local0 = AGFB (Arg0) |
|
Local1 = ((Local0 >> 0x10) & 0xFFFF) |
|
Local0 &= 0xFFFF |
|
Local2 = GLEN (Arg0) |
|
If ((Local0 == One)) |
|
{ |
|
GVER (Arg0, Local2) |
|
STAS &= 0xFE |
|
} |
|
|
|
If ((Local0 == 0x02)) |
|
{ |
|
BSMI (Arg0) |
|
STAS &= 0xFE |
|
} |
|
|
|
AGLN (Arg0, Local0, Local1, Local2) |
|
OperationRegion (\PARM, SystemMemory, Arg0, 0x08) |
|
Field (PARM, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
STAS, 8, |
|
EROR, 8 |
|
} |
|
|
|
If ((STAS == One)) |
|
{ |
|
EROR = One |
|
STAS |= 0x02 |
|
} |
|
|
|
STAS &= 0xFE |
|
STAS |= 0x80 |
|
Return (Zero) |
|
} |
|
|
|
Method (AGFB, 1, NotSerialized) |
|
{ |
|
OperationRegion (\PAR, SystemMemory, Arg0, 0x08) |
|
Field (PAR, DWordAcc, NoLock, Preserve) |
|
{ |
|
FUNC, 32, |
|
Offset (0x06), |
|
STAS, 8, |
|
EROR, 8 |
|
} |
|
|
|
EROR = Zero |
|
STAS = One |
|
Return (FUNC) /* \_SB_.ATKD.AGFB.FUNC */ |
|
} |
|
|
|
Method (GLEN, 1, NotSerialized) |
|
{ |
|
OperationRegion (\PARL, SystemMemory, Arg0, 0x08) |
|
Field (PARL, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x04), |
|
LEN, 16 |
|
} |
|
|
|
Return (LEN) /* \_SB_.ATKD.GLEN.LEN_ */ |
|
} |
|
|
|
Method (GVER, 2, NotSerialized) |
|
{ |
|
OperationRegion (\FGVR, SystemMemory, Arg0, Arg1) |
|
Field (FGVR, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
APID, 16, |
|
APRV, 32 |
|
} |
|
|
|
If ((Arg1 < 0x0E)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
If ((APID & One)) |
|
{ |
|
^^PCI0.SBRG.HEC.PKEN (One) |
|
} |
|
Else |
|
{ |
|
^^PCI0.SBRG.HEC.PKEN (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (GENS, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (GENW, 1, NotSerialized) |
|
{ |
|
\WMI0.RTCW = Zero |
|
} |
|
|
|
Method (BSMI, 1, Serialized) |
|
{ |
|
\WMI0.BIPA = Arg0 |
|
ISMI (0xA1) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (MF1X, 4, NotSerialized) |
|
{ |
|
If (((Arg1 & 0xF0) != 0x10)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
OperationRegion (FM1X, SystemMemory, Arg0, 0x08) |
|
Field (FM1X, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM1X, 8, |
|
EM1X, 8 |
|
} |
|
|
|
Local0 = One |
|
If ((Arg1 == 0x10)) |
|
{ |
|
Local0 = MF10 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x11)) |
|
{ |
|
Local0 = MF11 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x12)) |
|
{ |
|
Local0 = MF12 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x13)) |
|
{ |
|
Local0 = MF13 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x14)) |
|
{ |
|
Local0 = MF14 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x15)) |
|
{ |
|
Local0 = MF15 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x16)) |
|
{ |
|
Local0 = MF16 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x17)) |
|
{ |
|
Local0 = MF17 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x18)) |
|
{ |
|
Local0 = MF18 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x19)) |
|
{ |
|
Local0 = MF19 (Arg0, Arg3, Arg2) |
|
} |
|
|
|
If ((Arg1 == 0x1A)) |
|
{ |
|
Local0 = MF1A (Arg0, Arg3, Arg2) |
|
} |
|
|
|
SM1X &= 0xFE |
|
If (Local0) |
|
{ |
|
EM1X = Local0 |
|
SM1X |= 0x02 |
|
} |
|
|
|
SM1X |= 0x80 |
|
Return (Zero) |
|
} |
|
|
|
Method (MF10, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G10V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = SRTC (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G10V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F100, SystemMemory, Arg0, Arg1) |
|
Field (F100, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (SRTC, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F101, SystemMemory, Arg0, Arg1) |
|
Field (F101, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
DLTM, 16 |
|
} |
|
|
|
\WMI0.RTCW = DLTM /* \_SB_.ATKD.SRTC.DLTM */ |
|
Return (Zero) |
|
} |
|
|
|
Method (MF11, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G11V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GBAT (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = ASBR (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = ASBE (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x04)) |
|
{ |
|
Local0 = BTCR (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x80)) |
|
{ |
|
Local0 = GTSB (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x81)) |
|
{ |
|
Local0 = GPST (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x82)) |
|
{ |
|
Local0 = SBSM (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G11V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F110, SystemMemory, Arg0, Arg1) |
|
Field (F110, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GBAT, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F111, SystemMemory, Arg0, Arg1) |
|
Field (F111, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BTNM, 8, |
|
BTTP, 8 |
|
} |
|
|
|
BTNM = One |
|
BTTP = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (ASBR, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x30)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F112, SystemMemory, Arg0, Arg1) |
|
Field (F112, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BATN, 8, |
|
BATA, 8, |
|
REGS, 8, |
|
BDAT, 16, |
|
BLEN, 8, |
|
BREV, 16, |
|
BLK1, 32, |
|
BLK2, 32, |
|
BLK3, 32, |
|
BLK4, 32, |
|
BLK5, 32, |
|
BLK6, 32, |
|
BLK7, 32, |
|
BLK8, 32 |
|
} |
|
|
|
If ((BATN >= One)) |
|
{ |
|
Return (0x11) |
|
} |
|
|
|
If ((BATA == Zero)) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.SMBR (^^PCI0.SBRG.HEC.RDWD, ^^PCI0.SBRG.HEC.BADR, REGS) |
|
BDAT = DerefOf (Local0 [0x02]) |
|
Local2 = DerefOf (Local0 [Zero]) |
|
Local2 &= 0x1F |
|
If (Local2) |
|
{ |
|
Local2 += 0x10 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
If ((BATA == One)) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.SMBW (^^PCI0.SBRG.HEC.WRWD, ^^PCI0.SBRG.HEC.BADR, REGS, 0x02, BDAT) |
|
Local2 = DerefOf (Local0 [Zero]) |
|
Local2 &= 0x1F |
|
If (Local2) |
|
{ |
|
Local2 += 0x10 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
If ((BATA == 0x02)) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.SMBR (^^PCI0.SBRG.HEC.RDBL, ^^PCI0.SBRG.HEC.BADR, REGS) |
|
BKUF = DerefOf (Local0 [0x02]) |
|
BLEN = DerefOf (Local0 [One]) |
|
Local2 = DerefOf (Local0 [Zero]) |
|
Name (BKUF, Buffer (0x20){}) |
|
CreateDWordField (BKUF, Zero, DAT1) |
|
CreateDWordField (BKUF, 0x04, DAT2) |
|
CreateDWordField (BKUF, 0x08, DAT3) |
|
CreateDWordField (BKUF, 0x0C, DAT4) |
|
CreateDWordField (BKUF, 0x10, DAT5) |
|
CreateDWordField (BKUF, 0x14, DAT6) |
|
CreateDWordField (BKUF, 0x18, DAT7) |
|
CreateDWordField (BKUF, 0x1C, DAT8) |
|
BLK1 = DAT1 /* \_SB_.ATKD.ASBR.DAT1 */ |
|
BLK2 = DAT2 /* \_SB_.ATKD.ASBR.DAT2 */ |
|
BLK3 = DAT3 /* \_SB_.ATKD.ASBR.DAT3 */ |
|
BLK4 = DAT4 /* \_SB_.ATKD.ASBR.DAT4 */ |
|
BLK5 = DAT5 /* \_SB_.ATKD.ASBR.DAT5 */ |
|
BLK6 = DAT6 /* \_SB_.ATKD.ASBR.DAT6 */ |
|
BLK7 = DAT7 /* \_SB_.ATKD.ASBR.DAT7 */ |
|
BLK8 = DAT8 /* \_SB_.ATKD.ASBR.DAT8 */ |
|
Local2 &= 0x1F |
|
If (Local2) |
|
{ |
|
Local2 += 0x10 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
Return (0x10) |
|
} |
|
|
|
Method (ASBE, 2, Serialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F113, SystemMemory, Arg0, Arg1) |
|
Field (F113, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BATN, 8, |
|
BATA, 8, |
|
REGS, 8, |
|
BDAT, 8 |
|
} |
|
|
|
If ((BATN > One)) |
|
{ |
|
Return (0x11) |
|
} |
|
|
|
If ((BATA == Zero)) |
|
{ |
|
Local2 = ^^PCI0.SBRG.HEC.RBEP (REGS) |
|
Local3 = (Local2 & 0xFF) |
|
BDAT = Local3 |
|
Local2 >>= 0x08 |
|
Local2 &= 0x1F |
|
If (Local2) |
|
{ |
|
Local2 += 0x10 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
If ((BATA == One)) |
|
{ |
|
Local2 = ^^PCI0.SBRG.HEC.WBEP (REGS, BDAT) |
|
Local2 &= 0x1F |
|
If (Local2) |
|
{ |
|
Local2 += 0x10 |
|
} |
|
|
|
Return (Local2) |
|
} |
|
|
|
Return (0x10) |
|
} |
|
|
|
Method (BTCR, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x09)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F114, SystemMemory, Arg0, Arg1) |
|
Field (F114, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BCDC, 8 |
|
} |
|
|
|
SBTL (BCDC) |
|
Return (Zero) |
|
} |
|
|
|
Method (GTSB, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0F)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F118, SystemMemory, Arg0, Arg1) |
|
Field (F118, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BAST, 16 |
|
} |
|
|
|
Local0 = ^^PCI0.SBRG.HEC.SMBR (^^PCI0.SBRG.HEC.RDWD, ^^PCI0.SBRG.HEC.BADR, 0x16) |
|
BAST = DerefOf (Local0 [0x02]) |
|
Local1 = DerefOf (Local0 [Zero]) |
|
Local1 &= 0x1F |
|
If (Local1) |
|
{ |
|
Local1 += 0x10 |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Method (GPST, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0F)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F119, SystemMemory, Arg0, Arg1) |
|
Field (F119, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SORC, 8, |
|
GPCT, 8 |
|
} |
|
|
|
If (((SORC == Zero) | (SORC > 0x03))) |
|
{ |
|
Return (One) |
|
} |
|
|
|
If ((SORC == One)) |
|
{ |
|
GPCT = ^^PCI0.SBRG.HEC.RPIN (0x02, 0x04) |
|
} |
|
ElseIf ((SORC == 0x02)) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RPIN (0x02, 0x06) |
|
If (Local0) |
|
{ |
|
GPCT = Zero |
|
} |
|
Else |
|
{ |
|
GPCT = One |
|
} |
|
} |
|
ElseIf ((SORC == 0x03)) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RPIN (0x04, 0x06) |
|
If (Local0) |
|
{ |
|
GPCT = Zero |
|
} |
|
Else |
|
{ |
|
GPCT = One |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (SBSM, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x10)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F1A3, SystemMemory, Arg0, Arg1) |
|
Field (F1A3, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
EABL, 8 |
|
} |
|
|
|
If ((EABL == One)) |
|
{ |
|
PRJB () |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (MF12, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G12V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GLDI (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = LDCR (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G12V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F120, SystemMemory, Arg0, Arg1) |
|
Field (F120, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GLDI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x10)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F121, SystemMemory, Arg0, Arg1) |
|
Field (F121, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
LDI0, 32, |
|
LDI1, 32 |
|
} |
|
|
|
Local0 = Zero |
|
Local0 |= 0x10 |
|
Local0 |= 0x20 |
|
LDI0 = Local0 |
|
Return (Zero) |
|
} |
|
|
|
Method (LDCR, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0B)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F122, SystemMemory, Arg0, Arg1) |
|
Field (F122, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
LDNM, 8, |
|
LCRT, 8 |
|
} |
|
|
|
If ((LDNM == 0x04)) |
|
{ |
|
WLED (LCRT) |
|
Return (Zero) |
|
} |
|
|
|
Return (0x10) |
|
} |
|
|
|
Method (MF13, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G13V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GTSI (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = GTSV (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = GVSN (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x04)) |
|
{ |
|
Local0 = GVSV (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x05)) |
|
{ |
|
Local0 = GFNN (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x06)) |
|
{ |
|
Local0 = GFNS (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x07)) |
|
{ |
|
Local0 = SFNS (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G13V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F130, SystemMemory, Arg0, Arg1) |
|
Field (F130, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GTSI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F131, SystemMemory, Arg0, Arg1) |
|
Field (F131, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
THRI, 32 |
|
} |
|
|
|
Local0 = Zero |
|
Local0 |= One |
|
If ((\WMI0.CPUN >= One)) |
|
{ |
|
Local0 |= 0x0100 |
|
} |
|
|
|
If ((\WMI0.CPUN >= 0x02)) |
|
{ |
|
Local0 |= 0x0200 |
|
} |
|
|
|
If ((\WMI0.CPUN >= 0x03)) |
|
{ |
|
Local0 |= 0x0400 |
|
} |
|
|
|
If ((\WMI0.CPUN >= 0x04)) |
|
{ |
|
Local0 |= 0x0800 |
|
} |
|
|
|
THRI = Local0 |
|
Return (Zero) |
|
} |
|
|
|
Method (GTSV, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F132, SystemMemory, Arg0, Arg1) |
|
Field (F132, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
TSNM, 8, |
|
TSVL, 8, |
|
TSST, 8 |
|
} |
|
|
|
TSST = Zero |
|
If ((TSNM == Zero)) |
|
{ |
|
TSVL = \_TZ.RTMP () |
|
Return (Zero) |
|
} |
|
|
|
If ((TSNM == 0x08)) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
If ((TSNM == 0x09)) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
If ((TSNM == 0x0A)) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
If ((TSNM == 0x0B)) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Return (0x10) |
|
} |
|
|
|
Method (GVSN, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x09)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F133, SystemMemory, Arg0, Arg1) |
|
Field (F133, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
NMVS, 8 |
|
} |
|
|
|
NMVS = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GVSV, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0B)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F134, SystemMemory, Arg0, Arg1) |
|
Field (F134, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
VSNM, 8, |
|
VSVL, 16 |
|
} |
|
|
|
If ((VSNM > Zero)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (GFNN, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x09)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F135, SystemMemory, Arg0, Arg1) |
|
Field (F135, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
NMFN, 32 |
|
} |
|
|
|
NMFN = One |
|
Return (Zero) |
|
} |
|
|
|
Method (GFNS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0D)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F136, SystemMemory, Arg0, Arg1) |
|
Field (F136, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
FNNM, 8, |
|
GFNS, 32 |
|
} |
|
|
|
If (((FNNM == Zero) | (FNNM > One))) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
Local0 = FNNM /* \_SB_.ATKD.GFNS.FNNM */ |
|
GFNS = \_TZ.RFAN (Local0--) |
|
Return (Zero) |
|
} |
|
|
|
Method (SFNS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F137, SystemMemory, Arg0, Arg1) |
|
Field (F137, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
FNNB, 8, |
|
FNSP, 8 |
|
} |
|
|
|
If ((FNNB > One)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
^^PCI0.SBRG.HEC.SFNV (FNNB, FNSP) |
|
Return (Zero) |
|
} |
|
|
|
Method (MF14, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G14V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GNBT (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = GBTS (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G14V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F140, SystemMemory, Arg0, Arg1) |
|
Field (F140, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GNBT, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x09)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F141, SystemMemory, Arg0, Arg1) |
|
Field (F141, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
NBBT, 8 |
|
} |
|
|
|
NBBT = 0x05 |
|
Return (Zero) |
|
} |
|
|
|
Method (GBTS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F142, SystemMemory, Arg0, Arg1) |
|
Field (F142, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BTNM, 8, |
|
BTST, 8 |
|
} |
|
|
|
Name (BTTB, Package (0x05) |
|
{ |
|
Package (0x04) |
|
{ |
|
Zero, |
|
0x0C, |
|
Zero, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
Zero, |
|
0x0D, |
|
Zero, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
Zero, |
|
0x0E, |
|
Zero, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
Zero, |
|
0x0F, |
|
Zero, |
|
Zero |
|
}, |
|
|
|
Package (0x04) |
|
{ |
|
Zero, |
|
0x15, |
|
Zero, |
|
Zero |
|
} |
|
}) |
|
If ((BTNM > 0x05)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
Local0 = BTNM /* \_SB_.ATKD.GBTS.BTNM */ |
|
Local0-- |
|
Local1 = DerefOf (BTTB [Local0]) |
|
If ((DerefOf (Local1 [0x02]) == Zero)) |
|
{ |
|
Local2 = ^^PCI0.SBRG.HEC.RPIN (DerefOf (Local1 [Zero]), DerefOf (Local1 [One] |
|
)) |
|
} |
|
|
|
If ((DerefOf (Local1 [One]) == One)) |
|
{ |
|
Local2 = RGPL (DerefOf (Local1 [Zero]), One) |
|
} |
|
|
|
If ((DerefOf (Local1 [One]) == 0x03)){} |
|
If ((DerefOf (Local1 [0x02]) == Local2)) |
|
{ |
|
BTST = Zero |
|
} |
|
Else |
|
{ |
|
BTST = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (MF15, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G15V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GLDB (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = SLDB (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = GDPI (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x04)) |
|
{ |
|
Local0 = SODP (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G15V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F150, SystemMemory, Arg0, Arg1) |
|
Field (F150, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GLDB, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F151, SystemMemory, Arg0, Arg1) |
|
Field (F151, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
LCDB, 8, |
|
MLDB, 8 |
|
} |
|
|
|
LCDB = GPLV () |
|
MLDB = 0x0A |
|
Return (Zero) |
|
} |
|
|
|
Method (SLDB, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F152, SystemMemory, Arg0, Arg1) |
|
Field (F152, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
LCDL, 8, |
|
LTPE, 8 |
|
} |
|
|
|
If ((LTPE == Zero)) |
|
{ |
|
If ((LCDL >= 0x0B)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
SPLV (LCDL) |
|
Return (Zero) |
|
} |
|
|
|
If ((LTPE == One)) |
|
{ |
|
^^PCI0.SBRG.HEC.SBRV (LCDL) |
|
Return (Zero) |
|
} |
|
|
|
Return (0x11) |
|
} |
|
|
|
Method (GDPI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x10)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F153, SystemMemory, Arg0, Arg1) |
|
Field (F153, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
ODPI, 32, |
|
ODPC, 32, |
|
ODAV, 32 |
|
} |
|
|
|
Local0 = Zero |
|
Local0 |= One |
|
Local0 |= 0x02 |
|
Local0 |= 0x08 |
|
Local0 |= 0x10 |
|
ODPI = Local0 |
|
If (^^PCI0.VGA.PRST ()) |
|
{ |
|
^^PCI0.VGA.GETD () |
|
Local0 = \WMI0.ACTD |
|
ODAV = ^^PCI0.VGA.MD2A (Local0) |
|
Local1 = \WMI0.AVLD |
|
ODPC = ^^PCI0.VGA.MD2A (Local1) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (SODP, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F154, SystemMemory, Arg0, Arg1) |
|
Field (F154, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
ODPM, 32 |
|
} |
|
|
|
Local0 = Zero |
|
Local0 |= One |
|
Local0 |= 0x02 |
|
Local0 |= 0x08 |
|
Local0 |= 0x10 |
|
Local0 &= ODPM |
|
If ((Local0 == ODPM)) |
|
{ |
|
SDSP (ODPM) |
|
Return (Zero) |
|
} |
|
|
|
Return (0x10) |
|
} |
|
|
|
Method (MF16, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G16V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = LCMD (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = BSFN (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x04)) |
|
{ |
|
Local0 = PSSF (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G16V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F160, SystemMemory, Arg0, Arg1) |
|
Field (F160, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (SFBD, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F161, SystemMemory, Arg0, Arg1) |
|
Field (F161, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
NXBD, 8 |
|
} |
|
|
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Method (LCMD, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
BSMI (Arg0) |
|
\WMI0.FRPN = 0xAA55 |
|
Return (Zero) |
|
} |
|
|
|
Method (BSFN, 2, NotSerialized) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Method (PSSF, 2, NotSerialized) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Method (MF17, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G17V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GMDL (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = GBSI (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = GECI (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G17V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F170, SystemMemory, Arg0, Arg1) |
|
Field (F170, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GMDL, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x19)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F171, SystemMemory, Arg0, Arg1) |
|
Field (F171, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
MLEN, 8, |
|
MDL1, 32, |
|
MDL2, 32, |
|
MDL3, 32, |
|
MDL4, 32 |
|
} |
|
|
|
MDL1 = Zero |
|
MDL2 = Zero |
|
MDL3 = Zero |
|
MDL4 = Zero |
|
Name (BBUF, Buffer (0x10){}) |
|
CreateDWordField (BBUF, Zero, DAT1) |
|
CreateDWordField (BBUF, 0x04, DAT2) |
|
CreateDWordField (BBUF, 0x08, DAT3) |
|
CreateDWordField (BBUF, 0x0C, DAT4) |
|
Local0 = GBMN () |
|
MLEN = SizeOf (Local0) |
|
BBUF = GBMN () |
|
MDL1 = DAT1 /* \_SB_.ATKD.GMDL.DAT1 */ |
|
MDL2 = DAT2 /* \_SB_.ATKD.GMDL.DAT2 */ |
|
MDL3 = DAT3 /* \_SB_.ATKD.GMDL.DAT3 */ |
|
MDL4 = DAT4 /* \_SB_.ATKD.GMDL.DAT4 */ |
|
Return (Zero) |
|
} |
|
|
|
Method (GBSI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x19)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F172, SystemMemory, Arg0, Arg1) |
|
Field (F172, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BLEN, 8, |
|
BDL1, 32, |
|
BDL2, 32, |
|
BDL3, 32, |
|
BDL4, 24, |
|
YEAR, 32, |
|
MON, 16, |
|
DAY, 16 |
|
} |
|
|
|
BDL1 = Zero |
|
BDL2 = Zero |
|
BDL3 = Zero |
|
BDL4 = Zero |
|
Name (BBUF, Buffer (0x10){}) |
|
CreateDWordField (BBUF, Zero, DAT1) |
|
CreateDWordField (BBUF, 0x04, DAT2) |
|
CreateDWordField (BBUF, 0x08, DAT3) |
|
CreateDWordField (BBUF, 0x0C, DAT4) |
|
Local0 = GBRV () |
|
BLEN = SizeOf (Local0) |
|
BBUF = GBRV () |
|
BDL1 = DAT1 /* \_SB_.ATKD.GBSI.DAT1 */ |
|
BDL2 = DAT2 /* \_SB_.ATKD.GBSI.DAT2 */ |
|
BDL3 = DAT3 /* \_SB_.ATKD.GBSI.DAT3 */ |
|
BDL4 = DAT4 /* \_SB_.ATKD.GBSI.DAT4 */ |
|
CreateWordField (BBUF, Zero, WRD0) |
|
BBUF = "2013" |
|
YEAR = DAT1 /* \_SB_.ATKD.GBSI.DAT1 */ |
|
BBUF = "04" |
|
MON = WRD0 /* \_SB_.ATKD.GBSI.WRD0 */ |
|
BBUF = "15" |
|
DAY = WRD0 /* \_SB_.ATKD.GBSI.WRD0 */ |
|
Return (Zero) |
|
} |
|
|
|
Method (GECI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x19)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F173, SystemMemory, Arg0, Arg1) |
|
Field (F173, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
ELEN, 8, |
|
EDL1, 32, |
|
EDL2, 32, |
|
EDL3, 32, |
|
EDL4, 32 |
|
} |
|
|
|
EDL1 = Zero |
|
EDL2 = Zero |
|
EDL3 = Zero |
|
EDL4 = Zero |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Method (MF18, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G18V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GDVI (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = GDVS (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = SDPW (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G18V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F180, SystemMemory, Arg0, Arg1) |
|
Field (F180, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GDVI, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x18)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F181, SystemMemory, Arg0, Arg1) |
|
Field (F181, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
LDI0, 32, |
|
LDI1, 32 |
|
} |
|
|
|
LDI0 = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GDVS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F182, SystemMemory, Arg0, Arg1) |
|
Field (F182, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
DNUM, 8, |
|
DSTS, 8 |
|
} |
|
|
|
Local0 = (One << DNUM) /* \_SB_.ATKD.GDVS.DNUM */ |
|
If (((Local0 & Zero) == Zero)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (SDPW, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F183, SystemMemory, Arg0, Arg1) |
|
Field (F183, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
DNUM, 8, |
|
DCTR, 8 |
|
} |
|
|
|
Local0 = (One << DNUM) /* \_SB_.ATKD.SDPW.DNUM */ |
|
If (((Local0 & Zero) == Zero)) |
|
{ |
|
Return (0x10) |
|
} |
|
|
|
If ((DCTR > One)) |
|
{ |
|
Return (0x11) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (MF19, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G19V (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = ACMS (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = CSIN (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G19V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F190, SystemMemory, Arg0, Arg1) |
|
Field (F190, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (ACMS, 2, NotSerialized) |
|
{ |
|
BSMI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Method (CSIN, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F192, SystemMemory, Arg0, Arg1) |
|
Field (F192, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
CMAX, 16 |
|
} |
|
|
|
CMAX = 0xFF |
|
Return (Zero) |
|
} |
|
|
|
Method (MF1A, 3, NotSerialized) |
|
{ |
|
Local0 = One |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G1AV (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = GWDS (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = SWDS (Arg0, Arg1) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (G1AV, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F1A0, SystemMemory, Arg0, Arg1) |
|
Field (F1A0, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (GWDS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x10)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F1A1, SystemMemory, Arg0, Arg1) |
|
Field (F1A1, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
WDS0, 32, |
|
WDS1, 32 |
|
} |
|
|
|
Local0 = Zero |
|
Local1 = Zero |
|
Local2 = Zero |
|
If (^^PCI0.PE21.WLAN.MPDP ()) |
|
{ |
|
Local0 |= 0x04 |
|
} |
|
|
|
Local1 = RGPL (0x35, One) |
|
If (Local1) |
|
{ |
|
Local0 |= 0x08 |
|
} |
|
Else |
|
{ |
|
Local0 &= 0xFFF7 |
|
} |
|
|
|
If (\WMI0.BTDP) |
|
{ |
|
Local0 |= 0x10 |
|
} |
|
|
|
Local1 = RGPL (0xD2, One) |
|
If (Local1) |
|
{ |
|
Local0 |= 0x20 |
|
} |
|
Else |
|
{ |
|
Local0 &= 0xFFDF |
|
} |
|
|
|
If (\WMI0.WWDP) |
|
{ |
|
Local0 |= 0x40 |
|
} |
|
|
|
If (\WMI0.WMDP) |
|
{ |
|
Local0 |= 0x0100 |
|
} |
|
|
|
WDS0 = Local0 |
|
Return (Zero) |
|
} |
|
|
|
Method (SWDS, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F1A2, SystemMemory, Arg0, Arg1) |
|
Field (F1A2, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SWD0, 8, |
|
SWD1, 8 |
|
} |
|
|
|
Local0 = SWD0 /* \_SB_.ATKD.SWDS.SWD0 */ |
|
Local1 = (Local0 & One) |
|
Local1 >>= Zero |
|
OWLD (Local1) |
|
Local1 = (Local0 & 0x02) |
|
Local1 >>= One |
|
OBTD (Local1) |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (AGLN, 4, NotSerialized) |
|
{ |
|
CPUX (Arg0, Arg1, Arg2, Arg3) |
|
MF1X (Arg0, Arg1, Arg2, Arg3) |
|
^^PCI0.SBRG.HEC.MF63 (Arg0, Arg1, Arg2, Arg3) |
|
^^PCI0.SBRG.HEC.MF30 (Arg0, Arg1, Arg2, Arg3) |
|
MF42 (Arg0, Arg1, Arg2, Arg3) |
|
MF1F (Arg0, Arg1, Arg2, Arg3) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (GBRV, 0, NotSerialized) |
|
{ |
|
Local0 = "204" |
|
Return (Local0) |
|
} |
|
|
|
Method (GBMN, 0, NotSerialized) |
|
{ |
|
Local0 = "X550DP" |
|
Return (Local0) |
|
} |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Name (_WDG, Buffer (0x01B8) |
|
{ |
|
/* 0000 */ 0x00, 0x24, 0x14, 0x39, 0xA3, 0xC6, 0xFA, 0x40, // .$.9...@ |
|
/* 0008 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0010 */ 0x30, 0x30, 0x01, 0x01, 0x00, 0x24, 0x14, 0x49, // 00...$.I |
|
/* 0018 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0020 */ 0x52, 0x83, 0x41, 0x00, 0x30, 0x31, 0x01, 0x01, // R.A.01.. |
|
/* 0028 */ 0x00, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 0030 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0038 */ 0x30, 0x32, 0x01, 0x01, 0x01, 0x24, 0x14, 0x49, // 02...$.I |
|
/* 0040 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0048 */ 0x52, 0x83, 0x41, 0x00, 0x31, 0x31, 0x01, 0x01, // R.A.11.. |
|
/* 0050 */ 0x01, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 0058 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0060 */ 0x31, 0x32, 0x01, 0x01, 0x02, 0x24, 0x14, 0x49, // 12...$.I |
|
/* 0068 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0070 */ 0x52, 0x83, 0x41, 0x00, 0x32, 0x31, 0x01, 0x01, // R.A.21.. |
|
/* 0078 */ 0x02, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 0080 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0088 */ 0x32, 0x32, 0x01, 0x01, 0x03, 0x24, 0x14, 0x49, // 22...$.I |
|
/* 0090 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0098 */ 0x52, 0x83, 0x41, 0x00, 0x33, 0x31, 0x01, 0x01, // R.A.31.. |
|
/* 00A0 */ 0x03, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 00A8 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 00B0 */ 0x33, 0x32, 0x01, 0x01, 0x04, 0x24, 0x14, 0x49, // 32...$.I |
|
/* 00B8 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 00C0 */ 0x52, 0x83, 0x41, 0x00, 0x34, 0x31, 0x01, 0x01, // R.A.41.. |
|
/* 00C8 */ 0x04, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 00D0 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 00D8 */ 0x34, 0x32, 0x01, 0x01, 0x05, 0x24, 0x14, 0x49, // 42...$.I |
|
/* 00E0 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 00E8 */ 0x52, 0x83, 0x41, 0x00, 0x35, 0x31, 0x01, 0x01, // R.A.51.. |
|
/* 00F0 */ 0x05, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 00F8 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0100 */ 0x35, 0x32, 0x01, 0x01, 0x06, 0x24, 0x14, 0x49, // 52...$.I |
|
/* 0108 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0110 */ 0x52, 0x83, 0x41, 0x00, 0x36, 0x31, 0x01, 0x01, // R.A.61.. |
|
/* 0118 */ 0x06, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 0120 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0128 */ 0x36, 0x32, 0x01, 0x01, 0x07, 0x24, 0x14, 0x49, // 62...$.I |
|
/* 0130 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0138 */ 0x52, 0x83, 0x41, 0x00, 0x37, 0x31, 0x01, 0x01, // R.A.71.. |
|
/* 0140 */ 0x07, 0x24, 0x14, 0x4A, 0xA3, 0xC6, 0xFA, 0x40, // .$.J...@ |
|
/* 0148 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0150 */ 0x37, 0x32, 0x01, 0x01, 0x00, 0x24, 0x14, 0x59, // 72...$.Y |
|
/* 0158 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0160 */ 0x52, 0x83, 0x41, 0x00, 0x80, 0x00, 0x01, 0x08, // R.A..... |
|
/* 0168 */ 0x00, 0x24, 0x14, 0x69, 0xA3, 0xC6, 0xFA, 0x40, // .$.i...@ |
|
/* 0170 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 0178 */ 0x30, 0x35, 0x01, 0x02, 0x00, 0x24, 0x14, 0x79, // 05...$.y |
|
/* 0180 */ 0xA3, 0xC6, 0xFA, 0x40, 0xBA, 0xDB, 0x8A, 0x26, // ...@...& |
|
/* 0188 */ 0x52, 0x83, 0x41, 0x00, 0x30, 0x36, 0x01, 0x02, // R.A.06.. |
|
/* 0190 */ 0x00, 0x24, 0x14, 0x89, 0xA3, 0xC6, 0xFA, 0x40, // .$.....@ |
|
/* 0198 */ 0xBA, 0xDB, 0x8A, 0x26, 0x52, 0x83, 0x41, 0x00, // ...&R.A. |
|
/* 01A0 */ 0x30, 0x37, 0x01, 0x02, 0x21, 0x12, 0x90, 0x05, // 07..!... |
|
/* 01A8 */ 0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, // f....... |
|
/* 01B0 */ 0xC9, 0x06, 0x29, 0x10, 0x42, 0x41, 0x01, 0x01 // ..).BA.. |
|
}) |
|
Name (EVCD, Zero) |
|
Method (WQ00, 1, NotSerialized) |
|
{ |
|
Return (EVCD) /* \WMI0.EVCD */ |
|
} |
|
|
|
OperationRegion (\WMIA, SystemMemory, WMIB, 0x9000) |
|
Field (WMIA, AnyAcc, NoLock, Preserve) |
|
{ |
|
WAG1, 2048, |
|
WAG2, 2048, |
|
WAG3, 2048, |
|
WAG4, 2048, |
|
WAG5, 2048, |
|
WAG6, 2048, |
|
WAG7, 2048, |
|
WAG8, 2048, |
|
Offset (0x1000), |
|
WPD1, 32768, |
|
WPD2, 32768, |
|
WPD3, 32768, |
|
WPD4, 32768, |
|
WPD5, 32768, |
|
WPD6, 32768, |
|
WPD7, 32768, |
|
WPD8, 32768 |
|
} |
|
|
|
Method (WQ01, 1, NotSerialized) |
|
{ |
|
Return (WAG1) /* \WMI0.WAG1 */ |
|
} |
|
|
|
Method (WS01, 2, NotSerialized) |
|
{ |
|
WAG1 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ02, 1, NotSerialized) |
|
{ |
|
Return (WPD1) /* \WMI0.WPD1 */ |
|
} |
|
|
|
Method (WS02, 2, NotSerialized) |
|
{ |
|
WPD1 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ11, 1, NotSerialized) |
|
{ |
|
Return (WAG2) /* \WMI0.WAG2 */ |
|
} |
|
|
|
Method (WS11, 2, NotSerialized) |
|
{ |
|
WAG2 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ12, 1, NotSerialized) |
|
{ |
|
Return (WPD2) /* \WMI0.WPD2 */ |
|
} |
|
|
|
Method (WS12, 2, NotSerialized) |
|
{ |
|
WPD2 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ21, 1, NotSerialized) |
|
{ |
|
Return (WAG3) /* \WMI0.WAG3 */ |
|
} |
|
|
|
Method (WS21, 2, NotSerialized) |
|
{ |
|
WAG3 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ22, 1, NotSerialized) |
|
{ |
|
Return (WPD3) /* \WMI0.WPD3 */ |
|
} |
|
|
|
Method (WS22, 2, NotSerialized) |
|
{ |
|
WPD3 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ31, 1, NotSerialized) |
|
{ |
|
Return (WAG4) /* \WMI0.WAG4 */ |
|
} |
|
|
|
Method (WS31, 2, NotSerialized) |
|
{ |
|
WAG4 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ32, 1, NotSerialized) |
|
{ |
|
Return (WPD4) /* \WMI0.WPD4 */ |
|
} |
|
|
|
Method (WS32, 2, NotSerialized) |
|
{ |
|
WPD4 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ41, 1, NotSerialized) |
|
{ |
|
Return (WAG5) /* \WMI0.WAG5 */ |
|
} |
|
|
|
Method (WS41, 2, NotSerialized) |
|
{ |
|
WAG5 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ42, 1, NotSerialized) |
|
{ |
|
Return (WPD5) /* \WMI0.WPD5 */ |
|
} |
|
|
|
Method (WS42, 2, NotSerialized) |
|
{ |
|
WPD5 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ51, 1, NotSerialized) |
|
{ |
|
Return (WAG6) /* \WMI0.WAG6 */ |
|
} |
|
|
|
Method (WS51, 2, NotSerialized) |
|
{ |
|
WAG6 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ52, 1, NotSerialized) |
|
{ |
|
Return (WPD6) /* \WMI0.WPD6 */ |
|
} |
|
|
|
Method (WS52, 2, NotSerialized) |
|
{ |
|
WPD6 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ61, 1, NotSerialized) |
|
{ |
|
Return (WAG7) /* \WMI0.WAG7 */ |
|
} |
|
|
|
Method (WS61, 2, NotSerialized) |
|
{ |
|
WAG7 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ62, 1, NotSerialized) |
|
{ |
|
Return (WPD7) /* \WMI0.WPD7 */ |
|
} |
|
|
|
Method (WS62, 2, NotSerialized) |
|
{ |
|
WPD7 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ71, 1, NotSerialized) |
|
{ |
|
Return (WAG8) /* \WMI0.WAG8 */ |
|
} |
|
|
|
Method (WS71, 2, NotSerialized) |
|
{ |
|
WAG8 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WQ72, 1, NotSerialized) |
|
{ |
|
Return (WPD8) /* \WMI0.WPD8 */ |
|
} |
|
|
|
Method (WS72, 2, NotSerialized) |
|
{ |
|
WPD8 = Arg1 |
|
Return (Zero) |
|
} |
|
|
|
Method (WM05, 3, NotSerialized) |
|
{ |
|
CreateDWordField (Arg2, Zero, WMA5) |
|
If ((WMA5 == One)) |
|
{ |
|
WMIG (WMIB, (WMIB + 0x1000), One) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x02)) |
|
{ |
|
WMIG ((WMIB + 0x0100), (WMIB + 0x2000), 0x02) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x03)) |
|
{ |
|
WMIG ((WMIB + 0x0200), (WMIB + 0x3000), 0x03) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x04)) |
|
{ |
|
WMIG ((WMIB + 0x0300), (WMIB + 0x4000), 0x04) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x05)) |
|
{ |
|
WMIG ((WMIB + 0x0400), (WMIB + 0x5000), 0x05) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x06)) |
|
{ |
|
WMIG ((WMIB + 0x0500), (WMIB + 0x6000), 0x06) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x07)) |
|
{ |
|
WMIG ((WMIB + 0x0600), (WMIB + 0x7000), 0x07) |
|
Return (Zero) |
|
} |
|
|
|
If ((WMA5 == 0x08)) |
|
{ |
|
WMIG ((WMIB + 0x0700), (WMIB + 0x8000), 0x08) |
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (WM06, 3, Serialized) |
|
{ |
|
CreateDWordField (Arg2, Zero, WM6A) |
|
Local0 = INIT (WM6A) |
|
Return (Local0) |
|
} |
|
|
|
Method (WM07, 3, Serialized) |
|
{ |
|
CreateDWordField (Arg2, Zero, WM7A) |
|
Local0 = WDOG (WM7A) |
|
Return (Local0) |
|
} |
|
|
|
Method (NTFY, 1, Serialized) |
|
{ |
|
If (!QNTY (Arg0)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
EVCD = Arg0 |
|
Notify (WMI0, 0x80) // Status Change |
|
} |
|
|
|
Method (WSMI, 1, Serialized) |
|
{ |
|
WMIS = Arg0 |
|
ISMI (0xE3) |
|
} |
|
|
|
Name (WQBA, Buffer (0x0914) |
|
{ |
|
/* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB.... |
|
/* 0008 */ 0x04, 0x09, 0x00, 0x00, 0x50, 0x67, 0x00, 0x00, // ....Pg.. |
|
/* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T |
|
/* 0018 */ 0x28, 0xC7, 0xB2, 0x00, 0x01, 0x06, 0x18, 0x42, // (......B |
|
/* 0020 */ 0x10, 0x2B, 0x10, 0x92, 0x2B, 0x81, 0x42, 0x04, // .+..+.B. |
|
/* 0028 */ 0x0A, 0x44, 0x24, 0x81, 0x30, 0x28, 0x0D, 0x20, // .D$.0(. |
|
/* 0030 */ 0x92, 0x03, 0x21, 0x17, 0x4C, 0x4C, 0x80, 0x08, // ..!.LL.. |
|
/* 0038 */ 0x08, 0x79, 0x15, 0x60, 0x53, 0x80, 0x49, 0x10, // .y.`S.I. |
|
/* 0040 */ 0xF5, 0xEF, 0x0F, 0x51, 0x12, 0x1C, 0x4A, 0x08, // ...Q..J. |
|
/* 0048 */ 0x84, 0x24, 0x0A, 0x30, 0x2F, 0x40, 0xB7, 0x00, // .$.0/@.. |
|
/* 0050 */ 0xC3, 0x02, 0x6C, 0x0B, 0x30, 0x2D, 0xC0, 0x31, // ..l.0-.1 |
|
/* 0058 */ 0x24, 0x95, 0x06, 0x4E, 0x09, 0x2C, 0x05, 0x42, // $..N.,.B |
|
/* 0060 */ 0x42, 0x05, 0x28, 0x17, 0xE0, 0x5B, 0x80, 0x76, // B.(..[.v |
|
/* 0068 */ 0x44, 0x49, 0x16, 0xB0, 0xA3, 0x30, 0x09, 0x3C, // DI...0.< |
|
/* 0070 */ 0x8A, 0xC8, 0x46, 0xE3, 0xD0, 0xD8, 0x61, 0x58, // ..F...aX |
|
/* 0078 */ 0x26, 0x98, 0x06, 0x71, 0x18, 0x65, 0x23, 0x8B, // &..q.e#. |
|
/* 0080 */ 0xC0, 0x13, 0xEA, 0x74, 0x74, 0x05, 0x08, 0x13, // ...tt... |
|
/* 0088 */ 0x20, 0x1E, 0x55, 0x18, 0xCD, 0x41, 0x91, 0x08, // .U..A.. |
|
/* 0090 */ 0xD0, 0x28, 0x31, 0x63, 0x22, 0xB0, 0x9D, 0x63, // .(1c"..c |
|
/* 0098 */ 0x6B, 0x14, 0xA7, 0x51, 0xB8, 0x00, 0xE9, 0x18, // k..Q.... |
|
/* 00A0 */ 0x1A, 0xC1, 0x71, 0x85, 0xF7, 0xC8, 0x8E, 0x90, // ..q..... |
|
/* 00A8 */ 0x59, 0x1C, 0x8B, 0x20, 0x43, 0x85, 0xEB, 0x10, // Y.. C... |
|
/* 00B0 */ 0x4E, 0x73, 0x32, 0xC8, 0x89, 0x9C, 0x49, 0xEC, // Ns2...I. |
|
/* 00B8 */ 0x08, 0x05, 0x09, 0xB0, 0x8E, 0x21, 0xA4, 0x58, // .....!.X |
|
/* 00C0 */ 0x51, 0x6A, 0xC6, 0xD3, 0x0C, 0x82, 0x34, 0x0A, // Qj....4. |
|
/* 00C8 */ 0xA5, 0xC9, 0x79, 0x00, 0x61, 0xC2, 0xC3, 0x20, // ..y.a.. |
|
/* 00D0 */ 0x30, 0xFE, 0x11, 0x61, 0x64, 0x40, 0xC8, 0x33, // 0..ad@.3 |
|
/* 00D8 */ 0xB2, 0x86, 0x6A, 0x02, 0xBB, 0x17, 0xE0, 0x6C, // ..j....l |
|
/* 00E0 */ 0x6A, 0x32, 0x36, 0x39, 0x29, 0x9B, 0x1D, 0x41, // j269)..A |
|
/* 00E8 */ 0x68, 0x0B, 0x5E, 0xDA, 0x04, 0x18, 0x04, 0x13, // h.^..... |
|
/* 00F0 */ 0x4A, 0x24, 0x0F, 0xE5, 0x78, 0xA2, 0x54, 0x88, // J$..x.T. |
|
/* 00F8 */ 0xA4, 0xF1, 0xC5, 0x88, 0x52, 0x1C, 0x8A, 0x60, // ....R..` |
|
/* 0100 */ 0x23, 0xB6, 0x86, 0x21, 0x98, 0x98, 0x21, 0xE3, // #..!..!. |
|
/* 0108 */ 0x07, 0xB7, 0xFD, 0x83, 0x01, 0x53, 0x00, 0xD1, // .....S.. |
|
/* 0110 */ 0x02, 0x88, 0x22, 0x8D, 0x06, 0x75, 0x18, 0x48, // .."..u.H |
|
/* 0118 */ 0xF0, 0x70, 0xE0, 0x71, 0x9E, 0xD6, 0xF9, 0x1D, // .p.q.... |
|
/* 0120 */ 0xD7, 0x41, 0x04, 0x39, 0xE1, 0xE3, 0xAA, 0xF3, // .A.9.... |
|
/* 0128 */ 0x54, 0x40, 0x46, 0xC6, 0xFE, 0xFF, 0x58, 0x09, // T@F...X. |
|
/* 0130 */ 0x3A, 0x38, 0x26, 0x40, 0x71, 0x0D, 0xA8, 0x69, // :8&@q..i |
|
/* 0138 */ 0x3E, 0x1D, 0xB0, 0x81, 0x86, 0xC3, 0x0C, 0xD1, // >....... |
|
/* 0140 */ 0xA3, 0x0D, 0x77, 0x02, 0x87, 0xC8, 0x00, 0x3D, // ..w....= |
|
/* 0148 */ 0xA2, 0x07, 0x03, 0xEC, 0x10, 0x4F, 0xE6, 0x25, // .....O.% |
|
/* 0150 */ 0xA0, 0x54, 0x01, 0x66, 0x4F, 0x08, 0x9A, 0x76, // .T.fO..v |
|
/* 0158 */ 0x82, 0xE3, 0xF1, 0x71, 0xC0, 0xF3, 0x39, 0xE1, // ...q..9. |
|
/* 0160 */ 0x04, 0x96, 0x3F, 0x08, 0xD4, 0xC8, 0x0C, 0xED, // ..?..... |
|
/* 0168 */ 0x71, 0x9E, 0xD6, 0x5B, 0x81, 0x8F, 0x00, 0x26, // q..[...& |
|
/* 0170 */ 0xB0, 0x58, 0x08, 0x6D, 0x52, 0xE3, 0x01, 0x02, // .X.mR... |
|
/* 0178 */ 0x8A, 0x0F, 0x05, 0x42, 0x78, 0x75, 0xF0, 0x7C, // ...Bxu.| |
|
/* 0180 */ 0x4D, 0x30, 0x32, 0x84, 0x9C, 0x8C, 0x07, 0x35, // M02....5 |
|
/* 0188 */ 0x0A, 0x83, 0xD6, 0x0A, 0xAE, 0x9B, 0x40, 0x02, // ......@. |
|
/* 0190 */ 0x47, 0x84, 0xD0, 0x67, 0xC3, 0xA2, 0x86, 0x4D, // G..g...M |
|
/* 0198 */ 0x8F, 0x16, 0xFC, 0x54, 0xC1, 0x20, 0xCF, 0xE0, // ...T. .. |
|
/* 01A0 */ 0x11, 0xC0, 0x23, 0x39, 0x21, 0x1F, 0x3E, 0x3C, // ..#9!.>< |
|
/* 01A8 */ 0x30, 0xF8, 0xB3, 0xF0, 0x91, 0x02, 0x1C, 0x1E, // 0....... |
|
/* 01B0 */ 0xC1, 0x84, 0xF3, 0x0A, 0x01, 0x6B, 0xA4, 0xF0, // .....k.. |
|
/* 01B8 */ 0x6F, 0x11, 0x46, 0xF6, 0xA9, 0xE1, 0xB5, 0x21, // o.F....! |
|
/* 01C0 */ 0x81, 0x0F, 0x1E, 0x81, 0xB1, 0x43, 0xB5, 0x5F, // .....C._ |
|
/* 01C8 */ 0x01, 0x08, 0xC1, 0xA3, 0x3D, 0x0A, 0x3C, 0x7B, // ....=.<{ |
|
/* 01D0 */ 0x44, 0x78, 0xDC, 0xC0, 0xFC, 0xFF, 0x8F, 0x1B, // Dx...... |
|
/* 01D8 */ 0xB0, 0x09, 0x8A, 0x1C, 0x20, 0x7A, 0x0C, 0xFC, // .... z.. |
|
/* 01E0 */ 0x04, 0x71, 0x0A, 0xF1, 0xC3, 0x1F, 0xC3, 0x11, // .q...... |
|
/* 01E8 */ 0x45, 0x89, 0x7C, 0x48, 0x3E, 0x9C, 0x18, 0xE1, // E.|H>... |
|
/* 01F0 */ 0x10, 0x9E, 0x49, 0xCE, 0xC0, 0x07, 0x0C, 0x4F, // ..I....O |
|
/* 01F8 */ 0xEB, 0x14, 0x5E, 0x24, 0x3C, 0x02, 0x4C, 0xA0, // ..^$<.L. |
|
/* 0200 */ 0x43, 0x0C, 0x8D, 0xB2, 0x7E, 0x45, 0x80, 0x41, // C...~E.A |
|
/* 0208 */ 0x9D, 0x63, 0x00, 0x57, 0x30, 0xCF, 0x31, 0xE0, // .c.W0.1. |
|
/* 0210 */ 0x3B, 0x3E, 0xF0, 0x6B, 0x00, 0xE6, 0x7C, 0xF2, // ;>.k..|. |
|
/* 0218 */ 0x14, 0x03, 0x07, 0x97, 0x81, 0xBC, 0x04, 0xC4, // ........ |
|
/* 0220 */ 0x79, 0x77, 0xF1, 0xCD, 0xC4, 0xD7, 0x02, 0xE3, // yw...... |
|
/* 0228 */ 0x3E, 0xC4, 0x80, 0x61, 0x60, 0x0F, 0x31, 0xE0, // >..a`.1. |
|
/* 0230 */ 0xFC, 0xFF, 0x1F, 0x62, 0xE0, 0x05, 0x3F, 0xC4, // ...b..?. |
|
/* 0238 */ 0x00, 0x34, 0x91, 0x77, 0xBE, 0x90, 0x91, 0x55, // .4.w...U |
|
/* 0240 */ 0xF8, 0x10, 0x83, 0xBA, 0x21, 0x9C, 0xCF, 0x43, // ....!..C |
|
/* 0248 */ 0xCA, 0xD3, 0x01, 0x93, 0x73, 0xCE, 0xA0, 0x87, // ....s... |
|
/* 0250 */ 0x18, 0xE0, 0x01, 0x88, 0xF7, 0x3E, 0x65, 0x32, // .....>e2 |
|
/* 0258 */ 0x82, 0x33, 0x35, 0xA0, 0x51, 0x7D, 0xAE, 0x00, // .35.Q}.. |
|
/* 0260 */ 0xC7, 0x79, 0x82, 0xFF, 0xFF, 0xCF, 0x13, 0x18, // .y...... |
|
/* 0268 */ 0xBC, 0xD7, 0x0A, 0x76, 0x0C, 0x60, 0x67, 0x0A, // ...v.`g. |
|
/* 0270 */ 0x38, 0x57, 0x0A, 0x9F, 0x5A, 0x7C, 0x4E, 0xF0, // 8W..Z|N. |
|
/* 0278 */ 0x18, 0xF9, 0x58, 0x0C, 0x1A, 0xF2, 0x41, 0xC0, // ..X...A. |
|
/* 0280 */ 0x0B, 0xB4, 0xAC, 0xB3, 0x0D, 0x68, 0x2E, 0x13, // .....h.. |
|
/* 0288 */ 0xCF, 0x3D, 0xD8, 0xA3, 0x0D, 0x18, 0x90, 0x2A, // .=.....* |
|
/* 0290 */ 0xBD, 0x05, 0xE8, 0x02, 0x82, 0x23, 0xF0, 0xC1, // .....#.. |
|
/* 0298 */ 0x06, 0xF8, 0xC4, 0x3A, 0xD5, 0xD0, 0x30, 0x63, // ...:..0c |
|
/* 02A0 */ 0x54, 0x10, 0x18, 0xD4, 0xC1, 0x06, 0x70, 0x75, // T.....pu |
|
/* 02A8 */ 0xE8, 0xF0, 0xC1, 0x06, 0x3C, 0xFF, 0xFF, 0x11, // ....<... |
|
/* 02B0 */ 0xB2, 0xC1, 0x9C, 0x44, 0x98, 0xA3, 0x08, 0xF6, // ...D.... |
|
/* 02B8 */ 0x2C, 0xE1, 0x9B, 0x0D, 0x78, 0xB0, 0xB1, 0x27, // ,...x..' |
|
/* 02C0 */ 0x1B, 0xB0, 0x9C, 0x09, 0x9E, 0x6C, 0x80, 0x49, // .....l.I |
|
/* 02C8 */ 0xF8, 0x93, 0x0D, 0x40, 0x1E, 0xD8, 0x27, 0x81, // ...@..'. |
|
/* 02D0 */ 0x77, 0x80, 0xFF, 0xFF, 0x93, 0x0D, 0x60, 0xF1, // w.....`. |
|
/* 02D8 */ 0x4A, 0x81, 0x3D, 0xD9, 0x40, 0x5E, 0xBC, 0x4E, // J.=.@^.N |
|
/* 02E0 */ 0x36, 0xE0, 0x3A, 0x03, 0x82, 0xED, 0x08, 0x02, // 6.:..... |
|
/* 02E8 */ 0xF3, 0x6C, 0x03, 0x9C, 0xCE, 0x80, 0xC0, 0xE1, // .l...... |
|
/* 02F0 */ 0xFF, 0x7F, 0x06, 0x04, 0x1C, 0x9E, 0x5B, 0x9E, // ......[. |
|
/* 02F8 */ 0x01, 0xC1, 0x75, 0xF2, 0x64, 0x67, 0x40, 0x70, // ..u.dg@p |
|
/* 0300 */ 0xA1, 0x3C, 0x03, 0x02, 0x66, 0xFF, 0xFF, 0x67, // .<..f..g |
|
/* 0308 */ 0x40, 0xC0, 0xD2, 0xE9, 0x80, 0x9D, 0x01, 0x01, // @....... |
|
/* 0310 */ 0x4E, 0xFD, 0xFF, 0x2F, 0x20, 0xFC, 0x0C, 0x08, // N../ ... |
|
/* 0318 */ 0x30, 0xEC, 0x66, 0x03, 0x1B, 0x1B, 0x7B, 0xB2, // 0.f...{. |
|
/* 0320 */ 0x01, 0xCB, 0x19, 0x10, 0x77, 0xB2, 0x01, 0xEF, // ....w... |
|
/* 0328 */ 0xFF, 0xFF, 0x0C, 0x08, 0x30, 0xE9, 0x64, 0x03, // ....0.d. |
|
/* 0330 */ 0x58, 0xFB, 0xFF, 0x9F, 0x01, 0x01, 0x63, 0x67, // X.....cg |
|
/* 0338 */ 0x1B, 0x60, 0x75, 0x06, 0x04, 0xBC, 0xFF, 0xFF, // .`u..... |
|
/* 0340 */ 0xCF, 0x80, 0xF8, 0x63, 0xCB, 0x33, 0x20, 0xB8, // ...c.3 . |
|
/* 0348 */ 0x70, 0x9F, 0x01, 0xC1, 0x87, 0xF1, 0x0C, 0x08, // p....... |
|
/* 0350 */ 0xF0, 0xEF, 0x74, 0xC0, 0x8E, 0x36, 0xFC, 0xFF, // ..t..6.. |
|
/* 0358 */ 0x7F, 0x06, 0x04, 0x18, 0x75, 0x10, 0x60, 0x67, // ....u.`g |
|
/* 0360 */ 0x40, 0xC0, 0xD3, 0xFF, 0xFF, 0x0C, 0x08, 0x58, // @......X |
|
/* 0368 */ 0xBB, 0xD9, 0xC0, 0xC6, 0xC6, 0x9E, 0x6C, 0xC0, // ......l. |
|
/* 0370 */ 0x72, 0x06, 0xC4, 0x9D, 0x6C, 0xC0, 0x7F, 0x06, // r...l... |
|
/* 0378 */ 0x04, 0x5C, 0xFD, 0xFF, 0xCF, 0x80, 0x80, 0x95, // .\...... |
|
/* 0380 */ 0x93, 0x0D, 0xE0, 0xF1, 0x0C, 0x08, 0xF8, 0x39, // .......9 |
|
/* 0388 */ 0x0A, 0xFC, 0xFF, 0x9F, 0x01, 0x01, 0x6E, 0xCD, // ......n. |
|
/* 0390 */ 0xE1, 0x19, 0x10, 0x5C, 0x33, 0xF3, 0x19, 0x10, // ...\3... |
|
/* 0398 */ 0x6C, 0xF7, 0x1A, 0x9F, 0x01, 0xC1, 0xFF, 0xFF, // l....... |
|
/* 03A0 */ 0x3F, 0x03, 0x02, 0xEC, 0x39, 0x1D, 0xB0, 0xA3, // ?...9... |
|
/* 03A8 */ 0x0D, 0xE0, 0xEE, 0xFF, 0x7F, 0x06, 0x04, 0xEC, // ........ |
|
/* 03B0 */ 0x1C, 0x04, 0xD8, 0x19, 0x10, 0xE0, 0xD6, 0xFF, // ........ |
|
/* 03B8 */ 0xFF, 0x66, 0x03, 0x1F, 0x1B, 0x7B, 0xB2, 0x01, // .f...{.. |
|
/* 03C0 */ 0xCB, 0x19, 0x10, 0x77, 0xB2, 0x01, 0xFF, 0x19, // ...w.... |
|
/* 03C8 */ 0x10, 0x60, 0xD0, 0xC9, 0x06, 0xF6, 0xFF, 0xFF, // .`...... |
|
/* 03D0 */ 0x0C, 0x08, 0x30, 0xE9, 0x6C, 0x03, 0xAC, 0xCE, // ..0.l... |
|
/* 03D8 */ 0x80, 0xC0, 0xEF, 0xFF, 0x7F, 0x06, 0x04, 0x3C, // .......< |
|
/* 03E0 */ 0xDD, 0x5B, 0x9E, 0x01, 0xC1, 0x85, 0xFB, 0x0C, // .[...... |
|
/* 03E8 */ 0x08, 0x3E, 0x88, 0x67, 0x40, 0xC0, 0xFA, 0xFF, // .>.g@... |
|
/* 03F0 */ 0xFF, 0x0C, 0x08, 0x98, 0x38, 0x1D, 0xB0, 0x33, // ....8..3 |
|
/* 03F8 */ 0x20, 0xC0, 0xAC, 0x83, 0x00, 0x3B, 0xD8, 0xE0, // ....;.. |
|
/* 0400 */ 0xFF, 0xFF, 0x67, 0x40, 0x80, 0x4D, 0x37, 0x1B, // ..g@.M7. |
|
/* 0408 */ 0xD8, 0xD8, 0xD8, 0x93, 0x0D, 0x58, 0xCE, 0x80, // .....X.. |
|
/* 0410 */ 0xB8, 0x93, 0x0D, 0xF8, 0xCF, 0x80, 0x70, 0xFE, // ......p. |
|
/* 0418 */ 0xFF, 0x67, 0x40, 0x80, 0x2D, 0x27, 0x1B, 0xC0, // .g@.-'.. |
|
/* 0420 */ 0xE3, 0x95, 0x02, 0xF3, 0xFF, 0x3F, 0x03, 0x02, // .....?.. |
|
/* 0428 */ 0x56, 0xCE, 0x36, 0xC0, 0xEA, 0x0C, 0x08, 0xF0, // V.6..... |
|
/* 0430 */ 0xE0, 0xE0, 0xF2, 0x66, 0x83, 0xF9, 0xFF, 0x9F, // ...f.... |
|
/* 0438 */ 0x01, 0xC1, 0x80, 0xFB, 0x0C, 0x08, 0xBE, 0xFB, // ........ |
|
/* 0440 */ 0xC1, 0x33, 0x20, 0xC0, 0xBF, 0xD3, 0x01, 0x3B, // .3 ....; |
|
/* 0448 */ 0xDA, 0x80, 0xE3, 0xFF, 0x7F, 0x06, 0x04, 0x58, // .......X |
|
/* 0450 */ 0x73, 0x10, 0x60, 0x67, 0x40, 0xC0, 0xE1, 0xFF, // s.`g@... |
|
/* 0458 */ 0xFF, 0x0C, 0x08, 0x98, 0xB9, 0xD9, 0xC0, 0xC6, // ........ |
|
/* 0460 */ 0xC6, 0x9E, 0x6C, 0xC0, 0x72, 0x06, 0xC4, 0x9D, // ..l.r... |
|
/* 0468 */ 0x6C, 0xC0, 0x7F, 0x06, 0x04, 0x3C, 0xFE, 0xFF, // l....<.. |
|
/* 0470 */ 0xCF, 0x80, 0xC0, 0xFC, 0x64, 0x03, 0x78, 0x3C, // ....d.x< |
|
/* 0478 */ 0x03, 0x02, 0x7E, 0xCE, 0x36, 0xB0, 0xFF, 0xFF, // ..~.6... |
|
/* 0480 */ 0x67, 0x40, 0x80, 0x3F, 0xDE, 0xCE, 0x80, 0x20, // g@.?... |
|
/* 0488 */ 0xC3, 0x7D, 0x06, 0x04, 0xDF, 0xFD, 0xE0, 0x19, // .}...... |
|
/* 0490 */ 0x10, 0xD8, 0xFD, 0xFF, 0xCF, 0x80, 0x00, 0x43, // .......C |
|
/* 0498 */ 0x4E, 0x07, 0xEC, 0x0C, 0x08, 0x78, 0xFD, 0xFF, // N....x.. |
|
/* 04A0 */ 0x9F, 0x01, 0x01, 0x03, 0x07, 0x01, 0x76, 0x06, // ......v. |
|
/* 04A8 */ 0x04, 0xD8, 0x75, 0xB3, 0x81, 0xF9, 0xFF, 0xBF, // ..u..... |
|
/* 04B0 */ 0x60, 0xC1, 0x38, 0xD9, 0x80, 0xE5, 0x0C, 0x88, // `.8..... |
|
/* 04B8 */ 0x3B, 0xD9, 0x80, 0xFF, 0x0C, 0x08, 0x30, 0xE8, // ;.....0. |
|
/* 04C0 */ 0x64, 0x03, 0xE6, 0xFF, 0xFF, 0x19, 0x10, 0x60, // d......` |
|
/* 04C8 */ 0xCB, 0xD9, 0x06, 0x58, 0x9D, 0x01, 0x81, 0xFB, // ...X.... |
|
/* 04D0 */ 0xFF, 0xFF, 0x0C, 0x08, 0xB8, 0x38, 0x1A, 0x3C, // .....8.< |
|
/* 04D8 */ 0x03, 0x82, 0xEB, 0x96, 0xE0, 0x33, 0x20, 0xD8, // .....3 . |
|
/* 04E0 */ 0xEE, 0x07, 0xCF, 0x80, 0x00, 0x23, 0xFE, 0xFF, // .....#.. |
|
/* 04E8 */ 0x67, 0x40, 0x60, 0x7B, 0x3A, 0x60, 0x67, 0x40, // g@`{:`g@ |
|
/* 04F0 */ 0x80, 0x59, 0x07, 0x01, 0x76, 0xB0, 0x01, 0xD7, // .Y..v... |
|
/* 04F8 */ 0xFF, 0xFF, 0x0C, 0x08, 0x30, 0xE6, 0x66, 0x03, // ....0.f. |
|
/* 0500 */ 0x1B, 0x1B, 0x7B, 0xB2, 0x01, 0xCB, 0x19, 0x10, // ..{..... |
|
/* 0508 */ 0x77, 0xB2, 0x01, 0xFF, 0x19, 0x10, 0x7C, 0xFF, // w.....|. |
|
/* 0510 */ 0xFF, 0x33, 0x20, 0xC0, 0x88, 0x93, 0x0D, 0xE0, // .3 ..... |
|
/* 0518 */ 0xF1, 0x0C, 0x08, 0x96, 0xFF, 0xFF, 0x19, 0x10, // ........ |
|
/* 0520 */ 0x98, 0x9F, 0x6D, 0x80, 0x55, 0xB4, 0x83, 0x0D, // ..m.U... |
|
/* 0528 */ 0x2A, 0xCC, 0xD9, 0x06, 0x10, 0x3D, 0xEF, 0x87, // *....=.. |
|
/* 0530 */ 0x0F, 0x1F, 0x0C, 0x7C, 0x10, 0xC0, 0xDC, 0x6C, // ...|...l |
|
/* 0538 */ 0xE0, 0xDC, 0x2A, 0x7C, 0x5D, 0xF1, 0x41, 0xC4, // ..*|].A. |
|
/* 0540 */ 0x87, 0x07, 0xF6, 0xFF, 0x87, 0x8A, 0x13, 0x9E, // ........ |
|
/* 0548 */ 0x9F, 0x1C, 0x7C, 0xB6, 0x81, 0x7D, 0x9A, 0x79, // ..|..}.y |
|
/* 0550 */ 0x08, 0xC4, 0x21, 0x3C, 0xDB, 0x80, 0xFD, 0x4D, // ..!<...M |
|
/* 0558 */ 0xE1, 0x63, 0x81, 0xCF, 0x36, 0x00, 0x3F, 0x44, // .c..6.?D |
|
/* 0560 */ 0x1C, 0x30, 0xE4, 0x64, 0x3C, 0xA8, 0x51, 0x58, // .0.d<.QX |
|
/* 0568 */ 0xE3, 0x25, 0x81, 0x4C, 0xDB, 0x04, 0x43, 0x43, // .%.L..CC |
|
/* 0570 */ 0xE8, 0xB4, 0xE4, 0xB3, 0x0D, 0x38, 0xFF, 0xFF, // .....8.. |
|
/* 0578 */ 0x67, 0x1B, 0x70, 0x9E, 0x4E, 0xF0, 0x67, 0x1B, // g.p.N.g. |
|
/* 0580 */ 0x30, 0x9D, 0x25, 0x30, 0x04, 0x1E, 0x32, 0xFC, // 0.%0..2. |
|
/* 0588 */ 0xD3, 0x0C, 0x3F, 0x3E, 0xBC, 0x3F, 0x24, 0xF0, // ..?>.?$. |
|
/* 0590 */ 0xB9, 0x0F, 0x6C, 0xA7, 0x0E, 0x38, 0x87, 0x19, // ..l..8.. |
|
/* 0598 */ 0x60, 0x32, 0x26, 0xDC, 0x91, 0xC2, 0x43, 0xE0, // `2&...C. |
|
/* 05A0 */ 0x03, 0x68, 0x75, 0x7E, 0xE4, 0x58, 0x78, 0x56, // .hu~.XxV |
|
/* 05A8 */ 0xB8, 0xB3, 0x0C, 0x1F, 0x15, 0xE6, 0x74, 0x83, // ......t. |
|
/* 05B0 */ 0x8B, 0xF2, 0x3E, 0x30, 0x81, 0x82, 0xBC, 0x0B, // ..>0.... |
|
/* 05B8 */ 0x24, 0xF2, 0x81, 0x40, 0x61, 0x7C, 0xBA, 0x01, // $..@a|.. |
|
/* 05C0 */ 0x8E, 0xFF, 0xFF, 0xD3, 0x0D, 0xF0, 0x98, 0xA4, // ........ |
|
/* 05C8 */ 0x4F, 0x37, 0x60, 0x83, 0x88, 0x18, 0xAC, 0x68, // O7`....h |
|
/* 05D0 */ 0x30, 0xDD, 0x9A, 0x70, 0xB7, 0x1B, 0x1C, 0x5E, // 0..p...^ |
|
/* 05D8 */ 0xB8, 0x18, 0xA7, 0xC3, 0x10, 0xA2, 0x3C, 0xB0, // ......<. |
|
/* 05E0 */ 0x18, 0x99, 0x1F, 0x03, 0xC1, 0x70, 0x9B, 0x79, // .....p.y |
|
/* 05E8 */ 0xB6, 0x01, 0x2E, 0xE1, 0x0E, 0x05, 0xFA, 0x43, // .......C |
|
/* 05F0 */ 0xF9, 0x6C, 0x03, 0xF8, 0xFC, 0xFF, 0x9F, 0x6D, // .l.....m |
|
/* 05F8 */ 0x80, 0xCF, 0x41, 0x04, 0x77, 0x32, 0x01, 0xC3, // ..A.w2.. |
|
/* 0600 */ 0x89, 0x01, 0xD6, 0xB1, 0x0D, 0xB8, 0x88, 0x5B, // .......[ |
|
/* 0608 */ 0xA9, 0x4E, 0x3B, 0x16, 0x06, 0x22, 0x1B, 0x87, // .N;..".. |
|
/* 0610 */ 0x45, 0x3A, 0x54, 0x0B, 0xA1, 0xD2, 0x90, 0x7C, // E:T....| |
|
/* 0618 */ 0x04, 0x3A, 0xBB, 0x47, 0x85, 0xE7, 0x04, 0x01, // .:.G.... |
|
/* 0620 */ 0x09, 0xD4, 0x10, 0x0E, 0x0F, 0xA1, 0xE8, 0xA3, // ........ |
|
/* 0628 */ 0xA1, 0xC0, 0x0E, 0x0B, 0x46, 0x41, 0x3C, 0x7A, // ....FA<z |
|
/* 0630 */ 0x07, 0x81, 0xD0, 0xA1, 0x08, 0x7F, 0x62, 0xF0, // ......b. |
|
/* 0638 */ 0x7C, 0xDE, 0xF8, 0x4D, 0xF0, 0xB0, 0xF1, 0xB4, // |..M.... |
|
/* 0640 */ 0x00, 0xEB, 0x62, 0xE0, 0x63, 0x00, 0x3F, 0x13, // ..b.c.?. |
|
/* 0648 */ 0xE2, 0x0F, 0xFD, 0x26, 0xE0, 0xC7, 0x1E, 0xF0, // ...&.... |
|
/* 0650 */ 0x09, 0x3C, 0x0D, 0x80, 0x02, 0xC8, 0x93, 0xF7, // .<...... |
|
/* 0658 */ 0xB1, 0xE6, 0x01, 0x80, 0xCD, 0xE1, 0xC9, 0xC6, // ........ |
|
/* 0660 */ 0x68, 0xFF, 0xFF, 0x47, 0x1A, 0x9C, 0x8C, 0x95, // h..G.... |
|
/* 0668 */ 0xEA, 0x4B, 0xE3, 0x33, 0xA3, 0xC7, 0xC5, 0xCF, // .K.3.... |
|
/* 0670 */ 0x03, 0x3E, 0xB8, 0xB0, 0xB3, 0x01, 0xEE, 0x0C, // .>...... |
|
/* 0678 */ 0x85, 0x81, 0xF5, 0x48, 0x39, 0xAC, 0xD1, 0xC2, // ...H9... |
|
/* 0680 */ 0x1E, 0xF0, 0x43, 0x83, 0x2F, 0x1C, 0x9E, 0x99, // ..C./... |
|
/* 0688 */ 0xCF, 0x28, 0x3E, 0x6A, 0x80, 0xE5, 0x38, 0x05, // .(>j..8. |
|
/* 0690 */ 0xFF, 0xB0, 0x82, 0x3B, 0xC9, 0xC0, 0x9D, 0xE6, // ...;.... |
|
/* 0698 */ 0x23, 0xC1, 0xA3, 0x9E, 0x87, 0x1E, 0xDE, 0x47, // #......G |
|
/* 06A0 */ 0x18, 0xCF, 0x2E, 0x88, 0xAF, 0x9D, 0xFC, 0xF2, // ........ |
|
/* 06A8 */ 0x7D, 0x5A, 0xBE, 0xEF, 0xF8, 0xE8, 0x63, 0xA0, // }Z....c. |
|
/* 06B0 */ 0x27, 0x86, 0xA8, 0xAF, 0x27, 0x9E, 0x00, 0xBF, // '...'... |
|
/* 06B8 */ 0x50, 0x38, 0xC6, 0xA9, 0x88, 0x06, 0x5A, 0xA9, // P8....Z. |
|
/* 06C0 */ 0xA4, 0xAE, 0x99, 0xC2, 0xF8, 0x54, 0x04, 0xB8, // .....T.. |
|
/* 06C8 */ 0x8A, 0x30, 0x78, 0x50, 0xFC, 0xFF, 0x4F, 0x45, // .0xP..OE |
|
/* 06D0 */ 0xD8, 0x1B, 0x86, 0x2F, 0x03, 0x3E, 0x14, 0x81, // .../.>.. |
|
/* 06D8 */ 0xE5, 0x40, 0xE2, 0x89, 0xBD, 0x04, 0xF8, 0xDC, // .@...... |
|
/* 06E0 */ 0x80, 0xC3, 0x39, 0x03, 0x7E, 0x32, 0x02, 0xC3, // ..9.~2.. |
|
/* 06E8 */ 0x5D, 0xFB, 0xC9, 0x08, 0xB8, 0x44, 0x3B, 0x19, // ]....D;. |
|
/* 06F0 */ 0x01, 0x34, 0x39, 0xDF, 0xE1, 0xFE, 0xFF, 0x27, // .49....' |
|
/* 06F8 */ 0x23, 0x30, 0x9C, 0x1A, 0x60, 0x1C, 0x8C, 0x80, // #0..`... |
|
/* 0700 */ 0x8B, 0xA4, 0x83, 0x11, 0x95, 0x73, 0x30, 0x82, // .....s0. |
|
/* 0708 */ 0x72, 0x84, 0xC0, 0x1D, 0x8C, 0xC0, 0x3F, 0xA6, // r.....?. |
|
/* 0710 */ 0x33, 0x7A, 0x1D, 0x38, 0x75, 0x1F, 0x8C, 0x00, // 3z.8u... |
|
/* 0718 */ 0x73, 0xC3, 0xF5, 0xC1, 0x08, 0xF8, 0xFC, 0xFF, // s....... |
|
/* 0720 */ 0x0F, 0x46, 0xC0, 0xE5, 0x70, 0xE1, 0x83, 0x11, // .F..p... |
|
/* 0728 */ 0xB8, 0x0F, 0x0B, 0xFC, 0x10, 0x83, 0x25, 0x28, // ......%( |
|
/* 0730 */ 0xFE, 0x35, 0x64, 0x02, 0x85, 0x5A, 0xA4, 0x24, // .5d..Z.$ |
|
/* 0738 */ 0x2F, 0x97, 0xC2, 0xF8, 0x4C, 0x04, 0xB8, 0x8A, // /...L... |
|
/* 0740 */ 0x71, 0x26, 0x02, 0x21, 0xC6, 0xE3, 0xB1, 0x11, // q&.!.... |
|
/* 0748 */ 0xCF, 0x38, 0x6C, 0xB8, 0xE7, 0x8B, 0xA7, 0x22, // .8l...." |
|
/* 0750 */ 0xB0, 0xCF, 0xE1, 0x0C, 0xFA, 0xBC, 0x6E, 0xE9, // ......n. |
|
/* 0758 */ 0x54, 0x84, 0xFF, 0xFF, 0x9F, 0x8A, 0x60, 0x1C, // T.....`. |
|
/* 0760 */ 0x83, 0x9E, 0x8A, 0x80, 0x4B, 0xBC, 0x53, 0x11, // ....K.S. |
|
/* 0768 */ 0x40, 0x93, 0x13, 0xC4, 0x53, 0x11, 0xB8, 0xCE, // @...S... |
|
/* 0770 */ 0x0D, 0x30, 0xCF, 0x45, 0xE0, 0xFB, 0xFF, 0x9F, // .0.E.... |
|
/* 0778 */ 0x8B, 0xE0, 0x3E, 0x08, 0x7C, 0x18, 0x22, 0xE7, // ..>.|.". |
|
/* 0780 */ 0x22, 0x74, 0x78, 0x2A, 0x1D, 0x22, 0x70, 0xB1, // "tx*."p. |
|
/* 0788 */ 0xCF, 0x45, 0x74, 0xD8, 0x0E, 0x4C, 0xA2, 0x43, // .Et..L.C |
|
/* 0790 */ 0xBD, 0xCF, 0x45, 0x3C, 0xE6, 0x91, 0x86, 0x82, // ..E<.... |
|
/* 0798 */ 0x18, 0xD0, 0x19, 0xCE, 0x45, 0x68, 0x15, 0xE7, // ....Eh.. |
|
/* 07A0 */ 0x22, 0xE4, 0x20, 0xDF, 0x16, 0xD8, 0xEC, 0x7C, // ". ....| |
|
/* 07A8 */ 0x0F, 0xE0, 0x37, 0x15, 0x5F, 0x8B, 0x18, 0x6E, // ..7._..n |
|
/* 07B0 */ 0x35, 0xD7, 0x1D, 0x14, 0x98, 0x6F, 0x45, 0x18, // 5....oE. |
|
/* 07B8 */ 0x5D, 0xA7, 0x22, 0x90, 0xE9, 0xBB, 0x14, 0x81, // ]."..... |
|
/* 07C0 */ 0x1C, 0x9D, 0x9F, 0xA8, 0xC0, 0x87, 0xFF, 0x3C, // .......< |
|
/* 07C8 */ 0xE0, 0x21, 0x3C, 0x51, 0xC1, 0x3D, 0x13, 0xBC, // .!<Q.=.. |
|
/* 07D0 */ 0xF5, 0xF8, 0x44, 0x05, 0xFB, 0x90, 0x4B, 0x4E, // ..D...KN |
|
/* 07D8 */ 0x54, 0x40, 0xE3, 0xFF, 0x7F, 0xA2, 0x02, 0x5F, // T@....._ |
|
/* 07E0 */ 0xEC, 0x13, 0x15, 0xA0, 0xE7, 0x08, 0x82, 0x3B, // .......; |
|
/* 07E8 */ 0xB9, 0x82, 0xF5, 0x98, 0x81, 0x51, 0x68, 0xD3, // .....Qh. |
|
/* 07F0 */ 0xA7, 0x46, 0xA3, 0x56, 0x0D, 0xCA, 0xD4, 0x28, // .F.V...( |
|
/* 07F8 */ 0xD3, 0xA0, 0x56, 0x9F, 0x4A, 0x8D, 0x19, 0xBB, // ..V.J... |
|
/* 0800 */ 0x0F, 0x58, 0xE2, 0x3B, 0x41, 0xC3, 0x75, 0x40, // .X.;A.u@ |
|
/* 0808 */ 0x10, 0x1A, 0x89, 0x42, 0x20, 0x8E, 0xF2, 0xA7, // ...B ... |
|
/* 0810 */ 0x10, 0x88, 0x85, 0x78, 0x00, 0x61, 0x42, 0x57, // ...x.aBW |
|
/* 0818 */ 0x24, 0x10, 0x8B, 0x5B, 0x9B, 0x40, 0x1C, 0x0D, // $..[.@.. |
|
/* 0820 */ 0x84, 0x46, 0x5F, 0x9D, 0x40, 0x1C, 0xD8, 0x07, // .F_.@... |
|
/* 0828 */ 0x08, 0x93, 0xFB, 0x26, 0x10, 0x88, 0xE3, 0x18, // ...&.... |
|
/* 0830 */ 0x01, 0x61, 0x11, 0x5E, 0x54, 0x3A, 0x06, 0x10, // .a.^T:.. |
|
/* 0838 */ 0x2B, 0x20, 0x4C, 0xA0, 0x16, 0x10, 0x26, 0xCB, // + L...&. |
|
/* 0840 */ 0x0C, 0x08, 0x0B, 0x05, 0x42, 0x43, 0x7F, 0x39, // ....BC.9 |
|
/* 0848 */ 0x04, 0xE2, 0xA0, 0x76, 0x40, 0x98, 0x4C, 0x3D, // ...v@.L= |
|
/* 0850 */ 0x20, 0x2C, 0x86, 0x1F, 0x10, 0x26, 0x5E, 0xD1, // ,...&^. |
|
/* 0858 */ 0x60, 0x28, 0x08, 0x95, 0xF6, 0xE6, 0xD2, 0x61, // `(.....a |
|
/* 0860 */ 0x82, 0x78, 0x02, 0x61, 0x61, 0x40, 0xE8, 0xFF, // .x.aa@.. |
|
/* 0868 */ 0x3F, 0xAC, 0x28, 0x10, 0x16, 0xD1, 0xD5, 0x60, // ?.(....` |
|
/* 0870 */ 0xE8, 0xDB, 0x40, 0x20, 0x0E, 0xF0, 0x4C, 0x0A, // ..@ ..L. |
|
/* 0878 */ 0x42, 0x44, 0x3F, 0x25, 0x04, 0xE2, 0xC8, 0x20, // BD?%... |
|
/* 0880 */ 0x54, 0xD2, 0x1F, 0x42, 0x43, 0x25, 0x7F, 0xA5, // T..BC%.. |
|
/* 0888 */ 0x83, 0x61, 0x20, 0x34, 0xE6, 0x83, 0xE9, 0x50, // .a 4...P |
|
/* 0890 */ 0xD9, 0x5F, 0x4B, 0x20, 0x16, 0xA6, 0x0E, 0x84, // ._K .... |
|
/* 0898 */ 0x09, 0x77, 0x37, 0x54, 0xFA, 0x19, 0xD1, 0x60, // .w7T...` |
|
/* 08A0 */ 0x08, 0x08, 0x15, 0xF3, 0xA8, 0xD0, 0x50, 0xC9, // ......P. |
|
/* 08A8 */ 0x83, 0x22, 0x08, 0x91, 0x0F, 0x42, 0xE3, 0xBD, // ."...B.. |
|
/* 08B0 */ 0x04, 0x34, 0x54, 0xF2, 0x21, 0xD0, 0x60, 0xC8, // .4T.!.`. |
|
/* 08B8 */ 0x1B, 0x47, 0x20, 0x96, 0xFC, 0x4A, 0xD3, 0x50, // .G ..J.P |
|
/* 08C0 */ 0xC9, 0x43, 0x41, 0x20, 0x0E, 0x09, 0x42, 0x45, // .CA ..BE |
|
/* 08C8 */ 0xBC, 0x72, 0x82, 0x90, 0xF0, 0xCF, 0x8B, 0x20, // .r..... |
|
/* 08D0 */ 0x44, 0xBA, 0xD1, 0x41, 0xD0, 0xE7, 0xC5, 0x83, // D..A.... |
|
/* 08D8 */ 0x01, 0xB3, 0x0A, 0xC2, 0x04, 0x69, 0x1D, 0x36, // .....i.6 |
|
/* 08E0 */ 0x7D, 0x28, 0x14, 0xF0, 0x15, 0xD0, 0xE1, 0x20, // }(..... |
|
/* 08E8 */ 0x88, 0x80, 0x2C, 0xD2, 0xED, 0x80, 0x29, 0x08, // ..,...). |
|
/* 08F0 */ 0x15, 0x63, 0x17, 0x90, 0x49, 0x03, 0x11, 0x90, // .c..I... |
|
/* 08F8 */ 0xE3, 0x0A, 0x06, 0x61, 0x62, 0x5F, 0x14, 0x41, // ...ab_.A |
|
/* 0900 */ 0x48, 0xAE, 0xE7, 0x51, 0x40, 0x12, 0x12, 0x44, // H..Q@..D |
|
/* 0908 */ 0xC7, 0x03, 0xF2, 0x84, 0x13, 0x90, 0xC3, 0x81, // ........ |
|
/* 0910 */ 0x08, 0xC8, 0xFF, 0x7F // .... |
|
}) |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Name (WMIP, Zero) |
|
Method (INIT, 1, NotSerialized) |
|
{ |
|
WMIP = One |
|
WINI (Arg0) |
|
Return (Zero) |
|
} |
|
|
|
Name (PCDV, Zero) |
|
Method (WDOG, 1, NotSerialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
PCDV = PTIM /* \WMI0.PTIM */ |
|
Return (0x3C) |
|
} |
|
|
|
If ((Arg0 == One)) |
|
{ |
|
If (\_SB.LID._LID ()) |
|
{ |
|
PCDV = PTIM /* \WMI0.PTIM */ |
|
Return (One) |
|
} |
|
|
|
If ((\_TZ.RLTM () < PTMP)) |
|
{ |
|
PCDV = PTIM /* \WMI0.PTIM */ |
|
Return (One) |
|
} |
|
|
|
PCDV-- |
|
If ((PCDV == Zero)) |
|
{ |
|
PCDV = PTIM /* \WMI0.PTIM */ |
|
NTFY (0x6D) |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (_WED, 1, NotSerialized) // _Wxx: Wake Event, xx=0x00-0xFF |
|
{ |
|
Return (Arg0) |
|
} |
|
|
|
Method (WMIG, 3, Serialized) |
|
{ |
|
\_SB.ATKD.AGFN (Arg0) |
|
Local0 = CWMI (Arg0) |
|
If ((Local0 == Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local1 = ((Local0 >> 0x10) & 0xFFFF) |
|
Local0 &= 0xFFFF |
|
If (CWAC (Arg0)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If (((Local0 == 0x15) && (Local1 == 0x05))) |
|
{ |
|
WSMI (Arg2) |
|
Return (Zero) |
|
} |
|
|
|
If (((Local0 == 0x64) | (Local0 == 0x67))) |
|
{ |
|
WSMI (Arg2) |
|
Return (Zero) |
|
} |
|
|
|
Local2 = \_SB.ATKD.GLEN (Arg0) |
|
WGLN (Arg0, Arg1, Local0, Local1, Arg2) |
|
OperationRegion (\WMIF, SystemMemory, Arg0, 0x0100) |
|
Field (WMIF, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
STAS, 8, |
|
REST, 8 |
|
} |
|
|
|
If ((STAS != One)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
STAS = 0x82 |
|
REST = One |
|
Return (Zero) |
|
} |
|
|
|
Method (CWMI, 1, NotSerialized) |
|
{ |
|
OperationRegion (\WMID, SystemMemory, Arg0, 0x0100) |
|
Field (WMID, DWordAcc, NoLock, Preserve) |
|
{ |
|
FUNC, 32, |
|
LEN, 16, |
|
STAS, 8, |
|
REST, 8 |
|
} |
|
|
|
If (((REST & One) == Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
STAS = One |
|
REST = Zero |
|
Return (FUNC) /* \WMI0.CWMI.FUNC */ |
|
} |
|
|
|
Method (CWAC, 1, NotSerialized) |
|
{ |
|
OperationRegion (\WMIC, SystemMemory, Arg0, 0x0100) |
|
Field (WMIC, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x07), |
|
REST, 8 |
|
} |
|
|
|
ISMI (0xE4) |
|
Return (REST) /* \WMI0.CWAC.REST */ |
|
} |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Method (QNTY, 1, NotSerialized) |
|
{ |
|
Return (One) |
|
} |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Method (WGLN, 5, NotSerialized) |
|
{ |
|
\_SB.ATKD.WFLH (Arg0, Arg1, Arg2, Arg3, Arg4) |
|
\_SB.ATKD.GVBD (Arg0, Arg1, Arg2, Arg3, Arg4) |
|
} |
|
} |
|
|
|
Scope (WMI0) |
|
{ |
|
Method (WINI, 1, NotSerialized) |
|
{ |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Device (LID) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID |
|
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake |
|
{ |
|
0x10, |
|
0x05 |
|
}) |
|
Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake |
|
{ |
|
\WMI0.LDST = Arg0 |
|
} |
|
|
|
Method (_LID, 0, NotSerialized) // _LID: Lid Status |
|
{ |
|
Local0 = One |
|
Local0 = ^^PCI0.SBRG.HEC.RPIN (0x04, 0x06) |
|
If ((Local0 == Ones)) |
|
{ |
|
Local0 = One |
|
} |
|
|
|
Return (Local0) |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (_Q81, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
Notify (LID, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Device (PWRB) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (0x0F) |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB) |
|
{ |
|
Device (SLPB) |
|
{ |
|
Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */) // _HID: Hardware ID |
|
Name (_STA, 0x0F) // _STA: Status |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (GBTT, 1, Serialized) |
|
{ |
|
If ((Arg0 == Zero)) |
|
{ |
|
Local0 = EB0T /* \_SB_.PCI0.SBRG.HEC_.EB0T */ |
|
} |
|
Else |
|
{ |
|
Local0 = EB1T /* \_SB_.PCI0.SBRG.HEC_.EB1T */ |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (RRAM, 1, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
Local0 = Arg0 |
|
Local1 = (Local0 & 0xFF) |
|
Local0 >>= 0x08 |
|
Local0 &= 0xFF |
|
CDT2 = Local1 |
|
CDT1 = Local0 |
|
CMD1 = 0x80 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
Local1 = 0xFF |
|
While ((Local0 && (Local1 & CMD1))) |
|
{ |
|
Sleep (0x02) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (WRAM, 2, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
Local0 = Arg0 |
|
Local1 = (Local0 & 0xFF) |
|
Local0 >>= 0x08 |
|
Local0 &= 0xFF |
|
CDT2 = Local1 |
|
CDT1 = Local0 |
|
CDT3 = Arg1 |
|
CMD1 = 0x81 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (STBR, 0, Serialized) |
|
{ |
|
Local0 = (\WMI0.VGAF & One) |
|
ISMI (0x9A) |
|
} |
|
|
|
Method (SBRV, 1, Serialized) |
|
{ |
|
WBOV (Zero, Arg0) |
|
} |
|
|
|
Name (DECF, Zero) |
|
Method (SFNV, 2, Serialized) |
|
{ |
|
Local1 = RRAM (0x0521) |
|
Local2 = RRAM (0x0522) |
|
Local3 = RRAM (0x0523) |
|
Local4 = RRAM (0x0524) |
|
If ((Arg0 == Zero)) |
|
{ |
|
Local3 |= 0x80 |
|
Local4 |= 0x80 |
|
If ((Local1 & 0x80)) |
|
{ |
|
Local0 = (Local1 >> 0x04) |
|
Local0 &= 0x03 |
|
If ((Local0 == Zero)) |
|
{ |
|
WRAM (0x0523, Local3) |
|
} |
|
ElseIf ((Local0 == One)) |
|
{ |
|
WRAM (0x0524, Local4) |
|
} |
|
ElseIf ((Local0 == 0x02)) |
|
{ |
|
WRAM (0x0523, Local3) |
|
WRAM (0x0524, Local4) |
|
} |
|
} |
|
|
|
If ((Local2 & 0x80)) |
|
{ |
|
Local0 = (Local2 >> 0x04) |
|
Local0 &= 0x03 |
|
If ((Local0 == Zero)) |
|
{ |
|
WRAM (0x0523, Local3) |
|
} |
|
ElseIf ((Local0 == One)) |
|
{ |
|
WRAM (0x0524, Local4) |
|
} |
|
ElseIf ((Local0 == 0x02)) |
|
{ |
|
WRAM (0x0523, Local3) |
|
WRAM (0x0524, Local4) |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Local3 &= 0x7F |
|
Local4 &= 0x7F |
|
WRAM (0x0523, Local3) |
|
WRAM (0x0524, Local4) |
|
WFOV (Arg0--, Arg1) |
|
Return (Zero) |
|
} |
|
|
|
Method (SPIN, 3, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
Local0 = Arg0 |
|
Local1 = Arg1 |
|
If ((Local0 >= 0x41)) |
|
{ |
|
Local0 -= 0x41 |
|
} |
|
|
|
Local0 <<= 0x04 |
|
Local0 |= Local1 |
|
CDT2 = Local0 |
|
If ((Arg2 == One)) |
|
{ |
|
Local2 = 0x20 |
|
} |
|
Else |
|
{ |
|
Local2 = 0x40 |
|
} |
|
|
|
CDT1 = Local2 |
|
CMD1 = 0x87 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (RPIN, 2, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
Local0 = Arg0 |
|
If ((Local0 >= 0x41)) |
|
{ |
|
Local0 -= 0x41 |
|
} |
|
|
|
Local0 <<= 0x04 |
|
Local0 |= Arg1 |
|
CDT2 = Local0 |
|
CDT1 = Zero |
|
CMD1 = 0x87 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Name (WRQK, 0x02) |
|
Name (RDQK, 0x03) |
|
Name (SDBT, 0x04) |
|
Name (RCBT, 0x05) |
|
Name (WRBT, 0x06) |
|
Name (RDBT, 0x07) |
|
Name (WRWD, 0x08) |
|
Name (RDWD, 0x09) |
|
Name (WRBL, 0x0A) |
|
Name (RDBL, 0x0B) |
|
Name (WBLP, 0x8A) |
|
Name (RBLP, 0x8B) |
|
Name (PCLL, 0x0C) |
|
Name (GOOD, Zero) |
|
Name (UKER, 0x07) |
|
Name (DAER, 0x10) |
|
Name (DERR, 0x11) |
|
Name (CMDN, 0x12) |
|
Name (UKE2, 0x13) |
|
Name (DADN, 0x17) |
|
Name (SBTO, 0x18) |
|
Name (USPT, 0x19) |
|
Name (SBBY, 0x1A) |
|
Method (SMBR, 3, Serialized) |
|
{ |
|
Local0 = Package (0x03) |
|
{ |
|
0x07, |
|
Zero, |
|
Zero |
|
} |
|
OperationRegion (ECBD, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECBD, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x40), |
|
BCNT, 8, |
|
BDAT, 256 |
|
} |
|
|
|
If ((Arg0 != RDBL)) |
|
{ |
|
If ((Arg0 != RDWD)) |
|
{ |
|
If ((Arg0 != RDBT)) |
|
{ |
|
If ((Arg0 != RCBT)) |
|
{ |
|
If ((Arg0 != RDQK)) |
|
{ |
|
If ((Arg0 != RBLP)) |
|
{ |
|
Return (Local0) |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Zero |
|
CDT2 = Arg0 |
|
Local1 = (Arg1 << One) |
|
CDT3 = Local1 |
|
CDT4 = Arg2 |
|
CDT5 = Zero |
|
CMD1 = 0x9A |
|
ESEM = 0x0F |
|
Local2 = 0x7F |
|
While ((Local2 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local2-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 [Zero] = GOOD /* \_SB_.PCI0.SBRG.HEC_.GOOD */ |
|
If ((Arg0 == RDBL)) |
|
{ |
|
Local0 [One] = BCNT /* \_SB_.PCI0.SBRG.HEC_.SMBR.BCNT */ |
|
Local0 [0x02] = BDAT /* \_SB_.PCI0.SBRG.HEC_.SMBR.BDAT */ |
|
} |
|
|
|
If ((Arg0 == RBLP)) |
|
{ |
|
Local0 [One] = BCNT /* \_SB_.PCI0.SBRG.HEC_.SMBR.BCNT */ |
|
Local0 [0x02] = BDAT /* \_SB_.PCI0.SBRG.HEC_.SMBR.BDAT */ |
|
} |
|
|
|
If ((Arg0 == RDWD)) |
|
{ |
|
Local0 [One] = 0x02 |
|
Local1 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
Local1 <<= 0x08 |
|
Local1 |= EDA2 /* \_SB_.PCI0.SBRG.HEC_.EDA2 */ |
|
Local0 [0x02] = Local1 |
|
} |
|
|
|
If ((Arg0 == RDBT)) |
|
{ |
|
Local0 [One] = One |
|
Local0 [0x02] = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
|
|
If ((Arg0 == RCBT)) |
|
{ |
|
Local0 [One] = One |
|
Local0 [0x02] = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (SMBW, 5, Serialized) |
|
{ |
|
Local0 = Package (0x03) |
|
{ |
|
0x07, |
|
Zero, |
|
Zero |
|
} |
|
OperationRegion (ECBD, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECBD, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x07), |
|
BDAT, 256 |
|
} |
|
|
|
If ((Arg0 != WRBL)) |
|
{ |
|
If ((Arg0 != WRWD)) |
|
{ |
|
If ((Arg0 != WRBT)) |
|
{ |
|
If ((Arg0 != SDBT)) |
|
{ |
|
If ((Arg0 != WRQK)) |
|
{ |
|
If ((Arg0 != WBLP)) |
|
{ |
|
Return (Local0) |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Zero |
|
CDT2 = Arg0 |
|
Local1 = (Arg1 << One) |
|
CDT3 = Local1 |
|
CDT4 = Arg2 |
|
If ((Arg0 == WRBL)) |
|
{ |
|
CDT5 = Arg3 |
|
BDAT = Arg4 |
|
} |
|
|
|
If ((Arg0 == WBLP)) |
|
{ |
|
CDT5 = Arg3 |
|
BDAT = Arg4 |
|
} |
|
|
|
If ((Arg0 == WRWD)) |
|
{ |
|
CDT5 = 0x02 |
|
Local1 = Arg4 |
|
Local1 >>= 0x08 |
|
CDT6 = Local1 |
|
Local1 = (Arg4 & 0x0F) |
|
CDT7 = Local1 |
|
} |
|
|
|
If ((Arg0 == WRBT)) |
|
{ |
|
CDT5 = Zero |
|
CDT6 = Arg4 |
|
} |
|
|
|
If ((Arg0 == SDBT)) |
|
{ |
|
CDT5 = Zero |
|
CDT6 = Arg4 |
|
} |
|
|
|
CMD1 = 0x9A |
|
ESEM = 0x0F |
|
Local2 = 0x7F |
|
While ((Local2 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local2-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 [Zero] = Zero |
|
} |
|
Else |
|
{ |
|
Local0 [Zero] = UKER /* \_SB_.PCI0.SBRG.HEC_.UKER */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (SMR1, 3, Serialized) |
|
{ |
|
Local0 = Package (0x03) |
|
{ |
|
0x07, |
|
Zero, |
|
Zero |
|
} |
|
If ((Arg0 != RDBL)) |
|
{ |
|
If ((Arg0 != RDWD)) |
|
{ |
|
If ((Arg0 != RDBT)) |
|
{ |
|
Return (Local0) |
|
} |
|
} |
|
} |
|
|
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = One |
|
CDT2 = Arg0 |
|
Local1 = (Arg1 << One) |
|
CDT3 = Local1 |
|
CDT4 = Arg2 |
|
CDT5 = Zero |
|
CMD1 = 0x9A |
|
ESEM = 0x0F |
|
Local2 = 0x7F |
|
While ((Local2 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local2-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 [Zero] = GOOD /* \_SB_.PCI0.SBRG.HEC_.GOOD */ |
|
If ((Arg0 == RDBL)) |
|
{ |
|
OperationRegion (ECBD, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECBD, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x40), |
|
BCNT, 8, |
|
BDAT, 256 |
|
} |
|
|
|
Local0 [One] = BCNT /* \_SB_.PCI0.SBRG.HEC_.SMR1.BCNT */ |
|
Local0 [0x02] = BDAT /* \_SB_.PCI0.SBRG.HEC_.SMR1.BDAT */ |
|
} |
|
|
|
If ((Arg0 == RDWD)) |
|
{ |
|
Local0 [One] = 0x02 |
|
Local1 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
Local1 <<= 0x08 |
|
Local1 |= EDA2 /* \_SB_.PCI0.SBRG.HEC_.EDA2 */ |
|
Local0 [0x02] = Local1 |
|
} |
|
|
|
If ((Arg0 == RDBT)) |
|
{ |
|
Local0 [One] = One |
|
Local0 [0x02] = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (SMW1, 5, Serialized) |
|
{ |
|
Local0 = Package (0x03) |
|
{ |
|
0x07, |
|
Zero, |
|
Zero |
|
} |
|
If ((Arg0 != WRBL)) |
|
{ |
|
If ((Arg0 != WRWD)) |
|
{ |
|
If ((Arg0 != WRBT)) |
|
{ |
|
Return (Local0) |
|
} |
|
} |
|
} |
|
|
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = One |
|
CDT2 = Arg0 |
|
Local1 = (Arg1 << One) |
|
CDT3 = Local1 |
|
CDT4 = Arg2 |
|
If ((Arg0 == WRBL)) |
|
{ |
|
CDT5 = Arg3 |
|
OperationRegion (ECBD, SystemMemory, \WMI0.HEM2, 0x80) |
|
Field (ECBD, ByteAcc, Lock, Preserve) |
|
{ |
|
Offset (0x07), |
|
BDAT, 256 |
|
} |
|
|
|
BDAT = Arg4 |
|
} |
|
|
|
If ((Arg0 == WRWD)) |
|
{ |
|
CDT5 = Zero |
|
CDT6 = Arg4 |
|
} |
|
|
|
If ((Arg0 == WRBT)) |
|
{ |
|
CDT5 = Zero |
|
CDT6 = Arg4 |
|
} |
|
|
|
CMD1 = 0x9A |
|
ESEM = 0x0F |
|
Local2 = 0x7F |
|
While ((Local2 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local2-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 [Zero] = Zero |
|
} |
|
Else |
|
{ |
|
Local0 [Zero] = UKER /* \_SB_.PCI0.SBRG.HEC_.UKER */ |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Mutex (MUEP, 0x00) |
|
Method (RBEP, 1, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (WBEP, 2, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (SDAC, 2, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CDT2 = Arg1 |
|
CMD1 = 0x86 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (ECXT, 6, NotSerialized) |
|
{ |
|
Local1 = Package (0x06) |
|
{ |
|
0x10, |
|
Zero, |
|
Zero, |
|
Zero, |
|
Zero, |
|
Zero |
|
} |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg1 |
|
CDT2 = Arg2 |
|
CDT3 = Arg3 |
|
CDT4 = Arg4 |
|
CDT5 = Arg5 |
|
CMD1 = Arg0 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
Local2 = 0xFF |
|
While ((Local0 && (Local2 & CMD1))) |
|
{ |
|
Sleep (0x02) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local1 [Zero] = Zero |
|
Local1 [One] = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
Local1 [0x02] = EDA2 /* \_SB_.PCI0.SBRG.HEC_.EDA2 */ |
|
Local1 [0x03] = EDA3 /* \_SB_.PCI0.SBRG.HEC_.EDA3 */ |
|
Local1 [0x04] = EDA4 /* \_SB_.PCI0.SBRG.HEC_.EDA4 */ |
|
Local1 [0x05] = EDA5 /* \_SB_.PCI0.SBRG.HEC_.EDA5 */ |
|
} |
|
Else |
|
{ |
|
Local1 [Zero] = 0x10 |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
Method (ECSB, 6, NotSerialized) |
|
{ |
|
Local1 = Package (0x05) |
|
{ |
|
0x11, |
|
Zero, |
|
Zero, |
|
Zero, |
|
Zero |
|
} |
|
If ((Arg0 > One)) |
|
{ |
|
Return (Local1) |
|
} |
|
|
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CDT2 = Arg1 |
|
CDT3 = Arg2 |
|
CDT4 = Arg3 |
|
CDT5 = Zero |
|
CDT6 = Arg4 |
|
CDT7 = Arg5 |
|
CMD1 = 0x9A |
|
ESEM = 0x0F |
|
Local2 = 0x7F |
|
While ((Local2 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local2-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local1 [Zero] = Zero |
|
Local1 [One] = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
Local1 [0x02] = EDA2 /* \_SB_.PCI0.SBRG.HEC_.EDA2 */ |
|
Local1 [0x03] = EDA3 /* \_SB_.PCI0.SBRG.HEC_.EDA3 */ |
|
Local1 [0x04] = EDA4 /* \_SB_.PCI0.SBRG.HEC_.EDA4 */ |
|
} |
|
Else |
|
{ |
|
Local1 [Zero] = 0x10 |
|
} |
|
|
|
Release (MUEC) |
|
} |
|
|
|
Return (Local1) |
|
} |
|
|
|
OperationRegion (KAID, SystemIO, 0x025C, One) |
|
Field (KAID, ByteAcc, NoLock, Preserve) |
|
{ |
|
AEID, 8 |
|
} |
|
|
|
OperationRegion (KAIC, SystemIO, 0x025D, One) |
|
Field (KAIC, ByteAcc, NoLock, Preserve) |
|
{ |
|
AEIC, 8 |
|
} |
|
|
|
Method (WEIE, 0, Serialized) |
|
{ |
|
Local0 = 0x4000 |
|
Local1 = (AEIC & 0x02) |
|
While (((Local0 != Zero) && (Local1 == 0x02))) |
|
{ |
|
Local1 = (AEIC & 0x02) |
|
Local0-- |
|
} |
|
} |
|
|
|
Method (WEOF, 0, Serialized) |
|
{ |
|
Local0 = 0x4000 |
|
Local1 = (AEIC & One) |
|
While (((Local0 != Zero) && (Local1 == Zero))) |
|
{ |
|
Local1 = (AEIC & One) |
|
Local0-- |
|
} |
|
} |
|
|
|
Method (RFOV, 1, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CMD1 = 0x83 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (WFOV, 2, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CDT2 = Arg1 |
|
CMD1 = 0x84 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (RBOV, 1, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CMD1 = 0x85 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = EDA1 /* \_SB_.PCI0.SBRG.HEC_.EDA1 */ |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (WBOV, 2, Serialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CDT2 = Arg1 |
|
CMD1 = 0x86 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (PKEN, 1, NotSerialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CMD1 = 0xB1 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
|
|
Method (FNLK, 1, NotSerialized) |
|
{ |
|
If ((Acquire (MUEC, 0xFFFF) == Zero)) |
|
{ |
|
Local6 = 0x7F |
|
Local7 = 0x0F |
|
While ((Local6 && (Local7 & ESEM))) |
|
{ |
|
Sleep (0x02) |
|
Local6-- |
|
} |
|
|
|
CDT1 = Arg0 |
|
CMD1 = 0xB0 |
|
ESEM = 0x0F |
|
Local0 = 0x7F |
|
While ((Local0 && CMD1)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
If ((CMD1 == Zero)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Release (MUEC) |
|
Return (Local0) |
|
} |
|
|
|
Return (Ones) |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Name (TSP, 0x0A) |
|
Name (TC1, 0x02) |
|
Name (TC2, 0x0A) |
|
Name (PSVF, Zero) |
|
Name (CRTF, Zero) |
|
} |
|
|
|
Scope (_TZ) |
|
{ |
|
Method (KELV, 1, NotSerialized) |
|
{ |
|
Local0 = (Arg0 & 0xFF) |
|
If ((Local0 >= 0x80)) |
|
{ |
|
Local0 = (0x0100 - Local0) |
|
Local0 *= 0x0A |
|
Local0 = (0x0AAC - Local0) |
|
Return (Local0) |
|
} |
|
|
|
Local0 *= 0x0A |
|
Local0 += 0x0AAC |
|
Return (Local0) |
|
} |
|
|
|
Method (CELC, 1, NotSerialized) |
|
{ |
|
Local0 = (Arg0 - 0x0AAC) |
|
Divide (Local0, 0x0A, Local1, Local0) |
|
Return (Local0) |
|
} |
|
|
|
Name (PLCY, Zero) |
|
ThermalZone (THRM) |
|
{ |
|
Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature |
|
{ |
|
RCRT () |
|
Return (KELV (\WMI0.TCRT)) |
|
} |
|
|
|
Method (_TMP, 0, NotSerialized) // _TMP: Temperature |
|
{ |
|
Local1 = 0x05 |
|
While (Local1) |
|
{ |
|
Local0 = RTMP () |
|
If ((Local0 > \WMI0.TCRT)) |
|
{ |
|
Local1-- |
|
} |
|
Else |
|
{ |
|
Local1 = Zero |
|
} |
|
} |
|
|
|
Local2 = \WMI0.TCRT |
|
Local2-- |
|
If ((Local0 > Local2)) |
|
{ |
|
If ((PSVF == One)) |
|
{ |
|
Return (KELV (Local2)) |
|
} |
|
ElseIf ((CRTF == One)) |
|
{ |
|
Return (KELV (Local0)) |
|
} |
|
} |
|
|
|
Return (KELV (Local0)) |
|
} |
|
|
|
Method (_PSL, 0, NotSerialized) // _PSL: Passive List |
|
{ |
|
If ((\WMI0.CPUN == 0x04)) |
|
{ |
|
Return (Package (0x04) |
|
{ |
|
\_PR.P000, |
|
\_PR.P001, |
|
\_PR.P002, |
|
\_PR.P003 |
|
}) |
|
} |
|
|
|
If ((\WMI0.CPUN == 0x02)) |
|
{ |
|
Return (Package (0x02) |
|
{ |
|
\_PR.P000, |
|
\_PR.P001 |
|
}) |
|
} |
|
|
|
Return (Package (0x01) |
|
{ |
|
\_PR.P000 |
|
}) |
|
} |
|
|
|
Method (_TSP, 0, NotSerialized) // _TSP: Thermal Sampling Period |
|
{ |
|
Local0 = (TSP * 0x0A) |
|
Return (Local0) |
|
} |
|
|
|
Method (_TC1, 0, NotSerialized) // _TC1: Thermal Constant 1 |
|
{ |
|
Return (TC1) /* \TC1_ */ |
|
} |
|
|
|
Method (_TC2, 0, NotSerialized) // _TC2: Thermal Constant 2 |
|
{ |
|
Return (TC2) /* \TC2_ */ |
|
} |
|
|
|
Method (_PSV, 0, NotSerialized) // _PSV: Passive Temperature |
|
{ |
|
RPSV () |
|
If (PLCY) |
|
{ |
|
Return (KELV (\WMI0.PPSV)) |
|
} |
|
Else |
|
{ |
|
Return (KELV (\WMI0.TPSV)) |
|
} |
|
} |
|
|
|
Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy |
|
{ |
|
PLCY = Zero |
|
Notify (THRM, 0x81) // Thermal Trip Point Change |
|
} |
|
} |
|
} |
|
|
|
Scope (_TZ) |
|
{ |
|
Name (ATMP, 0x3C) |
|
Name (LTMP, 0x3C) |
|
Name (FANS, Zero) |
|
Method (RTMP, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.SBRG.HEC.ECAV ()) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.TH0R |
|
If ((Local0 < 0x80)) |
|
{ |
|
LTMP = Local0 |
|
} |
|
} |
|
|
|
Return (LTMP) /* \_TZ_.LTMP */ |
|
} |
|
|
|
Method (RLTM, 0, NotSerialized) |
|
{ |
|
Return (ATMP) /* \_TZ_.ATMP */ |
|
} |
|
|
|
Method (RCRT, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.SBRG.HEC.ECAV ()) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.ECRT |
|
If ((Local0 < 0x80)) |
|
{ |
|
\WMI0.TCRT = Local0 |
|
} |
|
} |
|
} |
|
|
|
Method (RPSV, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.SBRG.HEC.ECAV ()) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.EPSV |
|
If ((Local0 < 0x80)) |
|
{ |
|
\WMI0.TPSV = Local0 |
|
} |
|
} |
|
} |
|
|
|
Method (RFAN, 1, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.SBRG.HEC.ECAV ()) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.TACH (Arg0) |
|
Divide (Local0, 0x64, Local1, Local0) |
|
Local0 += One |
|
If ((Local0 <= 0x3C)) |
|
{ |
|
FANS = Local0 |
|
} |
|
Else |
|
{ |
|
Local0 = FANS /* \_TZ_.FANS */ |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (RFSE, 0, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (TCHG, 0, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (THDL, 0, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (TMSS, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (TMSW, 1, NotSerialized) |
|
{ |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (PWAC, 1, Serialized) |
|
{ |
|
If ((Arg0 >= 0x0B)) |
|
{ |
|
Local0 = 0x0A |
|
} |
|
Else |
|
{ |
|
Local0 = Arg0 |
|
} |
|
|
|
If ((Local0 == Zero)) |
|
{ |
|
Return (\WMI0.AB00) |
|
} |
|
|
|
If ((Local0 == One)) |
|
{ |
|
Return (\WMI0.AB01) |
|
} |
|
|
|
If ((Local0 == 0x02)) |
|
{ |
|
Return (\WMI0.AB02) |
|
} |
|
|
|
If ((Local0 == 0x03)) |
|
{ |
|
Return (\WMI0.AB03) |
|
} |
|
|
|
If ((Local0 == 0x04)) |
|
{ |
|
Return (\WMI0.AB04) |
|
} |
|
|
|
If ((Local0 == 0x05)) |
|
{ |
|
Return (\WMI0.AB05) |
|
} |
|
|
|
If ((Local0 == 0x06)) |
|
{ |
|
Return (\WMI0.AB06) |
|
} |
|
|
|
If ((Local0 == 0x07)) |
|
{ |
|
Return (\WMI0.AB07) |
|
} |
|
|
|
If ((Local0 == 0x08)) |
|
{ |
|
Return (\WMI0.AB08) |
|
} |
|
|
|
If ((Local0 == 0x09)) |
|
{ |
|
Return (\WMI0.AB09) |
|
} |
|
|
|
If ((Local0 == 0x0A)) |
|
{ |
|
Return (\WMI0.AB0A) |
|
} |
|
|
|
If ((Local0 == 0x0B)) |
|
{ |
|
Return (\WMI0.AB0B) |
|
} |
|
|
|
If ((Local0 == 0x0C)) |
|
{ |
|
Return (\WMI0.AB0C) |
|
} |
|
|
|
If ((Local0 == 0x0D)) |
|
{ |
|
Return (\WMI0.AB0D) |
|
} |
|
|
|
If ((Local0 == 0x0E)) |
|
{ |
|
Return (\WMI0.AB0E) |
|
} |
|
|
|
If ((Local0 == 0x0F)) |
|
{ |
|
Return (\WMI0.AB0F) |
|
} |
|
|
|
If ((Local0 == 0x10)) |
|
{ |
|
Return (\WMI0.AB10) |
|
} |
|
|
|
If ((Local0 == 0x11)) |
|
{ |
|
Return (\WMI0.AB11) |
|
} |
|
|
|
If ((Local0 == 0x12)) |
|
{ |
|
Return (\WMI0.AB12) |
|
} |
|
|
|
If ((Local0 == 0x13)) |
|
{ |
|
Return (\WMI0.AB13) |
|
} |
|
|
|
If ((Local0 == 0x14)) |
|
{ |
|
Return (\WMI0.AB14) |
|
} |
|
|
|
If ((Local0 == 0x15)) |
|
{ |
|
Return (\WMI0.AB15) |
|
} |
|
|
|
If ((Local0 == 0x16)) |
|
{ |
|
Return (\WMI0.AB16) |
|
} |
|
|
|
If ((Local0 == 0x17)) |
|
{ |
|
Return (\WMI0.AB17) |
|
} |
|
|
|
If ((Local0 == 0x18)) |
|
{ |
|
Return (\WMI0.AB18) |
|
} |
|
|
|
If ((Local0 == 0x19)) |
|
{ |
|
Return (\WMI0.AB19) |
|
} |
|
|
|
If ((Local0 == 0x1A)) |
|
{ |
|
Return (\WMI0.AB1A) |
|
} |
|
|
|
If ((Local0 == 0x1B)) |
|
{ |
|
Return (\WMI0.AB1B) |
|
} |
|
|
|
If ((Local0 == 0x1C)) |
|
{ |
|
Return (\WMI0.AB1C) |
|
} |
|
|
|
If ((Local0 == 0x1D)) |
|
{ |
|
Return (\WMI0.AB1D) |
|
} |
|
|
|
If ((Local0 == 0x1E)) |
|
{ |
|
Return (\WMI0.AB1E) |
|
} |
|
|
|
If ((Local0 == 0x1F)) |
|
{ |
|
Return (\WMI0.AB1F) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (PWDC, 1, Serialized) |
|
{ |
|
If ((Arg0 >= 0x0B)) |
|
{ |
|
Local0 = 0x0A |
|
} |
|
Else |
|
{ |
|
Local0 = Arg0 |
|
} |
|
|
|
If ((Local0 == Zero)) |
|
{ |
|
Return (\WMI0.DB00) |
|
} |
|
|
|
If ((Local0 == One)) |
|
{ |
|
Return (\WMI0.DB01) |
|
} |
|
|
|
If ((Local0 == 0x02)) |
|
{ |
|
Return (\WMI0.DB02) |
|
} |
|
|
|
If ((Local0 == 0x03)) |
|
{ |
|
Return (\WMI0.DB03) |
|
} |
|
|
|
If ((Local0 == 0x04)) |
|
{ |
|
Return (\WMI0.DB04) |
|
} |
|
|
|
If ((Local0 == 0x05)) |
|
{ |
|
Return (\WMI0.DB05) |
|
} |
|
|
|
If ((Local0 == 0x06)) |
|
{ |
|
Return (\WMI0.DB06) |
|
} |
|
|
|
If ((Local0 == 0x07)) |
|
{ |
|
Return (\WMI0.DB07) |
|
} |
|
|
|
If ((Local0 == 0x08)) |
|
{ |
|
Return (\WMI0.DB08) |
|
} |
|
|
|
If ((Local0 == 0x09)) |
|
{ |
|
Return (\WMI0.DB09) |
|
} |
|
|
|
If ((Local0 == 0x0A)) |
|
{ |
|
Return (\WMI0.DB0A) |
|
} |
|
|
|
If ((Local0 == 0x0B)) |
|
{ |
|
Return (\WMI0.DB0B) |
|
} |
|
|
|
If ((Local0 == 0x0C)) |
|
{ |
|
Return (\WMI0.DB0C) |
|
} |
|
|
|
If ((Local0 == 0x0D)) |
|
{ |
|
Return (\WMI0.DB0D) |
|
} |
|
|
|
If ((Local0 == 0x0E)) |
|
{ |
|
Return (\WMI0.DB0E) |
|
} |
|
|
|
If ((Local0 == 0x0F)) |
|
{ |
|
Return (\WMI0.DB0F) |
|
} |
|
|
|
If ((Local0 == 0x10)) |
|
{ |
|
Return (\WMI0.DB10) |
|
} |
|
|
|
If ((Local0 == 0x11)) |
|
{ |
|
Return (\WMI0.DB11) |
|
} |
|
|
|
If ((Local0 == 0x12)) |
|
{ |
|
Return (\WMI0.DB12) |
|
} |
|
|
|
If ((Local0 == 0x13)) |
|
{ |
|
Return (\WMI0.DB13) |
|
} |
|
|
|
If ((Local0 == 0x14)) |
|
{ |
|
Return (\WMI0.DB14) |
|
} |
|
|
|
If ((Local0 == 0x15)) |
|
{ |
|
Return (\WMI0.DB15) |
|
} |
|
|
|
If ((Local0 == 0x16)) |
|
{ |
|
Return (\WMI0.DB16) |
|
} |
|
|
|
If ((Local0 == 0x17)) |
|
{ |
|
Return (\WMI0.DB17) |
|
} |
|
|
|
If ((Local0 == 0x18)) |
|
{ |
|
Return (\WMI0.DB18) |
|
} |
|
|
|
If ((Local0 == 0x19)) |
|
{ |
|
Return (\WMI0.DB19) |
|
} |
|
|
|
If ((Local0 == 0x1A)) |
|
{ |
|
Return (\WMI0.DB1A) |
|
} |
|
|
|
If ((Local0 == 0x1B)) |
|
{ |
|
Return (\WMI0.DB1B) |
|
} |
|
|
|
If ((Local0 == 0x1C)) |
|
{ |
|
Return (\WMI0.DB1C) |
|
} |
|
|
|
If ((Local0 == 0x1D)) |
|
{ |
|
Return (\WMI0.DB1D) |
|
} |
|
|
|
If ((Local0 == 0x1E)) |
|
{ |
|
Return (\WMI0.DB1E) |
|
} |
|
|
|
If ((Local0 == 0x1F)) |
|
{ |
|
Return (\WMI0.DB1F) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (ACPS, 0, Serialized) |
|
{ |
|
Return ((GPWS () & One)) |
|
} |
|
|
|
Method (DCPS, 1, Serialized) |
|
{ |
|
Local0 = GPWS () |
|
If (Arg0) |
|
{ |
|
Local0 &= 0x04 |
|
} |
|
Else |
|
{ |
|
Local0 &= 0x02 |
|
} |
|
|
|
If (Local0) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (GPWS, 0, Serialized) |
|
{ |
|
Local0 = EPWS /* \_SB_.PCI0.SBRG.HEC_.EPWS */ |
|
Return (Local0) |
|
} |
|
|
|
Method (BCHG, 1, Serialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
Local0 = EB1S /* \_SB_.PCI0.SBRG.HEC_.EB1S */ |
|
Local0 &= 0xFF |
|
If ((Local0 != 0xFF)) |
|
{ |
|
Local0 &= 0x02 |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Return (Local0) |
|
} |
|
Else |
|
{ |
|
If (ECAV ()) |
|
{ |
|
Local0 = EB0S /* \_SB_.PCI0.SBRG.HEC_.EB0S */ |
|
Local0 &= 0xFF |
|
If ((Local0 != 0xFF)) |
|
{ |
|
Local0 &= 0x02 |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Return (Local0) |
|
} |
|
} |
|
|
|
Method (BCLE, 1, Serialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
Local1 = EB1S /* \_SB_.PCI0.SBRG.HEC_.EB1S */ |
|
Local1 &= 0xFFFF |
|
If ((Local1 != 0xFFFF)) |
|
{ |
|
Local1 &= 0x16 |
|
If ((Local1 == 0x04)) |
|
{ |
|
Local0 = Zero |
|
} |
|
ElseIf ((Local1 == 0x02)) |
|
{ |
|
Local0 = One |
|
} |
|
ElseIf ((Local1 == 0x10)) |
|
{ |
|
Local0 = One |
|
} |
|
} |
|
|
|
Local0 = Ones |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
Else |
|
{ |
|
If (ECAV ()) |
|
{ |
|
Local1 = EB0S /* \_SB_.PCI0.SBRG.HEC_.EB0S */ |
|
Local1 &= 0xFFFF |
|
If ((Local1 != 0xFFFF)) |
|
{ |
|
Local1 &= 0x16 |
|
If ((Local1 == 0x04)) |
|
{ |
|
Local0 = Zero |
|
} |
|
ElseIf ((Local1 == 0x02)) |
|
{ |
|
Local0 = One |
|
} |
|
ElseIf ((Local1 == 0x10)) |
|
{ |
|
Local0 = One |
|
} |
|
} |
|
|
|
Local0 = Ones |
|
} |
|
Else |
|
{ |
|
Local0 = Ones |
|
} |
|
|
|
Return (Local0) |
|
} |
|
} |
|
|
|
Method (CHBT, 1, Serialized) |
|
{ |
|
Local1 = GBTT (Arg0) |
|
If ((Local1 == 0xFF)) |
|
{ |
|
Local0 = Zero |
|
} |
|
Else |
|
{ |
|
Local0 = (Local1 & 0x10) |
|
If (Local0) |
|
{ |
|
Local0 = One |
|
} |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (TACH, 1, NotSerialized) |
|
{ |
|
If (ECAV ()) |
|
{ |
|
If (Arg0) |
|
{ |
|
Local0 = F1TS /* \_SB_.PCI0.SBRG.HEC_.F1TS */ |
|
} |
|
Else |
|
{ |
|
Local0 = F0TS /* \_SB_.PCI0.SBRG.HEC_.F0TS */ |
|
} |
|
|
|
Local1 = 0x8CA0 |
|
Divide (Local1, Local0, Local2, Local0) |
|
Local0 *= 0x3C |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (EC0S, 1, NotSerialized) |
|
{ |
|
} |
|
|
|
Method (EC0W, 1, NotSerialized) |
|
{ |
|
If ((Arg0 <= 0x04)) |
|
{ |
|
\WMI0.ACPF = ACPS () |
|
\WMI0.DCPF = DCPS (Zero) |
|
PNOT () |
|
} |
|
} |
|
|
|
Name (FHKM, One) |
|
Method (FHKW, 0, Serialized) |
|
{ |
|
While (!FHKM) |
|
{ |
|
Sleep (0x0A) |
|
} |
|
|
|
FHKM = Zero |
|
} |
|
|
|
Method (FHKS, 0, Serialized) |
|
{ |
|
FHKM = One |
|
} |
|
|
|
Method (_Q0A, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
Notify (SLPB, 0x80) // Status Change |
|
} |
|
|
|
Method (_Q0B, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
^^^^ASHS.NTFY (0x88) |
|
Return (Zero) |
|
} |
|
|
|
If ((^^^^ATKD.WAPF & 0x04)) |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x88) |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = OHWR () |
|
If ((Local0 & 0x02)) |
|
{ |
|
If ((Local0 & One)) |
|
{ |
|
Local0 = One |
|
} |
|
Else |
|
{ |
|
Local0 = Zero |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = One |
|
} |
|
|
|
If (Local0) |
|
{ |
|
If ((^^^^ATKD.WAPF & One)) |
|
{ |
|
If ((\WMI0.WLDP && \WMI0.BTDP)) |
|
{ |
|
Local0 = \WMI0.WRST |
|
Local0 |= (\WMI0.BRST << One) |
|
Local0++ |
|
If ((Local0 > 0x03)) |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Local1 = DerefOf (WBTL [Local0]) |
|
If ((Local1 == Zero)) |
|
{ |
|
^^^^ATKD.NTFY (0x5D) |
|
Sleep (0x0DAC) |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
|
|
If ((Local1 == One)) |
|
{ |
|
^^^^ATKD.NTFY (0x5D) |
|
Sleep (0x0DAC) |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
|
|
If ((Local1 == 0x02)) |
|
{ |
|
^^^^ATKD.NTFY (0x5D) |
|
Sleep (0x0DAC) |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
|
|
If ((Local1 == 0x03)) |
|
{ |
|
^^^^ATKD.NTFY (0x5D) |
|
Sleep (0x0DAC) |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
} |
|
ElseIf (\WMI0.WLDP) |
|
{ |
|
^^^^ATKD.NTFY (0x5D) |
|
} |
|
ElseIf (\WMI0.BTDP) |
|
{ |
|
If (\WMI0.BRST) |
|
{ |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
Else |
|
{ |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
} |
|
} |
|
ElseIf ((\WMI0.WLDP && \WMI0.BTDP)) |
|
{ |
|
Local0 = \WMI0.WRST |
|
Local0 |= (\WMI0.BRST << One) |
|
Local0++ |
|
If ((Local0 > 0x03)) |
|
{ |
|
Local0 = Zero |
|
} |
|
|
|
Local1 = DerefOf (WBTL [Local0]) |
|
If ((Local1 == Zero)) |
|
{ |
|
OWLD (Zero) |
|
^^^^ATKD.NTFY (0x5F) |
|
Sleep (0x0DAC) |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
|
|
If ((Local1 == One)) |
|
{ |
|
OWLD (One) |
|
^^^^ATKD.NTFY (0x5E) |
|
Sleep (0x0DAC) |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
|
|
If ((Local1 == 0x02)) |
|
{ |
|
OWLD (Zero) |
|
^^^^ATKD.NTFY (0x5F) |
|
Sleep (0x0DAC) |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
|
|
If ((Local1 == 0x03)) |
|
{ |
|
OWLD (One) |
|
^^^^ATKD.NTFY (0x5E) |
|
Sleep (0x0DAC) |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
} |
|
ElseIf (\WMI0.WLDP) |
|
{ |
|
If (\WMI0.WRST) |
|
{ |
|
OWLD (Zero) |
|
^^^^ATKD.NTFY (0x5F) |
|
} |
|
Else |
|
{ |
|
OWLD (One) |
|
^^^^ATKD.NTFY (0x5E) |
|
} |
|
} |
|
ElseIf (\WMI0.BTDP) |
|
{ |
|
If (\WMI0.BRST) |
|
{ |
|
OBTD (Zero) |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
Else |
|
{ |
|
OBTD (One) |
|
^^^^ATKD.NTFY (0x7D) |
|
} |
|
} |
|
} |
|
Else |
|
{ |
|
If (\WMI0.WLDP) |
|
{ |
|
^^^^ATKD.NTFY (0x5F) |
|
} |
|
|
|
If ((\WMI0.WLDP && \WMI0.BTDP)) |
|
{ |
|
Sleep (0x0DAC) |
|
} |
|
|
|
If (\WMI0.BTDP) |
|
{ |
|
^^^^ATKD.NTFY (0x7E) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Name (WBTL, Package (0x04) |
|
{ |
|
Zero, |
|
One, |
|
0x02, |
|
0x03 |
|
}) |
|
Method (_Q0E, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSVT)) |
|
{ |
|
If (^^^VGA.PRST ()) |
|
{ |
|
^^^VGA.DWBL () |
|
} |
|
} |
|
Else |
|
{ |
|
If ((\WMI0.LBTN > Zero)) |
|
{ |
|
\WMI0.LBTN-- |
|
} |
|
|
|
If ((\WMI0.LBTN > 0x0A)) |
|
{ |
|
\WMI0.LBTN = 0x0A |
|
} |
|
|
|
STBR () |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY ((\WMI0.LBTN + 0x20)) |
|
} |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (_Q0F, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSVT)) |
|
{ |
|
If (^^^VGA.PRST ()) |
|
{ |
|
^^^VGA.UPBL () |
|
} |
|
} |
|
Else |
|
{ |
|
If ((\WMI0.LBTN < 0x0A)) |
|
{ |
|
\WMI0.LBTN++ |
|
} |
|
Else |
|
{ |
|
\WMI0.LBTN = 0x0A |
|
} |
|
|
|
STBR () |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY ((\WMI0.LBTN + 0x10)) |
|
} |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (_Q10, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (LIDP) |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x35) |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 = One |
|
Local0 = RPIN (0x05, 0x07) |
|
Local0 ^= One |
|
SPIN (0x05, 0x07, Local0) |
|
If (ATKP) |
|
{ |
|
Local0 = (0x34 - Local0) |
|
^^^^ATKD.NTFY (Local0) |
|
} |
|
} |
|
} |
|
|
|
Name (AVNC, Package (0x20) |
|
{ |
|
0x61, |
|
0x61, |
|
0x62, |
|
0x63, |
|
0x64, |
|
0x65, |
|
0x66, |
|
0x67, |
|
0x8C, |
|
0x8D, |
|
0x8E, |
|
0x90, |
|
0x8F, |
|
0x91, |
|
0x92, |
|
0x93, |
|
0xA0, |
|
0xA1, |
|
0xA2, |
|
0xA4, |
|
0xA3, |
|
0xA5, |
|
0xA6, |
|
0xA7, |
|
0x61, |
|
0x61, |
|
0x61, |
|
0x61, |
|
0x61, |
|
0x61, |
|
0x61, |
|
0x61 |
|
}) |
|
Name (LVNC, Package (0x04) |
|
{ |
|
Zero, |
|
0x61, |
|
0x62, |
|
0xA0 |
|
}) |
|
Name (FNF8, Zero) |
|
Method (_QD7, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (FNF8) |
|
{ |
|
ECXT (0xB8, 0x02, Zero, Zero, Zero, Zero) |
|
FNF8 = Zero |
|
} |
|
} |
|
|
|
Method (_Q11, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
If ((FNF8 == Zero)) |
|
{ |
|
ECXT (0xB8, Zero, Zero, Zero, Zero, Zero) |
|
ECXT (0xB8, One, Zero, Zero, Zero, Zero) |
|
FNF8 = One |
|
} |
|
Else |
|
{ |
|
ECXT (0xB8, One, Zero, Zero, Zero, Zero) |
|
} |
|
} |
|
Else |
|
{ |
|
FHKW () |
|
Local0 = ADVG () |
|
If (NATK ()) |
|
{ |
|
If ((OSFG == OSLX)) |
|
{ |
|
If ((Local0 == 0x10)) |
|
{ |
|
Local0 = 0x03 |
|
} |
|
|
|
Local1 = DerefOf (LVNC [Local0]) |
|
} |
|
Else |
|
{ |
|
Local1 = DerefOf (AVNC [Local0]) |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (Local1) |
|
} |
|
Else |
|
{ |
|
SWHG (Local0) |
|
} |
|
} |
|
Else |
|
{ |
|
SWHG (Local0) |
|
} |
|
|
|
FHKS () |
|
} |
|
} |
|
|
|
Method (_Q13, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
ECXT (0xB8, 0x03, Zero, Zero, Zero, Zero) |
|
} |
|
ElseIf (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x32) |
|
} |
|
} |
|
|
|
Method (_Q14, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
ECXT (0xB8, 0x04, Zero, Zero, Zero, Zero) |
|
} |
|
Else |
|
{ |
|
If ((\WMI0.AVOL < 0x0F)) |
|
{ |
|
\WMI0.AVOL++ |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x31) |
|
} |
|
} |
|
} |
|
|
|
Method (_Q15, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If ((OSFG >= OSW8)) |
|
{ |
|
ECXT (0xB8, 0x05, Zero, Zero, Zero, Zero) |
|
} |
|
Else |
|
{ |
|
If ((\WMI0.AVOL > Zero)) |
|
{ |
|
\WMI0.AVOL-- |
|
} |
|
|
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x30) |
|
} |
|
} |
|
} |
|
|
|
Method (_Q6C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x45) |
|
} |
|
} |
|
|
|
Method (_Q6B, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x43) |
|
} |
|
} |
|
|
|
Method (_Q6D, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x40) |
|
} |
|
} |
|
|
|
Method (_Q6E, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x41) |
|
} |
|
} |
|
|
|
Method (_Q12, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
Local0 = (One << 0x0E) |
|
If ((IOST & Local0)) |
|
{ |
|
^^^^ATKD.NTFY (0x6B) |
|
} |
|
Else |
|
{ |
|
^^^^ATKD.NTFY (0x6F) |
|
} |
|
} |
|
} |
|
|
|
Method (_Q0C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x50) |
|
} |
|
} |
|
|
|
Method (_Q0D, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x51) |
|
} |
|
} |
|
|
|
Method (_Q72, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x5C) |
|
} |
|
} |
|
|
|
Method (_Q71, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x8A) |
|
} |
|
} |
|
|
|
Method (_Q70, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x82) |
|
} |
|
} |
|
|
|
Method (_Q73, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x84) |
|
} |
|
} |
|
|
|
Method (_QB0, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
Local0 = RRAM (0x051C) |
|
If ((Local0 & 0x02)) |
|
{ |
|
CRTF = One |
|
PSVF = Zero |
|
} |
|
ElseIf ((Local0 & One)) |
|
{ |
|
PSVF = One |
|
CRTF = Zero |
|
} |
|
Else |
|
{ |
|
PSVF = Zero |
|
CRTF = Zero |
|
} |
|
|
|
Notify (\_TZ.THRM, 0x80) // Thermal Status Change |
|
} |
|
|
|
Method (_QCC, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x6D) |
|
} |
|
Else |
|
{ |
|
Notify (SLPB, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Method (_Q60, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
Notify (PWRB, 0x80) // Status Change |
|
} |
|
|
|
Method (_Q68, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
} |
|
|
|
Method (_QA0, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ACPS ()) |
|
{ |
|
\WMI0.ACPF = One |
|
Local0 = 0x58 |
|
} |
|
Else |
|
{ |
|
\WMI0.ACPF = Zero |
|
Local0 = 0x57 |
|
} |
|
|
|
If ((OSFG < OSVT)) |
|
{ |
|
STBR () |
|
} |
|
|
|
Notify (AC0, 0x80) // Status Change |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (Local0) |
|
} |
|
|
|
Sleep (0x64) |
|
PNOT () |
|
Sleep (0x0A) |
|
NBAT (0x80) |
|
} |
|
|
|
Method (_Q6F, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0xB5) |
|
} |
|
} |
|
|
|
Method (_QBD, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
If (ATKP) |
|
{ |
|
^^^^ATKD.NTFY (0x6E) |
|
} |
|
ElseIf (BATP (Zero)) |
|
{ |
|
Notify (BAT0, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Method (_QAE, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x04, One, Zero) |
|
} |
|
|
|
Method (_QAF, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x04, One, One) |
|
} |
|
|
|
Method (_QBE, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x04, One, Zero) |
|
} |
|
|
|
Method (_QBF, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x04, One, One) |
|
} |
|
|
|
Method (_QA6, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
\WMI0.SLMT = One |
|
PNOT () |
|
} |
|
|
|
Method (_QA7, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
\WMI0.SLMT = \WMI0.CPUP |
|
PNOT () |
|
} |
|
|
|
Method (_QAC, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
} |
|
|
|
Method (_QAD, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
} |
|
|
|
Method (_QBA, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x1A, One, Zero) |
|
} |
|
|
|
Method (_QBB, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF |
|
{ |
|
SGPL (0x1A, One, One) |
|
} |
|
} |
|
|
|
Scope (_TZ) |
|
{ |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (MF63, 4, NotSerialized) |
|
{ |
|
If ((Arg1 != 0x63)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
M631 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
M632 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
M633 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x04)) |
|
{ |
|
M634 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x05)) |
|
{ |
|
M635 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x06)) |
|
{ |
|
M636 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x07)) |
|
{ |
|
M637 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x08)) |
|
{ |
|
M638 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x09)) |
|
{ |
|
M639 (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x0A)) |
|
{ |
|
M63A (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x0B)) |
|
{ |
|
M63B (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x0C)) |
|
{ |
|
M63C (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x0D)) |
|
{ |
|
M63D (Arg0, Arg1) |
|
} |
|
|
|
If ((Arg2 == 0x0E)) |
|
{ |
|
M63E (Arg0, Arg1) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M631, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
TSXR, 8, |
|
TSXL, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
TSXR = RRAM (0x03E2) |
|
TSXL = RRAM (0x03E3) |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
TSXR = RRAM (0x03E0) |
|
TSXL = RRAM (0x03E1) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M632, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
DEVS, 8, |
|
DEVT, 16 |
|
} |
|
|
|
SM63 = 0x80 |
|
EM63 = Zero |
|
If ((DEVS == Zero)) |
|
{ |
|
DEVT = \WMI0.TJMX |
|
} |
|
ElseIf ((DEVS == One)) |
|
{ |
|
DEVT = TH0R /* \_SB_.PCI0.SBRG.HEC_.TH0R */ |
|
} |
|
ElseIf ((DEVS == 0x02)) |
|
{ |
|
DEVT = Zero |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M633, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FANX, 8, |
|
FANS, 8, |
|
FANT, 16, |
|
TRGG, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FANX == Zero)) |
|
{ |
|
FANS = F0CS /* \_SB_.PCI0.SBRG.HEC_.F0CS */ |
|
FANT = F0TS /* \_SB_.PCI0.SBRG.HEC_.F0TS */ |
|
TRGG = RRAM (0x0576) |
|
} |
|
ElseIf ((FANX == One)) |
|
{ |
|
FANS = F1CS /* \_SB_.PCI0.SBRG.HEC_.F1CS */ |
|
FANT = F1TS /* \_SB_.PCI0.SBRG.HEC_.F1TS */ |
|
TRGG = RRAM (0x0577) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M634, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
PARA, 8, |
|
DATA, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler, x=0-9, A-Z |
|
_T_0 = ToInteger (PARA) |
|
If ((_T_0 == Zero)) |
|
{ |
|
DATA = RRAM (0x0521) |
|
} |
|
ElseIf ((_T_0 == One)) |
|
{ |
|
DATA = RRAM (0x0522) |
|
} |
|
ElseIf ((_T_0 == 0x02)) |
|
{ |
|
DATA = RRAM (0x0523) |
|
} |
|
ElseIf ((_T_0 == 0x03)) |
|
{ |
|
DATA = RRAM (0x0524) |
|
} |
|
ElseIf ((_T_0 == 0x04)) |
|
{ |
|
DATA = RRAM (0x0509) |
|
} |
|
ElseIf ((_T_0 == 0x05)) |
|
{ |
|
DATA = RRAM (0x050A) |
|
} |
|
ElseIf ((_T_0 == 0x06)) |
|
{ |
|
DATA = RRAM (0x0568) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler, x=0-9, A-Z |
|
_T_1 = ToInteger (PARA) |
|
If ((_T_1 == Zero)) |
|
{ |
|
WRAM (0x0521, DATA) |
|
} |
|
ElseIf ((_T_1 == One)) |
|
{ |
|
WRAM (0x0522, DATA) |
|
} |
|
ElseIf ((_T_1 == 0x02)) |
|
{ |
|
WRAM (0x0523, DATA) |
|
} |
|
ElseIf ((_T_1 == 0x03)) |
|
{ |
|
WRAM (0x0524, DATA) |
|
} |
|
ElseIf ((_T_1 == 0x04)) |
|
{ |
|
WRAM (0x0509, DATA) |
|
} |
|
ElseIf ((_T_1 == 0x05)) |
|
{ |
|
WRAM (0x050A, DATA) |
|
} |
|
ElseIf ((_T_1 == 0x06)) |
|
{ |
|
WRAM (0x0568, DATA) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M635, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
ECSD, 8, |
|
OSSD, 8, |
|
OSPV, 8, |
|
THON, 8, |
|
THOF, 8, |
|
FNER, 8, |
|
VGSD, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
ECSD = RRAM (0x0530) |
|
OSSD = RRAM (0x03E4) |
|
OSPV = RRAM (0x03E5) |
|
THON = RRAM (0x0533) |
|
THOF = RRAM (0x0534) |
|
FNER = RRAM (0x0535) |
|
VGSD = RRAM (0x0536) |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
WRAM (0x0530, ECSD) |
|
WRAM (0x03E4, OSSD) |
|
WRAM (0x03E5, OSPV) |
|
WRAM (0x0533, THON) |
|
WRAM (0x0534, THOF) |
|
WRAM (0x0535, FNER) |
|
WRAM (0x0536, VGSD) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M636, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
ALGM, 8, |
|
TTS1, 8, |
|
TTS2, 8, |
|
TTS3, 8, |
|
TTS4, 8, |
|
TTS5, 8, |
|
TTS6, 8, |
|
TTS7, 8, |
|
TTS8, 8, |
|
TFFP, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
TTS1 = RRAM (0x0537) |
|
TTS2 = RRAM (0x0538) |
|
TTS3 = RRAM (0x0539) |
|
TTS4 = RRAM (0x053A) |
|
TTS5 = RRAM (0x053B) |
|
TTS6 = RRAM (0x053C) |
|
TTS7 = RRAM (0x053D) |
|
TTS8 = RRAM (0x053E) |
|
TFFP = RRAM (0x053F) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
TTS1 = RRAM (0x0597) |
|
TTS2 = RRAM (0x0598) |
|
TTS3 = RRAM (0x0599) |
|
TTS4 = RRAM (0x059A) |
|
TTS5 = RRAM (0x059B) |
|
TTS6 = RRAM (0x059C) |
|
TTS7 = RRAM (0x059D) |
|
TTS8 = RRAM (0x059E) |
|
TFFP = RRAM (0x059F) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
WRAM (0x0537, TTS1) |
|
WRAM (0x0538, TTS2) |
|
WRAM (0x0539, TTS3) |
|
WRAM (0x053A, TTS4) |
|
WRAM (0x053B, TTS5) |
|
WRAM (0x053C, TTS6) |
|
WRAM (0x053D, TTS7) |
|
WRAM (0x053E, TTS8) |
|
WRAM (0x053F, TFFP) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
WRAM (0x0597, TTS1) |
|
WRAM (0x0598, TTS2) |
|
WRAM (0x0599, TTS3) |
|
WRAM (0x059A, TTS4) |
|
WRAM (0x059B, TTS5) |
|
WRAM (0x059C, TTS6) |
|
WRAM (0x059D, TTS7) |
|
WRAM (0x059E, TTS8) |
|
WRAM (0x059F, TFFP) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
|
|
Method (M637, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
ALGM, 8, |
|
TDA1, 8, |
|
TDA2, 8, |
|
TDA3, 8, |
|
TDA4, 8, |
|
TDA5, 8, |
|
TDA6, 8, |
|
TDA7, 8, |
|
TDA8, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
TDA1 = RRAM (0x0548) |
|
TDA2 = RRAM (0x0549) |
|
TDA3 = RRAM (0x054A) |
|
TDA4 = RRAM (0x054B) |
|
TDA5 = RRAM (0x054C) |
|
TDA6 = RRAM (0x054D) |
|
TDA7 = RRAM (0x054E) |
|
TDA8 = RRAM (0x054F) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
TDA1 = RRAM (0x05A8) |
|
TDA2 = RRAM (0x05A9) |
|
TDA3 = RRAM (0x05AA) |
|
TDA4 = RRAM (0x05AB) |
|
TDA5 = RRAM (0x05AC) |
|
TDA6 = RRAM (0x05AD) |
|
TDA7 = RRAM (0x05AE) |
|
TDA8 = RRAM (0x05AF) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
WRAM (0x0548, TDA1) |
|
WRAM (0x0549, TDA2) |
|
WRAM (0x054A, TDA3) |
|
WRAM (0x054B, TDA4) |
|
WRAM (0x054C, TDA5) |
|
WRAM (0x054D, TDA6) |
|
WRAM (0x054E, TDA7) |
|
WRAM (0x054F, TDA8) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
WRAM (0x05A8, TDA1) |
|
WRAM (0x05A9, TDA2) |
|
WRAM (0x05AA, TDA3) |
|
WRAM (0x05AB, TDA4) |
|
WRAM (0x05AC, TDA5) |
|
WRAM (0x05AD, TDA6) |
|
WRAM (0x05AE, TDA7) |
|
WRAM (0x05AF, TDA8) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
|
|
Method (M638, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
ALGM, 8, |
|
ASC1, 8, |
|
ASC2, 8, |
|
ASC3, 8, |
|
ASC4, 8, |
|
ADA1, 8, |
|
ADA2, 8, |
|
ADA3, 8, |
|
ADA4, 8, |
|
DSC1, 8, |
|
DSC2, 8, |
|
DSC3, 8, |
|
DSC4, 8, |
|
DDA1, 8, |
|
DDA2, 8, |
|
DDA3, 8, |
|
DDA4, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
ASC1 = RRAM (0x0550) |
|
ASC2 = RRAM (0x0551) |
|
ASC3 = RRAM (0x0552) |
|
ASC4 = RRAM (0x0553) |
|
ADA1 = RRAM (0x0554) |
|
ADA2 = RRAM (0x0555) |
|
ADA3 = RRAM (0x0556) |
|
ADA4 = RRAM (0x0557) |
|
DSC1 = RRAM (0x0558) |
|
DSC2 = RRAM (0x0559) |
|
DSC3 = RRAM (0x055A) |
|
DSC4 = RRAM (0x055B) |
|
DDA1 = RRAM (0x055C) |
|
DDA2 = RRAM (0x055D) |
|
DDA3 = RRAM (0x055E) |
|
DDA4 = RRAM (0x055F) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
ASC1 = RRAM (0x05B0) |
|
ASC2 = RRAM (0x05B1) |
|
ASC3 = RRAM (0x05B2) |
|
ASC4 = RRAM (0x05B3) |
|
ADA1 = RRAM (0x05B4) |
|
ADA2 = RRAM (0x05B5) |
|
ADA3 = RRAM (0x05B6) |
|
ADA4 = RRAM (0x05B7) |
|
DSC1 = RRAM (0x05B8) |
|
DSC2 = RRAM (0x05B9) |
|
DSC3 = RRAM (0x05BA) |
|
DSC4 = RRAM (0x05BB) |
|
DDA1 = RRAM (0x05BC) |
|
DDA2 = RRAM (0x05BD) |
|
DDA3 = RRAM (0x05BE) |
|
DDA4 = RRAM (0x05BF) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
WRAM (0x0550, ASC1) |
|
WRAM (0x0551, ASC2) |
|
WRAM (0x0552, ASC3) |
|
WRAM (0x0553, ASC4) |
|
WRAM (0x0554, ADA1) |
|
WRAM (0x0555, ADA2) |
|
WRAM (0x0556, ADA3) |
|
WRAM (0x0557, ADA4) |
|
WRAM (0x0558, DSC1) |
|
WRAM (0x0559, DSC2) |
|
WRAM (0x055A, DSC3) |
|
WRAM (0x055B, DSC4) |
|
WRAM (0x055C, DDA1) |
|
WRAM (0x055D, DDA2) |
|
WRAM (0x055E, DDA3) |
|
WRAM (0x055F, DDA4) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
WRAM (0x05B0, ASC1) |
|
WRAM (0x05B1, ASC2) |
|
WRAM (0x05B2, ASC3) |
|
WRAM (0x05B3, ASC4) |
|
WRAM (0x05B4, ADA1) |
|
WRAM (0x05B5, ADA2) |
|
WRAM (0x05B6, ADA3) |
|
WRAM (0x05B7, ADA4) |
|
WRAM (0x05B8, DSC1) |
|
WRAM (0x05B9, DSC2) |
|
WRAM (0x05BA, DSC3) |
|
WRAM (0x05BB, DSC4) |
|
WRAM (0x05BC, DDA1) |
|
WRAM (0x05BD, DDA2) |
|
WRAM (0x05BE, DDA3) |
|
WRAM (0x05BF, DDA4) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
|
|
Method (M639, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
ALGM, 8, |
|
HYS1, 8, |
|
HYS2, 8, |
|
HYS3, 8, |
|
HYS4, 8, |
|
HYS5, 8, |
|
HYS6, 8, |
|
HYS7, 8, |
|
HYS8, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
HYS1 = RRAM (0x0540) |
|
HYS2 = RRAM (0x0541) |
|
HYS3 = RRAM (0x0542) |
|
HYS4 = RRAM (0x0543) |
|
HYS5 = RRAM (0x0544) |
|
HYS6 = RRAM (0x0545) |
|
HYS7 = RRAM (0x0546) |
|
HYS8 = RRAM (0x0547) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
HYS1 = RRAM (0x05A0) |
|
HYS2 = RRAM (0x05A1) |
|
HYS3 = RRAM (0x05A2) |
|
HYS4 = RRAM (0x05A3) |
|
HYS5 = RRAM (0x05A4) |
|
HYS6 = RRAM (0x05A5) |
|
HYS7 = RRAM (0x05A6) |
|
HYS8 = RRAM (0x05A7) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((ALGM == Zero)) |
|
{ |
|
WRAM (0x0540, HYS1) |
|
WRAM (0x0541, HYS2) |
|
WRAM (0x0542, HYS3) |
|
WRAM (0x0543, HYS4) |
|
WRAM (0x0544, HYS5) |
|
WRAM (0x0545, HYS6) |
|
WRAM (0x0546, HYS7) |
|
WRAM (0x0547, HYS8) |
|
} |
|
ElseIf ((ALGM == One)) |
|
{ |
|
WRAM (0x05A0, HYS1) |
|
WRAM (0x05A1, HYS2) |
|
WRAM (0x05A2, HYS3) |
|
WRAM (0x05A3, HYS4) |
|
WRAM (0x05A4, HYS5) |
|
WRAM (0x05A5, HYS6) |
|
WRAM (0x05A6, HYS7) |
|
WRAM (0x05A7, HYS8) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M63A, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
FANX, 8, |
|
TA1L, 8, |
|
TA1H, 8, |
|
TA2L, 8, |
|
TA2H, 8, |
|
TA3L, 8, |
|
TA3H, 8, |
|
TA4L, 8, |
|
TA4H, 8, |
|
TA5L, 8, |
|
TA5H, 8, |
|
TA6L, 8, |
|
TA6H, 8, |
|
TA7L, 8, |
|
TA7H, 8, |
|
TA8L, 8, |
|
TA8H, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((FANX == Zero)) |
|
{ |
|
TA1L = RRAM (0x05C0) |
|
TA1H = RRAM (0x05C1) |
|
TA2L = RRAM (0x05C2) |
|
TA2H = RRAM (0x05C3) |
|
TA3L = RRAM (0x05C4) |
|
TA3H = RRAM (0x05C5) |
|
TA4L = RRAM (0x05C6) |
|
TA4H = RRAM (0x05C7) |
|
TA5L = RRAM (0x05C8) |
|
TA5H = RRAM (0x05C9) |
|
TA6L = RRAM (0x05CA) |
|
TA6H = RRAM (0x05CB) |
|
TA7L = RRAM (0x05CC) |
|
TA7H = RRAM (0x05CD) |
|
TA8L = RRAM (0x05CE) |
|
TA8H = RRAM (0x05CF) |
|
} |
|
ElseIf ((FANX == One)) |
|
{ |
|
TA1L = RRAM (0x05D0) |
|
TA1H = RRAM (0x05D1) |
|
TA2L = RRAM (0x05D2) |
|
TA2H = RRAM (0x05D3) |
|
TA3L = RRAM (0x05D4) |
|
TA3H = RRAM (0x05D5) |
|
TA4L = RRAM (0x05D6) |
|
TA4H = RRAM (0x05D7) |
|
TA5L = RRAM (0x05D8) |
|
TA5H = RRAM (0x05D9) |
|
TA6L = RRAM (0x05DA) |
|
TA6H = RRAM (0x05DB) |
|
TA7L = RRAM (0x05DC) |
|
TA7H = RRAM (0x05DD) |
|
TA8L = RRAM (0x05DE) |
|
TA8H = RRAM (0x05DF) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((FANX == Zero)) |
|
{ |
|
WRAM (0x05C0, TA1L) |
|
WRAM (0x05C1, TA1H) |
|
WRAM (0x05C2, TA2L) |
|
WRAM (0x05C3, TA2H) |
|
WRAM (0x05C4, TA3L) |
|
WRAM (0x05C5, TA3H) |
|
WRAM (0x05C6, TA4L) |
|
WRAM (0x05C7, TA4H) |
|
WRAM (0x05C8, TA5L) |
|
WRAM (0x05C9, TA5H) |
|
WRAM (0x05CA, TA6L) |
|
WRAM (0x05CB, TA6H) |
|
WRAM (0x05CC, TA7L) |
|
WRAM (0x05CD, TA7H) |
|
WRAM (0x05CE, TA8L) |
|
WRAM (0x05CF, TA8H) |
|
} |
|
ElseIf ((FANX == One)) |
|
{ |
|
WRAM (0x05D0, TA1L) |
|
WRAM (0x05D1, TA1H) |
|
WRAM (0x05D2, TA2L) |
|
WRAM (0x05D3, TA2H) |
|
WRAM (0x05D4, TA3L) |
|
WRAM (0x05D5, TA3H) |
|
WRAM (0x05D6, TA4L) |
|
WRAM (0x05D7, TA4H) |
|
WRAM (0x05D8, TA5L) |
|
WRAM (0x05D9, TA5H) |
|
WRAM (0x05DA, TA6L) |
|
WRAM (0x05DB, TA6H) |
|
WRAM (0x05DC, TA7L) |
|
WRAM (0x05DD, TA7H) |
|
WRAM (0x05DE, TA8L) |
|
WRAM (0x05DF, TA8H) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M63B, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
PARA, 8, |
|
DATA, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((PARA == Zero)) |
|
{ |
|
DATA = RRAM (0x0569) |
|
} |
|
ElseIf ((PARA == One)) |
|
{ |
|
DATA = RRAM (0x056A) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((PARA == Zero)) |
|
{ |
|
WRAM (0x0569, DATA) |
|
} |
|
ElseIf ((PARA == One)) |
|
{ |
|
WRAM (0x056A, DATA) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M63C, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x20) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
DATA, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
DATA = RRAM (0x0511) |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
DATA = RRAM (0x0512) |
|
} |
|
ElseIf ((FUNC == 0x02)) |
|
{ |
|
DATA = RRAM (0x0513) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M63D, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
FREQ, 16 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
Local0 = 0x017D7840 |
|
Local1 = RRAM (0xF4A0) |
|
Local1 += One |
|
Local2 = RRAM (0xF4A2) |
|
Local2 += One |
|
Local2 *= Local1 |
|
Divide (Local0, Local2, Local3, Local1) |
|
FREQ = Local1 |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
FREQ = Zero |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (M63E, 2, NotSerialized) |
|
{ |
|
OperationRegion (FM63, SystemMemory, Arg0, 0x10) |
|
Field (FM63, ByteAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM63, 8, |
|
EM63, 8, |
|
FUNC, 8, |
|
FANX, 8, |
|
FAND, 8 |
|
} |
|
|
|
SM63 |= 0x80 |
|
EM63 = Zero |
|
If ((FUNC == Zero)) |
|
{ |
|
If ((FANX == Zero)) |
|
{ |
|
FAND = RFOV (Zero) |
|
} |
|
ElseIf ((FANX == One)) |
|
{ |
|
FAND = RFOV (One) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
ElseIf ((FUNC == One)) |
|
{ |
|
If ((FANX == Zero)) |
|
{ |
|
WFOV (Zero, FAND) |
|
} |
|
ElseIf ((FANX == One)) |
|
{ |
|
WFOV (One, FAND) |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
} |
|
Else |
|
{ |
|
SM63 = 0x80 |
|
EM63 = One |
|
} |
|
|
|
Return (Zero) |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SBRG.HEC) |
|
{ |
|
Method (MF30, 4, NotSerialized) |
|
{ |
|
If ((Arg1 != 0x30)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Local0 = 0xFF |
|
If ((Arg2 == Zero)) |
|
{ |
|
Local0 = G30V (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = EC01 (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = EC02 (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = EC03 (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == 0x84)) |
|
{ |
|
Local0 = EC84 (Arg0, Arg3) |
|
} |
|
|
|
Local2 = (Arg2 & 0xFC) |
|
If ((Local2 == 0x80)) |
|
{ |
|
^^^^ATKD.BSMI (Arg0) |
|
If ((Arg2 == 0x81)) |
|
{ |
|
If (BATP (Zero)) |
|
{ |
|
Notify (BAT0, 0x80) // Status Change |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
If ((Local0 == 0xFF)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
OperationRegion (FM30, SystemMemory, Arg0, 0x08) |
|
Field (FM30, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
SM30, 8, |
|
EM30, 8 |
|
} |
|
|
|
If (Local0) |
|
{ |
|
EM30 = Local0 |
|
SM30 |= 0x02 |
|
} |
|
|
|
SM30 &= 0xFE |
|
SM30 |= 0x80 |
|
Return (Zero) |
|
} |
|
|
|
Method (G30V, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0C)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (\F300, SystemMemory, Arg0, Arg1) |
|
Field (F300, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SVER, 16, |
|
MVER, 16 |
|
} |
|
|
|
MVER = Zero |
|
SVER = Zero |
|
Return (Zero) |
|
} |
|
|
|
Method (EC01, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x10)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (FEC1, SystemMemory, Arg0, Arg1) |
|
Field (FEC1, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
ECMD, 8, |
|
EDA1, 8, |
|
EDA2, 8, |
|
EDA3, 8, |
|
EDA4, 8, |
|
EDA5, 8 |
|
} |
|
|
|
Local0 = ECXT (ECMD, EDA1, EDA2, EDA3, EDA4, EDA5) |
|
EDA1 = DerefOf (Local0 [One]) |
|
EDA2 = DerefOf (Local0 [One]) |
|
EDA3 = DerefOf (Local0 [One]) |
|
EDA4 = DerefOf (Local0 [One]) |
|
EDA5 = DerefOf (Local0 [One]) |
|
Return (DerefOf (Local0 [Zero])) |
|
} |
|
|
|
Method (EC02, 2, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (EC03, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x09)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
Local0 = Zero |
|
OperationRegion (FEC3, SystemMemory, Arg0, Arg1) |
|
Field (FEC3, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
FNEN, 8 |
|
} |
|
|
|
If (FNEN) |
|
{ |
|
FNLK (One) |
|
} |
|
Else |
|
{ |
|
FNLK (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (EC84, 2, NotSerialized) |
|
{ |
|
If ((Arg1 < 0x0A)) |
|
{ |
|
Return (0x02) |
|
} |
|
|
|
OperationRegion (ECEG, SystemMemory, Arg0, Arg1) |
|
Field (ECEG, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
EVTP, 8, |
|
EVID, 8 |
|
} |
|
|
|
ECXT (0xAE, EVTP, EVID, Zero, Zero, Zero) |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (MF42, 4, NotSerialized) |
|
{ |
|
If ((Arg1 == 0x42)) |
|
{ |
|
OperationRegion (F042, SystemMemory, Arg0, 0x08) |
|
Field (F042, DWordAcc, NoLock, Preserve) |
|
{ |
|
MFUN, 16, |
|
SFUN, 16, |
|
LEN, 16, |
|
STAS, 8, |
|
EROR, 8 |
|
} |
|
|
|
Local0 = One |
|
If ((Arg2 == One)) |
|
{ |
|
Local0 = SFB0 (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == 0x02)) |
|
{ |
|
Local0 = SAOC (Arg0, Arg3) |
|
} |
|
|
|
If ((Arg2 == 0x03)) |
|
{ |
|
Local0 = GBST (Arg0, Arg3) |
|
} |
|
|
|
If (Local0) |
|
{ |
|
EROR = Local0 |
|
STAS |= 0x02 |
|
} |
|
|
|
STAS |= 0x80 |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Method (SFB0, 2, NotSerialized) |
|
{ |
|
OperationRegion (F421, SystemMemory, Arg0, Arg1) |
|
Field (F421, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
SOPT, 8 |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (SAOC, 2, NotSerialized) |
|
{ |
|
OperationRegion (F422, SystemMemory, Arg0, Arg1) |
|
Field (F422, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
CNTF, 8 |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (GBST, 2, NotSerialized) |
|
{ |
|
OperationRegion (F423, SystemMemory, Arg0, Arg1) |
|
Field (F423, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x08), |
|
BOT1, 64, |
|
BOT2, 64 |
|
} |
|
|
|
BOT1 = \WMI0.TBOT |
|
BOT2 = \WMI0.TRTC |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (DS3S, 1, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x02FA) |
|
If ((Arg0 == 0x03)) |
|
{ |
|
If (\WMI0.DS3F) |
|
{ |
|
Local0 &= 0xFE |
|
} |
|
Else |
|
{ |
|
Local0 |= One |
|
} |
|
} |
|
Else |
|
{ |
|
Local0 &= 0xFE |
|
} |
|
|
|
^^PCI0.SBRG.HEC.WRAM (0x02FA, Local0) |
|
} |
|
|
|
Method (DS3W, 1, NotSerialized) |
|
{ |
|
If (!\WMI0.DS3F) |
|
{ |
|
Notify (SLPB, 0x02) // Device Wake |
|
} |
|
} |
|
|
|
Method (DESP, 1, Serialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
\WMI0.DS3F = Zero |
|
} |
|
Else |
|
{ |
|
\WMI0.DS3F = One |
|
} |
|
|
|
Return (One) |
|
} |
|
|
|
Method (GDS3, 1, Serialized) |
|
{ |
|
If (\WMI0.DS3F) |
|
{ |
|
Return (0x00010000) |
|
} |
|
Else |
|
{ |
|
Return (0x00010001) |
|
} |
|
} |
|
|
|
Method (NS3P, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x0C4A) |
|
Local1 = ^^PCI0.SBRG.HEC.RRAM (0x0C4B) |
|
Local0 <<= 0x08 |
|
Local0 += Local1 |
|
If ((Local0 == Zero)) |
|
{ |
|
Return (0xFFEB) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (DS3P, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x0C4A) |
|
Local1 = ^^PCI0.SBRG.HEC.RRAM (0x0C4B) |
|
Local0 <<= 0x08 |
|
Local0 += Local1 |
|
If ((Local0 == Zero)) |
|
{ |
|
Return (0xFFF3) |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (T2BF, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.SMBR (^^PCI0.SBRG.HEC.RDWD, 0x16, 0x13) |
|
If ((DerefOf (Local0 [Zero]) != Zero)) |
|
{ |
|
Return (0xFFFF) |
|
} |
|
|
|
Local1 = DerefOf (Local0 [0x02]) |
|
Return (Local1) |
|
} |
|
|
|
Method (N3MV, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x0C48) |
|
Local1 = ^^PCI0.SBRG.HEC.RRAM (0x0C49) |
|
Local0 <<= 0x08 |
|
Local0 += Local1 |
|
If ((Local0 == Zero)) |
|
{ |
|
Return (0x3EDA) |
|
} |
|
|
|
Local0 = (0xFFFF - Local0) |
|
Return (Local0) |
|
} |
|
|
|
Method (D3MV, 0, NotSerialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x0C48) |
|
Local1 = ^^PCI0.SBRG.HEC.RRAM (0x0C49) |
|
Local0 <<= 0x08 |
|
Local0 += Local1 |
|
If ((Local0 == Zero)) |
|
{ |
|
Return (0x3EDA) |
|
} |
|
|
|
Local0 = (0xFFFF - Local0) |
|
Return (Local0) |
|
} |
|
|
|
Method (S4PC, 0, NotSerialized) |
|
{ |
|
Return (0x0A) |
|
} |
|
|
|
Method (IOMB, 1, Serialized) |
|
{ |
|
Local0 = ^^PCI0.SBRG.HEC.RRAM (0x02FA) |
|
If (Arg0) |
|
{ |
|
Local0 |= 0x02 |
|
} |
|
Else |
|
{ |
|
Local0 &= 0xFD |
|
} |
|
|
|
^^PCI0.SBRG.HEC.WRAM (0x02FA, Local0) |
|
Return (One) |
|
} |
|
|
|
Method (IOMT, 1, Serialized) |
|
{ |
|
Return (One) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (FSMI, 1, NotSerialized) |
|
{ |
|
\WMI0.FSFN = Arg0 |
|
Local0 = (Arg0 | 0xA0) |
|
ISMI (0x90) |
|
Return (\WMI0.FSTA) |
|
} |
|
|
|
Method (FLSH, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
FSMI (Zero) |
|
} |
|
|
|
Method (FINI, 1, NotSerialized) |
|
{ |
|
\WMI0.FADR = Arg0 |
|
Return (FSMI (One)) |
|
} |
|
|
|
Method (FERS, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
Return (FSMI (0x02)) |
|
} |
|
|
|
Method (FWRI, 1, NotSerialized) |
|
{ |
|
\WMI0.FADR = Arg0 |
|
\WMI0.FSIZ = 0x1000 |
|
Return ((0x1000 - FSMI (0x03))) |
|
} |
|
|
|
Method (FWRP, 0, NotSerialized) |
|
{ |
|
\WMI0.FSIZ = Zero |
|
Return ((0x1000 - FSMI (0x03))) |
|
} |
|
|
|
Method (FEBW, 1, NotSerialized) |
|
{ |
|
\WMI0.FADR = Arg0 |
|
Return (FSMI (0x04)) |
|
} |
|
|
|
Method (FEBR, 1, NotSerialized) |
|
{ |
|
\WMI0.FADR = Arg0 |
|
Return (FSMI (0x05)) |
|
} |
|
|
|
Method (FEDW, 0, NotSerialized) |
|
{ |
|
Return (FSMI (0x06)) |
|
} |
|
|
|
Method (ECSR, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
Return (FSMI (0x07)) |
|
} |
|
|
|
Method (FLSC, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
Return (FSMI (0x08)) |
|
} |
|
|
|
Method (FIME, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
Return (FSMI (0x09)) |
|
} |
|
|
|
Method (FREC, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Arg0 |
|
Return (FSMI (0x0A)) |
|
} |
|
|
|
Method (FCPW, 1, NotSerialized) |
|
{ |
|
\WMI0.FADR = Arg0 |
|
\WMI0.FSIZ = 0x1000 |
|
Return (FSMI (0x0D)) |
|
} |
|
|
|
Method (FCPP, 0, NotSerialized) |
|
{ |
|
\WMI0.FSIZ = Zero |
|
Return (FSMI (0x0D)) |
|
} |
|
|
|
Method (WFLH, 5, Serialized) |
|
{ |
|
If ((Arg2 == 0x66)) |
|
{ |
|
If ((Arg3 == One)) |
|
{ |
|
OperationRegion (WFLS, SystemMemory, Arg0, 0x0100) |
|
Field (WFLS, DWordAcc, NoLock, Preserve) |
|
{ |
|
Offset (0x06), |
|
STAS, 8, |
|
REST, 8, |
|
FSFN, 8, |
|
FSTA, 16, |
|
FADR, 32, |
|
FSIZ, 16 |
|
} |
|
|
|
\WMI0.TRTY = 0x90 |
|
\WMI0.FSFN = FSFN /* \_SB_.ATKD.WFLH.FSFN */ |
|
\WMI0.FSTA = FSTA /* \_SB_.ATKD.WFLH.FSTA */ |
|
\WMI0.FADR = FADR /* \_SB_.ATKD.WFLH.FADR */ |
|
\WMI0.FSIZ = FSIZ /* \_SB_.ATKD.WFLH.FSIZ */ |
|
If ((FSFN == One)) |
|
{ |
|
\WMI0.FADR = Arg1 |
|
} |
|
ElseIf ((FSFN == 0x80)) |
|
{ |
|
\WMI0.FADR = Arg1 |
|
} |
|
ElseIf ((FSFN == 0x81)) |
|
{ |
|
\WMI0.FADR = Arg1 |
|
} |
|
|
|
ISMI (0x90) |
|
Local0 = 0x012C |
|
While ((Local0 && \WMI0.TRTY)) |
|
{ |
|
Sleep (One) |
|
Local0-- |
|
} |
|
|
|
FSFN = \WMI0.FSFN |
|
FSTA = \WMI0.FSTA |
|
FADR = \WMI0.FADR |
|
FSIZ = \WMI0.FSIZ |
|
STAS &= 0xFE |
|
STAS |= 0x80 |
|
Return (Zero) |
|
} |
|
Else |
|
{ |
|
\WMI0.WSMI (Arg4) |
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (FIN2, 1, NotSerialized) |
|
{ |
|
\WMI0.FSTA = Zero |
|
Return (FSMI (0x80)) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (GVBD, 5, NotSerialized) |
|
{ |
|
If ((Arg2 == 0x69)) |
|
{ |
|
If ((Arg3 == One)) |
|
{ |
|
\WMI0.WSMI (Arg4) |
|
Return (Zero) |
|
} |
|
|
|
If ((Arg3 == 0x02)) |
|
{ |
|
\WMI0.WSMI (Arg4) |
|
Return (Zero) |
|
} |
|
} |
|
|
|
Return (Zero) |
|
} |
|
} |
|
|
|
Scope (_SB.ATKD) |
|
{ |
|
Method (MF1F, 4, NotSerialized) |
|
{ |
|
If ((Arg1 == 0x1F)) |
|
{ |
|
OperationRegion (F01F, SystemMemory, Arg0, 0x08) |
|
Field (F01F, DWordAcc, NoLock, Preserve) |
|
{ |
|
MFUN, 16, |
|
SFUN, 16, |
|
LEN, 16, |
|
STAS, 8, |
|
EROR, 8 |
|
} |
|
|
|
BSMI (Arg0) |
|
STAS &= 0xFE |
|
} |
|
} |
|
} |
|
|
|
Scope (\) |
|
{ |
|
Method (LIMT, 0, NotSerialized) |
|
{ |
|
Local0 = (\WMI0.CPUP - \WMI0.SLMT) |
|
Return (Local0) |
|
} |
|
|
|
Method (PRJS, 1, Serialized) |
|
{ |
|
} |
|
|
|
Method (PRJW, 1, Serialized) |
|
{ |
|
\_SB.PCI0.SBRG.HEC.STBR () |
|
} |
|
|
|
Method (PRJB, 0, NotSerialized) |
|
{ |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x07FE, 0x80) |
|
\_SB.PCI0.SBRG.HEC.SMBW (\_SB.PCI0.SBRG.HEC.WRWD, \_SB.PCI0.SBRG.HEC.BADR, Zero, Zero, 0x1000) |
|
} |
|
|
|
Method (GLID, 0, Serialized) |
|
{ |
|
Return (\_SB.PCI0.SBRG.HEC.RPIN (0x04, 0x06)) |
|
} |
|
|
|
Method (OMLD, 1, Serialized) |
|
{ |
|
} |
|
|
|
Method (OTLD, 1, Serialized) |
|
{ |
|
} |
|
|
|
Method (OGLD, 1, Serialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (OWLD, 1, Serialized) |
|
{ |
|
\WMI0.WRST = Arg0 |
|
SGPL (0xBB, One, Arg0) |
|
} |
|
|
|
Method (OBTD, 1, Serialized) |
|
{ |
|
\WMI0.BRST = Arg0 |
|
SGPL (0xBD, One, Arg0) |
|
} |
|
|
|
Method (OHWR, 0, Serialized) |
|
{ |
|
Local0 = Zero |
|
If (\_SB.PCI0.PE21.WLAN.MPDP ()) |
|
{ |
|
Local0 |= 0x80 |
|
} |
|
|
|
If (\WMI0.BTDP) |
|
{ |
|
Local0 |= 0x0100 |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (ORST, 0, Serialized) |
|
{ |
|
Local0 = Zero |
|
If (\WMI0.WRST) |
|
{ |
|
Local0 |= One |
|
} |
|
|
|
If (\WMI0.BRST) |
|
{ |
|
Local0 |= 0x02 |
|
} |
|
|
|
Return (Local0) |
|
} |
|
|
|
Method (GBTL, 0, Serialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (SBTL, 1, Serialized) |
|
{ |
|
} |
|
|
|
Method (BL2C, 0, NotSerialized) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Method (ACPS, 0, Serialized) |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.RPIN (0x02, 0x04) |
|
Return (Local0) |
|
} |
|
|
|
Method (OGND, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
Return (\_SB.PCI0.VGA.NXTD) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (OEAD, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
Return (\WMI0.AVLD) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (OGCD, 0, NotSerialized) |
|
{ |
|
If (\_SB.PCI0.VGA.PRST ()) |
|
{ |
|
Return (\_SB.PCI0.VGA.GETD ()) |
|
} |
|
|
|
Return (Zero) |
|
} |
|
|
|
Method (DGSW, 1, Serialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
SGPL (0x2C, One, Zero) |
|
SGPL (0x2D, One, Zero) |
|
Sleep (0x0A) |
|
SGPL (0x2D, One, One) |
|
Sleep (0x64) |
|
Local0 = RGPL (0x1C, One) |
|
While ((Local0 == Zero)) |
|
{ |
|
Local0 = RGPL (0x1C, One) |
|
} |
|
|
|
Sleep (0x64) |
|
SGPL (0x2C, One, One) |
|
Sleep (0x012C) |
|
Local0 = \_SB.PCI0.SBRG.HEC.RRAM (0x0520) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0520, (Local0 & 0xFFFFFFFFFFFFFF7F)) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0523, 0x9D) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0524, 0x9D) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0522, 0x25) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0521, 0xA5) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0520, 0xB2) |
|
} |
|
Else |
|
{ |
|
Local0 = \_SB.PCI0.SBRG.HEC.RRAM (0x0520) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0520, (Local0 & 0xFFFFFFFFFFFFFF7F)) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0523, 0x9D) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0522, Zero) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0521, 0x85) |
|
\_SB.PCI0.SBRG.HEC.WRAM (0x0520, 0x81) |
|
Sleep (0x0A) |
|
SGPL (0x2C, One, Zero) |
|
Sleep (0x0A) |
|
SGPL (0x2D, One, Zero) |
|
} |
|
} |
|
|
|
Name (GPED, Zero) |
|
Scope (_SB.PCI0) |
|
{ |
|
Device (AFD) |
|
{ |
|
Name (_HID, "AFD0001") // _HID: Hardware ID |
|
Name (ODZP, 0x80000001) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
} |
|
|
|
Scope (_SB.PCI0.SATA) |
|
{ |
|
OperationRegion (SATX, PCI_Config, Zero, 0x43) |
|
Field (SATX, AnyAcc, NoLock, Preserve) |
|
{ |
|
VIDI, 32, |
|
Offset (0x24), |
|
BA05, 32, |
|
WTEN, 1, |
|
Offset (0x42), |
|
DIS0, 1, |
|
DIS1, 1, |
|
DIS2, 1, |
|
DIS3, 1, |
|
DIS4, 1, |
|
DIS5, 1 |
|
} |
|
|
|
Device (PRT1) |
|
{ |
|
Name (_ADR, One) // _ADR: Address |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
Device (ODD) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status |
|
{ |
|
Return (One) |
|
} |
|
} |
|
} |
|
|
|
Device (ODDZ) |
|
{ |
|
Method (_ADR, 0, NotSerialized) // _ADR: Address |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Return (0x0002FFFF) |
|
} |
|
Else |
|
{ |
|
Return (0x02) |
|
} |
|
} |
|
|
|
Name (WDSW, One) |
|
Name (ODPS, Zero) |
|
Method (_STA, 0, NotSerialized) // _STA: Status |
|
{ |
|
If ((^^^AFD.ODZP == 0x80000000)) |
|
{ |
|
Return (Zero) |
|
} |
|
Else |
|
{ |
|
Return (0x0F) |
|
} |
|
} |
|
|
|
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 |
|
{ |
|
If ((^^^AFD.ODZP == 0x80000001)) |
|
{ |
|
If ((VIDI == 0x78041022)) |
|
{ |
|
GPED = One |
|
Sleep (0x28) |
|
SGPL (0x37, One, One) |
|
Sleep (0x28) |
|
Sleep (0x012C) |
|
GPED = Zero |
|
} |
|
|
|
If ((VIDI == 0x78011022)) |
|
{ |
|
DIS2 = Zero |
|
Sleep (0x28) |
|
GPED = One |
|
Sleep (0x28) |
|
SGPL (0x37, One, One) |
|
Sleep (0x28) |
|
Sleep (0x012C) |
|
GPED = Zero |
|
} |
|
} |
|
|
|
ODPS = Zero |
|
} |
|
|
|
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 |
|
{ |
|
If ((^^^AFD.ODZP == 0x80000001)) |
|
{ |
|
If ((VIDI == 0x78041022)) |
|
{ |
|
GPED = One |
|
Sleep (0x28) |
|
SGPL (0x37, One, Zero) |
|
Sleep (0x28) |
|
Sleep (0xC8) |
|
GPED = Zero |
|
} |
|
|
|
If ((VIDI == 0x78011022)) |
|
{ |
|
GPED = One |
|
Sleep (0x28) |
|
SGPL (0x37, One, Zero) |
|
Sleep (0x28) |
|
Sleep (0xC8) |
|
GPED = Zero |
|
DIS2 = One |
|
Sleep (0x28) |
|
} |
|
} |
|
|
|
ODPS = 0x03 |
|
} |
|
|
|
Method (_PSC, 0, NotSerialized) // _PSC: Power State Current |
|
{ |
|
Return (ODPS) /* \_SB_.PCI0.SATA.ODDZ.ODPS */ |
|
} |
|
|
|
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake |
|
{ |
|
If (Arg0) |
|
{ |
|
WDSW = One |
|
} |
|
Else |
|
{ |
|
WDSW = Zero |
|
} |
|
} |
|
|
|
Method (_EJ0, 1, NotSerialized) // _EJx: Eject Device, x=0-9 |
|
{ |
|
_PS3 () |
|
} |
|
|
|
Name (_S0W, 0x04) // _S0W: S0 Device Wake State |
|
Device (ODD) |
|
{ |
|
Name (_ADR, Zero) // _ADR: Address |
|
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status |
|
{ |
|
Return (Zero) |
|
} |
|
} |
|
} |
|
} |
|
|
|
Scope (_GPE) |
|
{ |
|
Method (_L1F, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF |
|
{ |
|
If ((GPED != Zero)) |
|
{ |
|
Return (Zero) |
|
} |
|
|
|
If ((\_SB.PCI0.AFD.ODZP == 0x80000001)) |
|
{ |
|
If (RGPP (0x6F)) |
|
{ |
|
Sleep (0x14) |
|
If (RGPL (0x6F, One)) |
|
{ |
|
SGPP (0x6F, Zero) |
|
If (((\_SB.PCI0.SATA.VIDI == 0x78001022) || (\_SB.PCI0.SATA.VIDI == 0x78011022))) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
|
|
If ((\_SB.PCI0.SATA.VIDI == 0x78041022)) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
|
|
If ((\_SB.PCI0.SATA.VIDI == 0x78011022)) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
} |
|
} |
|
Else |
|
{ |
|
Sleep (0x14) |
|
If (!RGPL (0x6F, Zero)) |
|
{ |
|
SGPP (0x6F, One) |
|
If (((\_SB.PCI0.SATA.VIDI == 0x78001022) || (\_SB.PCI0.SATA.VIDI == 0x78011022))) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
|
|
If ((\_SB.PCI0.SATA.VIDI == 0x78041022)) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
|
|
If ((\_SB.PCI0.SATA.VIDI == 0x78011022)) |
|
{ |
|
If ((OSVR >= 0x0F)) |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x02) // Device Wake |
|
} |
|
Else |
|
{ |
|
Notify (\_SB.PCI0.SATA.ODDZ, 0x80) // Status Change |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
Name (_S0, Package (0x04) // _S0_: S0 System State |
|
{ |
|
Zero, |
|
Zero, |
|
Zero, |
|
Zero |
|
}) |
|
If (SS3) |
|
{ |
|
Name (_S3, Package (0x04) // _S3_: S3 System State |
|
{ |
|
0x03, |
|
Zero, |
|
Zero, |
|
Zero |
|
}) |
|
} |
|
|
|
If (SS4) |
|
{ |
|
Name (_S4, Package (0x04) // _S4_: S4 System State |
|
{ |
|
0x04, |
|
Zero, |
|
Zero, |
|
Zero |
|
}) |
|
} |
|
|
|
Name (_S5, Package (0x04) // _S5_: S5 System State |
|
{ |
|
0x05, |
|
Zero, |
|
Zero, |
|
Zero |
|
}) |
|
Method (PTS, 1, NotSerialized) |
|
{ |
|
If (Arg0) |
|
{ |
|
SPTS (Arg0) |
|
\_SB.PCI0.NPTS (Arg0) |
|
\_SB.ATKD.GENS (Arg0) |
|
\_SB.ATKD.DS3S (Arg0) |
|
OEMS (Arg0) |
|
} |
|
} |
|
|
|
Method (WAK, 1, NotSerialized) |
|
{ |
|
SWAK (Arg0) |
|
\_SB.PCI0.NWAK (Arg0) |
|
\_SB.ATKD.GENW (Arg0) |
|
\_SB.ATKD.DS3W (Arg0) |
|
OEMW (Arg0) |
|
} |
|
} |
|
|
