Created
April 7, 2015 20:21
-
-
Save Tharre/af53a55650c03fb91e6e to your computer and use it in GitHub Desktop.
dsdt.dsl
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Intel ACPI Component Architecture | |
* AML Disassembler version 20140926-64 [Oct 16 2014] | |
* Copyright (c) 2000 - 2014 Intel Corporation | |
* | |
* Disassembly of /sys/firmware/acpi/tables/DSDT, Tue Apr 7 22:18:28 2015 | |
* | |
* Original Table Header: | |
* Signature "DSDT" | |
* Length 0x00014215 (82453) | |
* Revision 0x02 | |
* Checksum 0x4F | |
* OEM ID "_ASUS_" | |
* OEM Table ID "Notebook" | |
* OEM Revision 0x00000013 (19) | |
* Compiler ID "INTL" | |
* Compiler Version 0x20091112 (537465106) | |
*/ | |
DefinitionBlock ("/sys/firmware/acpi/tables/DSDT.aml", "DSDT", 2, "_ASUS_", "Notebook", 0x00000013) | |
{ | |
/* | |
* iASL Warning: There were 2 external control methods found during | |
* disassembly, but only 0 was 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. | |
* | |
* If necessary, 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 (_SB_.IFFS.SFTV, MethodObj) // Warning: Unresolved method, guessing 1 arguments | |
External (HNOT, MethodObj) // Warning: Unresolved method, guessing 1 arguments | |
External (_PR_.CPU0._PSS, PkgObj) | |
External (_PR_.CPU0._TSS, IntObj) | |
External (_SB_.IFFS.FFSS, UnknownObj) | |
External (PDC0, IntObj) | |
External (PDC1, IntObj) | |
External (PDC2, IntObj) | |
External (PDC3, IntObj) | |
External (PDC4, IntObj) | |
External (PDC5, IntObj) | |
External (PDC6, IntObj) | |
External (PDC7, IntObj) | |
Name (SMBS, 0x0580) | |
Name (SMBL, 0x20) | |
Name (PMBS, 0x0400) | |
Name (PMLN, 0x80) | |
Name (GPBS, 0x0500) | |
Name (GPLN, 0x80) | |
Name (SMIP, 0xB2) | |
Name (APCB, 0xFEC00000) | |
Name (APCL, 0x1000) | |
Name (SMCR, 0x0430) | |
Name (HPTB, 0xFED00000) | |
Name (HPTC, 0xFED1F404) | |
Name (FLSZ, 0x00600000) | |
Name (SRCB, 0xFED1C000) | |
Name (RCLN, 0x4000) | |
Name (TCBR, 0xFED08000) | |
Name (TCLT, 0x1000) | |
Name (PEBS, 0xF8000000) | |
Name (PELN, 0x04000000) | |
Name (LAPB, 0xFEE00000) | |
Name (EGPB, 0xFED19000) | |
Name (MCHB, 0xFED10000) | |
Name (VTBS, 0xFED90000) | |
Name (VTLN, 0x4000) | |
Name (ACPH, 0xDE) | |
Name (ASSB, Zero) | |
Name (AOTB, Zero) | |
Name (AAXB, Zero) | |
Name (PEHP, Zero) | |
Name (SHPC, Zero) | |
Name (PEPM, Zero) | |
Name (PEER, Zero) | |
Name (PECS, Zero) | |
Name (ITKE, Zero) | |
Name (DPPB, 0xFED98000) | |
Name (DPPL, 0x8000) | |
Name (FMBL, One) | |
Name (FDTP, 0x02) | |
Name (FUPS, 0x03) | |
Name (FUWS, 0x04) | |
Name (BSH, Zero) | |
Name (BEL, One) | |
Name (BEH, 0x02) | |
Name (BRH, 0x03) | |
Name (BTF, 0x04) | |
Name (BHC, 0x05) | |
Name (BYB, 0x06) | |
Name (BPH, 0x07) | |
Name (BSHS, 0x08) | |
Name (BELC, 0x09) | |
Name (BRHP, 0x0A) | |
Name (BTFC, 0x0B) | |
Name (BEHP, 0x0C) | |
Name (BPHS, 0x0D) | |
Name (BELP, 0x0E) | |
Name (BTL, 0x10) | |
Name (BTFP, 0x11) | |
Name (BSR, 0x14) | |
Name (BOF, 0x20) | |
Name (BEF, 0x21) | |
Name (BLLE, 0x22) | |
Name (BLLC, 0x23) | |
Name (BLCA, 0x24) | |
Name (BLLS, 0x25) | |
Name (BLLP, 0x26) | |
Name (BLLD, 0x27) | |
Name (BHBE, 0x30) | |
Name (BHBC, 0x31) | |
Name (BHBN, 0x32) | |
Name (BHBM, 0x33) | |
Name (TRTP, One) | |
Name (WDTE, One) | |
Name (TRTD, 0x02) | |
Name (TRTI, 0x03) | |
Name (GCDD, One) | |
Name (DSTA, 0x0A) | |
Name (DSLO, 0x0C) | |
Name (DSLC, 0x0E) | |
Name (PITS, 0x10) | |
Name (SBCS, 0x12) | |
Name (SALS, 0x13) | |
Name (LSSS, 0x2A) | |
Name (SOOT, 0x35) | |
Name (PDBR, 0x4D) | |
Name (SRSI, 0xB2) | |
Name (CSMI, 0x61) | |
Name (DSSP, Zero) | |
Name (FHPP, One) | |
Name (SMIT, 0xB2) | |
Name (OFST, 0x35) | |
Name (TPMF, Zero) | |
Name (TCMF, Zero) | |
Name (TMF1, Zero) | |
Name (TMF2, Zero) | |
Name (TMF3, Zero) | |
Name (TRST, 0x02) | |
Name (MBEC, Zero) | |
Name (MBLF, 0x0A) | |
Name (SS1, Zero) | |
Name (SS2, Zero) | |
Name (SS3, One) | |
Name (SS4, One) | |
Name (IOST, 0x4400) | |
Name (TOPM, 0x00000000) | |
Name (ROMS, 0xFFE00000) | |
Name (VGAF, One) | |
OperationRegion (GNVS, SystemMemory, 0xCA87FE18, 0x01D1) | |
Field (GNVS, AnyAcc, Lock, Preserve) | |
{ | |
OSYS, 16, | |
SMIF, 8, | |
PRM0, 8, | |
PRM1, 8, | |
SCIF, 8, | |
PRM2, 8, | |
PRM3, 8, | |
LCKF, 8, | |
PRM4, 8, | |
PRM5, 8, | |
P80D, 32, | |
LIDS, 8, | |
PWRS, 8, | |
DBGS, 8, | |
THOF, 8, | |
ACT1, 8, | |
ACTT, 8, | |
PSVT, 8, | |
TC1V, 8, | |
TC2V, 8, | |
TSPV, 8, | |
CRTT, 8, | |
DTSE, 8, | |
DTS1, 8, | |
DTS2, 8, | |
DTSF, 8, | |
Offset (0x25), | |
REVN, 8, | |
RES3, 8, | |
Offset (0x28), | |
APIC, 8, | |
TCNT, 8, | |
PCP0, 8, | |
PCP1, 8, | |
PPCM, 8, | |
PPMF, 32, | |
C67L, 8, | |
NATP, 8, | |
CMAP, 8, | |
CMBP, 8, | |
LPTP, 8, | |
FDCP, 8, | |
CMCP, 8, | |
CIRP, 8, | |
SMSC, 8, | |
W381, 8, | |
SMC1, 8, | |
IGDS, 8, | |
TLST, 8, | |
CADL, 8, | |
PADL, 8, | |
CSTE, 16, | |
NSTE, 16, | |
SSTE, 16, | |
NDID, 8, | |
DID1, 32, | |
DID2, 32, | |
DID3, 32, | |
DID4, 32, | |
DID5, 32, | |
KSV0, 32, | |
KSV1, 8, | |
Offset (0x67), | |
BLCS, 8, | |
BRTL, 8, | |
ALSE, 8, | |
ALAF, 8, | |
LLOW, 8, | |
LHIH, 8, | |
Offset (0x6E), | |
EMAE, 8, | |
EMAP, 16, | |
EMAL, 16, | |
Offset (0x74), | |
MEFE, 8, | |
DSTS, 8, | |
Offset (0x78), | |
TPMP, 8, | |
TPME, 8, | |
MORD, 8, | |
TCGP, 8, | |
PPRP, 32, | |
PPRQ, 8, | |
LPPR, 8, | |
GTF0, 56, | |
GTF2, 56, | |
IDEM, 8, | |
GTF1, 56, | |
BID, 8, | |
PLID, 8, | |
Offset (0xAA), | |
ASLB, 32, | |
IBTT, 8, | |
IPAT, 8, | |
ITVF, 8, | |
ITVM, 8, | |
IPSC, 8, | |
IBLC, 8, | |
IBIA, 8, | |
ISSC, 8, | |
I409, 8, | |
I509, 8, | |
I609, 8, | |
I709, 8, | |
IPCF, 8, | |
IDMS, 8, | |
IF1E, 8, | |
HVCO, 8, | |
NXD1, 32, | |
NXD2, 32, | |
NXD3, 32, | |
NXD4, 32, | |
NXD5, 32, | |
NXD6, 32, | |
NXD7, 32, | |
NXD8, 32, | |
GSMI, 8, | |
PAVP, 8, | |
Offset (0xE1), | |
OSCC, 8, | |
NEXP, 8, | |
SBV1, 8, | |
SBV2, 8, | |
Offset (0xEB), | |
DSEN, 8, | |
ECON, 8, | |
GPIC, 8, | |
CTYP, 8, | |
L01C, 8, | |
VFN0, 8, | |
VFN1, 8, | |
VFN2, 8, | |
VFN3, 8, | |
VFN4, 8, | |
Offset (0x100), | |
NVGA, 32, | |
NVHA, 32, | |
AMDA, 32, | |
DID6, 32, | |
DID7, 32, | |
DID8, 32, | |
EBAS, 32, | |
CPSP, 32, | |
EECP, 32, | |
EVCP, 32, | |
XBAS, 32, | |
OBS1, 32, | |
OBS2, 32, | |
OBS3, 32, | |
OBS4, 32, | |
OBS5, 32, | |
OBS6, 32, | |
OBS7, 32, | |
OBS8, 32, | |
Offset (0x157), | |
ATMC, 8, | |
PTMC, 8, | |
ATRA, 8, | |
PTRA, 8, | |
PNHM, 32, | |
TBAB, 32, | |
TBAH, 32, | |
RTIP, 8, | |
TSOD, 8, | |
ATPC, 8, | |
PTPC, 8, | |
PFLV, 8, | |
BREV, 8, | |
SGMD, 8, | |
SGFL, 8, | |
PWOK, 8, | |
HLRS, 8, | |
DSEL, 8, | |
ESEL, 8, | |
PSEL, 8, | |
PWEN, 8, | |
PRST, 8, | |
MXD1, 32, | |
MXD2, 32, | |
MXD3, 32, | |
MXD4, 32, | |
MXD5, 32, | |
MXD6, 32, | |
MXD7, 32, | |
MXD8, 32, | |
GBAS, 16, | |
SGGP, 8, | |
PXFX, 8, | |
PXDY, 8, | |
PXFD, 8, | |
Offset (0x19D), | |
ALFP, 8, | |
IMON, 8, | |
PDTS, 8, | |
PKGA, 8, | |
PAMT, 8, | |
AC0F, 8, | |
AC1F, 8, | |
DTS3, 8, | |
DTS4, 8, | |
Offset (0x1B2), | |
XHCI, 8, | |
XHPM, 8, | |
Offset (0x1B7), | |
XTUB, 32, | |
XTUS, 32, | |
XMPB, 32, | |
Offset (0x1C4), | |
LPMV, 8, | |
Offset (0x1C6), | |
DDRF, 8, | |
MM64, 8, | |
AOAC, 8, | |
SLDR, 32, | |
ECTM, 32 | |
} | |
Scope (_SB) | |
{ | |
Name (PR00, Package (0x23) | |
{ | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
One, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
One, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
0x03, | |
LNKB, | |
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) | |
{ | |
0x0001FFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
One, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x03, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
Zero, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
One, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
0x02, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
0x03, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
One, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
0x02, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
0x03, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
Zero, | |
LNKH, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
One, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
0x03, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001BFFFF, | |
Zero, | |
LNKG, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
One, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
0x03, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
Zero, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
0x03, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0014FFFF, | |
Zero, | |
LNKA, | |
Zero | |
} | |
}) | |
Name (AR00, Package (0x23) | |
{ | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
One, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
One, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
0x03, | |
Zero, | |
0x11 | |
}, | |
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) | |
{ | |
0x0001FFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
One, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x03, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
Zero, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
One, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
0x02, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x0006FFFF, | |
0x03, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
One, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
0x02, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
0x03, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x001DFFFF, | |
Zero, | |
Zero, | |
0x17 | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
One, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
0x03, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x001BFFFF, | |
Zero, | |
Zero, | |
0x16 | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
One, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x001CFFFF, | |
0x03, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
Zero, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
0x03, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0014FFFF, | |
Zero, | |
Zero, | |
0x10 | |
} | |
}) | |
Name (PR04, 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 (AR04, 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 (PR05, 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 (AR05, 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 (PR06, 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 (AR06, 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 (PR07, 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 (AR07, 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 (PR08, 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 (AR08, 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 (PR09, 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 (AR09, 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 (PR0E, 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 (AR0E, 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 (PR0F, 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 (AR0F, 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 (PR01, Package (0x10) | |
{ | |
Package (0x04) | |
{ | |
0xFFFF, | |
Zero, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
One, | |
LNKG, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
0x02, | |
LNKH, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
0x03, | |
LNKE, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
Zero, | |
LNKG, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
One, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x02, | |
LNKE, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x03, | |
LNKH, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
One, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
0x02, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
0x03, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
Zero, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
One, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
0x02, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
0x03, | |
LNKG, | |
Zero | |
} | |
}) | |
Name (AR01, Package (0x10) | |
{ | |
Package (0x04) | |
{ | |
0xFFFF, | |
Zero, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
One, | |
Zero, | |
0x16 | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
0x02, | |
Zero, | |
0x17 | |
}, | |
Package (0x04) | |
{ | |
0xFFFF, | |
0x03, | |
Zero, | |
0x14 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
Zero, | |
Zero, | |
0x16 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
One, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x02, | |
Zero, | |
0x14 | |
}, | |
Package (0x04) | |
{ | |
0x0001FFFF, | |
0x03, | |
Zero, | |
0x17 | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
One, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
0x02, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
0x03, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
Zero, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
One, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
0x02, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
0x03, | |
Zero, | |
0x16 | |
} | |
}) | |
Name (PR02, 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 (AR02, 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 (PR0A, 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 (AR0A, 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 (PR0B, 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 (AR0B, 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 (PR0C, 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 (AR0C, 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, ) | |
{3,4,5,6,7,10,11,12} | |
}) | |
Name (PRSB, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{3,4,5,6,7,10,12} | |
}) | |
Alias (PRSB, PRSC) | |
Alias (PRSB, PRSD) | |
Alias (PRSB, PRSE) | |
Alias (PRSB, PRSF) | |
Alias (PRSB, PRSG) | |
Alias (PRSB, PRSH) | |
Device (PCI0) | |
{ | |
Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID | |
Name (_ADR, Zero) // _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 ()) | |
} | |
Return (PR00 ()) | |
} | |
OperationRegion (HBUS, PCI_Config, Zero, 0x0100) | |
Field (HBUS, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x40), | |
EPEN, 1, | |
, 11, | |
EPBR, 20, | |
Offset (0x48), | |
MHEN, 1, | |
, 14, | |
MHBR, 17, | |
Offset (0x50), | |
GCLK, 1, | |
Offset (0x54), | |
D0EN, 1, | |
Offset (0x60), | |
PXEN, 1, | |
PXSZ, 2, | |
, 23, | |
PXBR, 6, | |
Offset (0x68), | |
DIEN, 1, | |
, 11, | |
DIBR, 20, | |
Offset (0x70), | |
, 20, | |
MEBR, 12, | |
Offset (0x80), | |
, 4, | |
PM0H, 2, | |
Offset (0x81), | |
PM1L, 2, | |
, 2, | |
PM1H, 2, | |
Offset (0x82), | |
PM2L, 2, | |
, 2, | |
PM2H, 2, | |
Offset (0x83), | |
PM3L, 2, | |
, 2, | |
PM3H, 2, | |
Offset (0x84), | |
PM4L, 2, | |
, 2, | |
PM4H, 2, | |
Offset (0x85), | |
PM5L, 2, | |
, 2, | |
PM5H, 2, | |
Offset (0x86), | |
PM6L, 2, | |
, 2, | |
PM6H, 2, | |
Offset (0x87), | |
Offset (0xA8), | |
, 20, | |
TUUD, 19, | |
Offset (0xBC), | |
, 20, | |
TLUD, 12, | |
Offset (0xC8), | |
, 7, | |
HTSE, 1 | |
} | |
OperationRegion (MCHT, SystemMemory, 0xFED10000, 0x1100) | |
Field (MCHT, ByteAcc, NoLock, Preserve) | |
{ | |
} | |
Name (BUF0, ResourceTemplate () | |
{ | |
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, | |
0x0000, // Granularity | |
0x0000, // Range Minimum | |
0x00FF, // Range Maximum | |
0x0000, // Translation Offset | |
0x0100, // Length | |
,, _Y00) | |
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
0x00000000, // Granularity | |
0x00000000, // Range Minimum | |
0x00000CF7, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00000CF8, // Length | |
,, , TypeStatic) | |
IO (Decode16, | |
0x0CF8, // Range Minimum | |
0x0CF8, // Range Maximum | |
0x01, // Alignment | |
0x08, // Length | |
) | |
DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
0x00000000, // Granularity | |
0x00000D00, // Range Minimum | |
0x0000FFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x0000F300, // Length | |
,, , TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000A0000, // Range Minimum | |
0x000BFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00020000, // Length | |
,, , AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000C0000, // Range Minimum | |
0x000C3FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y01, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000C4000, // Range Minimum | |
0x000C7FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y02, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000C8000, // Range Minimum | |
0x000CBFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y03, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000CC000, // Range Minimum | |
0x000CFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y04, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000D0000, // Range Minimum | |
0x000D3FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y05, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000D4000, // Range Minimum | |
0x000D7FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y06, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000D8000, // Range Minimum | |
0x000DBFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y07, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000DC000, // Range Minimum | |
0x000DFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y08, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000E0000, // Range Minimum | |
0x000E3FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y09, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000E4000, // Range Minimum | |
0x000E7FFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y0A, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000E8000, // Range Minimum | |
0x000EBFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y0B, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000EC000, // Range Minimum | |
0x000EFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00004000, // Length | |
,, _Y0C, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000F0000, // Range Minimum | |
0x000FFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00010000, // Length | |
,, _Y0D, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x00000000, // Range Minimum | |
0xFEAFFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0xFEB00000, // Length | |
,, _Y0E, AddressRangeMemory, TypeStatic) | |
QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x0000000000000000, // Granularity | |
0x0000000000010000, // Range Minimum | |
0x000000000001FFFF, // Range Maximum | |
0x0000000000000000, // Translation Offset | |
0x0000000000010000, // Length | |
,, _Y0F, AddressRangeMemory, TypeStatic) | |
}) | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
CreateWordField (BUF0, \_SB.PCI0._Y00._MAX, PBMX) // _MAX: Maximum Base Address | |
Store (Subtract (ShiftRight (PELN, 0x14), 0x02), PBMX) /* \_SB_.PCI0._CRS.PBMX */ | |
CreateWordField (BUF0, \_SB.PCI0._Y00._LEN, PBLN) // _LEN: Length | |
Store (Subtract (ShiftRight (PELN, 0x14), One), PBLN) /* \_SB_.PCI0._CRS.PBLN */ | |
If (PM1L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y01._LEN, C0LN) // _LEN: Length | |
Store (Zero, C0LN) /* \_SB_.PCI0._CRS.C0LN */ | |
} | |
If (LEqual (PM1L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y01._RW, C0RW) // _RW_: Read-Write Status | |
Store (Zero, C0RW) /* \_SB_.PCI0._CRS.C0RW */ | |
} | |
If (PM1H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y02._LEN, C4LN) // _LEN: Length | |
Store (Zero, C4LN) /* \_SB_.PCI0._CRS.C4LN */ | |
} | |
If (LEqual (PM1H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y02._RW, C4RW) // _RW_: Read-Write Status | |
Store (Zero, C4RW) /* \_SB_.PCI0._CRS.C4RW */ | |
} | |
If (PM2L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y03._LEN, C8LN) // _LEN: Length | |
Store (Zero, C8LN) /* \_SB_.PCI0._CRS.C8LN */ | |
} | |
If (LEqual (PM2L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y03._RW, C8RW) // _RW_: Read-Write Status | |
Store (Zero, C8RW) /* \_SB_.PCI0._CRS.C8RW */ | |
} | |
If (PM2H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y04._LEN, CCLN) // _LEN: Length | |
Store (Zero, CCLN) /* \_SB_.PCI0._CRS.CCLN */ | |
} | |
If (LEqual (PM2H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y04._RW, CCRW) // _RW_: Read-Write Status | |
Store (Zero, CCRW) /* \_SB_.PCI0._CRS.CCRW */ | |
} | |
If (PM3L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y05._LEN, D0LN) // _LEN: Length | |
Store (Zero, D0LN) /* \_SB_.PCI0._CRS.D0LN */ | |
} | |
If (LEqual (PM3L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y05._RW, D0RW) // _RW_: Read-Write Status | |
Store (Zero, D0RW) /* \_SB_.PCI0._CRS.D0RW */ | |
} | |
If (PM3H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y06._LEN, D4LN) // _LEN: Length | |
Store (Zero, D4LN) /* \_SB_.PCI0._CRS.D4LN */ | |
} | |
If (LEqual (PM3H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y06._RW, D4RW) // _RW_: Read-Write Status | |
Store (Zero, D4RW) /* \_SB_.PCI0._CRS.D4RW */ | |
} | |
If (PM4L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y07._LEN, D8LN) // _LEN: Length | |
Store (Zero, D8LN) /* \_SB_.PCI0._CRS.D8LN */ | |
} | |
If (LEqual (PM4L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y07._RW, D8RW) // _RW_: Read-Write Status | |
Store (Zero, D8RW) /* \_SB_.PCI0._CRS.D8RW */ | |
} | |
If (PM4H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y08._LEN, DCLN) // _LEN: Length | |
Store (Zero, DCLN) /* \_SB_.PCI0._CRS.DCLN */ | |
} | |
If (LEqual (PM4H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y08._RW, DCRW) // _RW_: Read-Write Status | |
Store (Zero, DCRW) /* \_SB_.PCI0._CRS.DCRW */ | |
} | |
If (PM5L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y09._LEN, E0LN) // _LEN: Length | |
Store (Zero, E0LN) /* \_SB_.PCI0._CRS.E0LN */ | |
} | |
If (LEqual (PM5L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y09._RW, E0RW) // _RW_: Read-Write Status | |
Store (Zero, E0RW) /* \_SB_.PCI0._CRS.E0RW */ | |
} | |
If (PM5H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y0A._LEN, E4LN) // _LEN: Length | |
Store (Zero, E4LN) /* \_SB_.PCI0._CRS.E4LN */ | |
} | |
If (LEqual (PM5H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y0A._RW, E4RW) // _RW_: Read-Write Status | |
Store (Zero, E4RW) /* \_SB_.PCI0._CRS.E4RW */ | |
} | |
If (PM6L) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y0B._LEN, E8LN) // _LEN: Length | |
Store (Zero, E8LN) /* \_SB_.PCI0._CRS.E8LN */ | |
} | |
If (LEqual (PM6L, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y0B._RW, E8RW) // _RW_: Read-Write Status | |
Store (Zero, E8RW) /* \_SB_.PCI0._CRS.E8RW */ | |
} | |
If (PM6H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y0C._LEN, ECLN) // _LEN: Length | |
Store (Zero, ECLN) /* \_SB_.PCI0._CRS.ECLN */ | |
} | |
If (LEqual (PM6H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y0C._RW, ECRW) // _RW_: Read-Write Status | |
Store (Zero, ECRW) /* \_SB_.PCI0._CRS.ECRW */ | |
} | |
If (PM0H) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y0D._LEN, F0LN) // _LEN: Length | |
Store (Zero, F0LN) /* \_SB_.PCI0._CRS.F0LN */ | |
} | |
If (LEqual (PM0H, One)) | |
{ | |
CreateBitField (BUF0, \_SB.PCI0._Y0D._RW, F0RW) // _RW_: Read-Write Status | |
Store (Zero, F0RW) /* \_SB_.PCI0._CRS.F0RW */ | |
} | |
CreateDWordField (BUF0, \_SB.PCI0._Y0E._MIN, M1MN) // _MIN: Minimum Base Address | |
CreateDWordField (BUF0, \_SB.PCI0._Y0E._MAX, M1MX) // _MAX: Maximum Base Address | |
CreateDWordField (BUF0, \_SB.PCI0._Y0E._LEN, M1LN) // _LEN: Length | |
ShiftLeft (TLUD, 0x14, M1MN) /* \_SB_.PCI0._CRS.M1MN */ | |
Add (Subtract (M1MX, M1MN), One, M1LN) /* \_SB_.PCI0._CRS.M1LN */ | |
If (LOr (LEqual (MM64, Zero), LLessEqual (OSYS, 0x07D3))) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0._Y0F._LEN, MSLN) // _LEN: Length | |
Store (Zero, MSLN) /* \_SB_.PCI0._CRS.MSLN */ | |
} | |
Else | |
{ | |
CreateQWordField (BUF0, \_SB.PCI0._Y0F._LEN, M2LN) // _LEN: Length | |
CreateQWordField (BUF0, \_SB.PCI0._Y0F._MIN, M2MN) // _MIN: Minimum Base Address | |
CreateQWordField (BUF0, \_SB.PCI0._Y0F._MAX, M2MX) // _MAX: Maximum Base Address | |
Store (0x0000000400000000, M2LN) /* \_SB_.PCI0._CRS.M2LN */ | |
If (LGreaterEqual (TUUD, 0x1000)) | |
{ | |
ShiftLeft (TUUD, 0x14, M2MN) /* \_SB_.PCI0._CRS.M2MN */ | |
} | |
Else | |
{ | |
Store (0x0000000100000000, M2MN) /* \_SB_.PCI0._CRS.M2MN */ | |
} | |
Subtract (Add (M2MN, M2LN), One, M2MX) /* \_SB_.PCI0._CRS.M2MX */ | |
} | |
Return (BUF0) /* \_SB_.PCI0.BUF0 */ | |
} | |
Name (GUID, ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */) | |
Name (SUPP, Zero) | |
Name (CTRL, Zero) | |
Name (XCNT, Zero) | |
Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities | |
{ | |
Store (Arg3, Local0) | |
CreateDWordField (Local0, Zero, CDW1) | |
CreateDWordField (Local0, 0x04, CDW2) | |
CreateDWordField (Local0, 0x08, CDW3) | |
If (^XHC.CUID (Arg0)) | |
{ | |
Return (^XHC.POSC (Arg1, Arg2, Arg3)) | |
} | |
Else | |
{ | |
If (_OSI ("Windows 2012")) | |
{ | |
If (LEqual (XCNT, Zero)) | |
{ | |
^XHC.XSEL () | |
Increment (XCNT) | |
} | |
} | |
} | |
If (LEqual (Arg0, GUID)) | |
{ | |
Store (CDW2, SUPP) /* \_SB_.PCI0.SUPP */ | |
Store (CDW3, CTRL) /* \_SB_.PCI0.CTRL */ | |
If (LEqual (NEXP, Zero)) | |
{ | |
And (CTRL, 0xFFFFFFF8, CTRL) /* \_SB_.PCI0.CTRL */ | |
} | |
If (NEXP) | |
{ | |
If (Not (And (CDW1, One))) | |
{ | |
If (And (CTRL, One)) | |
{ | |
NHPG () | |
} | |
If (And (CTRL, 0x04)) | |
{ | |
NPME () | |
} | |
} | |
} | |
If (LNotEqual (Arg1, One)) | |
{ | |
Or (CDW1, 0x08, CDW1) /* \_SB_.PCI0._OSC.CDW1 */ | |
} | |
If (LNotEqual (CDW3, CTRL)) | |
{ | |
Or (CDW1, 0x10, CDW1) /* \_SB_.PCI0._OSC.CDW1 */ | |
} | |
Store (CTRL, CDW3) /* \_SB_.PCI0._OSC.CDW3 */ | |
Store (CTRL, OSCC) /* \OSCC */ | |
Return (Local0) | |
} | |
Else | |
{ | |
Or (CDW1, 0x04, CDW1) /* \_SB_.PCI0._OSC.CDW1 */ | |
Return (Local0) | |
} | |
} | |
Scope (\_SB.PCI0) | |
{ | |
Method (AR00, 0, NotSerialized) | |
{ | |
Return (^^AR00) /* \_SB_.AR00 */ | |
} | |
Method (PR00, 0, NotSerialized) | |
{ | |
Return (^^PR00) /* \_SB_.PR00 */ | |
} | |
Method (AR01, 0, NotSerialized) | |
{ | |
Return (^^AR01) /* \_SB_.AR01 */ | |
} | |
Method (PR01, 0, NotSerialized) | |
{ | |
Return (^^PR01) /* \_SB_.PR01 */ | |
} | |
Method (AR02, 0, NotSerialized) | |
{ | |
Return (^^AR02) /* \_SB_.AR02 */ | |
} | |
Method (PR02, 0, NotSerialized) | |
{ | |
Return (^^PR02) /* \_SB_.PR02 */ | |
} | |
Method (AR04, 0, NotSerialized) | |
{ | |
Return (^^AR04) /* \_SB_.AR04 */ | |
} | |
Method (PR04, 0, NotSerialized) | |
{ | |
Return (^^PR04) /* \_SB_.PR04 */ | |
} | |
Method (AR05, 0, NotSerialized) | |
{ | |
Return (^^AR05) /* \_SB_.AR05 */ | |
} | |
Method (PR05, 0, NotSerialized) | |
{ | |
Return (^^PR05) /* \_SB_.PR05 */ | |
} | |
Method (AR06, 0, NotSerialized) | |
{ | |
Return (^^AR06) /* \_SB_.AR06 */ | |
} | |
Method (PR06, 0, NotSerialized) | |
{ | |
Return (^^PR06) /* \_SB_.PR06 */ | |
} | |
Method (AR07, 0, NotSerialized) | |
{ | |
Return (^^AR07) /* \_SB_.AR07 */ | |
} | |
Method (PR07, 0, NotSerialized) | |
{ | |
Return (^^PR07) /* \_SB_.PR07 */ | |
} | |
Method (AR08, 0, NotSerialized) | |
{ | |
Return (^^AR08) /* \_SB_.AR08 */ | |
} | |
Method (PR08, 0, NotSerialized) | |
{ | |
Return (^^PR08) /* \_SB_.PR08 */ | |
} | |
Method (AR09, 0, NotSerialized) | |
{ | |
Return (^^AR09) /* \_SB_.AR09 */ | |
} | |
Method (PR09, 0, NotSerialized) | |
{ | |
Return (^^PR09) /* \_SB_.PR09 */ | |
} | |
Method (AR0E, 0, NotSerialized) | |
{ | |
Return (^^AR0E) /* \_SB_.AR0E */ | |
} | |
Method (PR0E, 0, NotSerialized) | |
{ | |
Return (^^PR0E) /* \_SB_.PR0E */ | |
} | |
Method (AR0F, 0, NotSerialized) | |
{ | |
Return (^^AR0F) /* \_SB_.AR0F */ | |
} | |
Method (PR0F, 0, NotSerialized) | |
{ | |
Return (^^PR0F) /* \_SB_.PR0F */ | |
} | |
Method (AR0A, 0, NotSerialized) | |
{ | |
Return (^^AR0A) /* \_SB_.AR0A */ | |
} | |
Method (PR0A, 0, NotSerialized) | |
{ | |
Return (^^PR0A) /* \_SB_.PR0A */ | |
} | |
Method (AR0B, 0, NotSerialized) | |
{ | |
Return (^^AR0B) /* \_SB_.AR0B */ | |
} | |
Method (PR0B, 0, NotSerialized) | |
{ | |
Return (^^PR0B) /* \_SB_.PR0B */ | |
} | |
Method (AR0C, 0, NotSerialized) | |
{ | |
Return (^^AR0C) /* \_SB_.AR0C */ | |
} | |
Method (PR0C, 0, NotSerialized) | |
{ | |
Return (^^PR0C) /* \_SB_.PR0C */ | |
} | |
} | |
Device (TPMX) | |
{ | |
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID | |
Name (_UID, One) // _UID: Unique ID | |
Name (CRS, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFED40000, // Address Base | |
0x00005000, // Address Length | |
) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Return (CRS) /* \_SB_.PCI0.TPMX.CRS_ */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (TPMF) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
} | |
Device (P0P1) | |
{ | |
Name (_ADR, 0x001E0000) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0B, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR01 ()) | |
} | |
Return (PR01 ()) | |
} | |
} | |
Device (B0D4) | |
{ | |
Name (_ADR, 0x00040000) // _ADR: Address | |
} | |
Device (PEG0) | |
{ | |
Name (_ADR, 0x00010000) // _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 (AR02 ()) | |
} | |
Return (PR02 ()) | |
} | |
Device (PEGP) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
} | |
} | |
Device (PEG1) | |
{ | |
Name (_ADR, 0x00010001) // _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 (AR0A ()) | |
} | |
Return (PR0A ()) | |
} | |
} | |
Device (PEG2) | |
{ | |
Name (_ADR, 0x00010002) // _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 (AR0B ()) | |
} | |
Return (PR0B ()) | |
} | |
} | |
Device (PEG3) | |
{ | |
Name (_ADR, 0x00060000) // _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 (AR0C ()) | |
} | |
Return (PR0C ()) | |
} | |
} | |
Device (USB1) | |
{ | |
Name (_ADR, 0x001D0001) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x03, 0x03)) | |
} | |
} | |
Device (USB2) | |
{ | |
Name (_ADR, 0x001D0002) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x04, 0x03)) | |
} | |
} | |
Device (USB3) | |
{ | |
Name (_ADR, 0x001D0003) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0C, 0x03)) | |
} | |
} | |
Device (USB4) | |
{ | |
Name (_ADR, 0x001D0004) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0E, 0x03)) | |
} | |
} | |
Device (EHC2) | |
{ | |
Name (_ADR, 0x001A0000) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0D, 0x03)) | |
} | |
} | |
Device (USB5) | |
{ | |
Name (_ADR, 0x001A0001) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x05, 0x03)) | |
} | |
} | |
Device (USB6) | |
{ | |
Name (_ADR, 0x001A0002) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x20, 0x03)) | |
} | |
} | |
Device (USB7) | |
{ | |
Name (_ADR, 0x001A0003) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x25, 0x03)) | |
} | |
} | |
Device (HDEF) | |
{ | |
Name (_ADR, 0x001B0000) // _ADR: Address | |
OperationRegion (HDAR, PCI_Config, 0x4C, 0x10) | |
Field (HDAR, WordAcc, NoLock, Preserve) | |
{ | |
DCKA, 1, | |
Offset (0x01), | |
DCKM, 1, | |
, 6, | |
DCKS, 1, | |
Offset (0x08), | |
, 15, | |
PMES, 1 | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0D, 0x04)) | |
} | |
} | |
Device (RP01) | |
{ | |
Name (_ADR, 0x001C0000) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP01.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP01.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP01.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR04 ()) | |
} | |
Return (PR04 ()) | |
} | |
} | |
Device (RP03) | |
{ | |
Name (_ADR, 0x001C0002) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP03.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP03.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP03.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR06 ()) | |
} | |
Return (PR06 ()) | |
} | |
} | |
Device (RP04) | |
{ | |
Name (_ADR, 0x001C0003) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP04.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP04.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP04.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR07 ()) | |
} | |
Return (PR07 ()) | |
} | |
} | |
Device (RP05) | |
{ | |
Name (_ADR, 0x001C0004) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP05.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP05.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP05.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR08 ()) | |
} | |
Return (PR08 ()) | |
} | |
} | |
Device (RP06) | |
{ | |
Name (_ADR, 0x001C0005) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP06.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP06.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP06.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR09 ()) | |
} | |
Return (PR09 ()) | |
} | |
} | |
Device (RP07) | |
{ | |
Name (_ADR, 0x001C0006) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP07.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP07.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP07.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR0E ()) | |
} | |
Return (PR0E ()) | |
} | |
} | |
Device (RP08) | |
{ | |
Name (_ADR, 0x001C0007) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP08.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP08.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP08.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR0F ()) | |
} | |
Return (PR0F ()) | |
} | |
} | |
Device (LPCB) | |
{ | |
Name (_ADR, 0x001F0000) // _ADR: Address | |
Scope (\_SB) | |
{ | |
OperationRegion (PCI0.LPCB.LPC1, PCI_Config, 0x40, 0xC0) | |
Field (PCI0.LPCB.LPC1, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x20), | |
PARC, 8, | |
PBRC, 8, | |
PCRC, 8, | |
PDRC, 8, | |
Offset (0x28), | |
PERC, 8, | |
PFRC, 8, | |
PGRC, 8, | |
PHRC, 8, | |
Offset (0x6C), | |
Offset (0x6D), | |
Offset (0x6E), | |
XUSB, 1 | |
} | |
Device (LNKA) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, One) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PARC, 0x80, PARC) /* \_SB_.PARC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSA) /* \_SB_.PRSA */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLA, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLA, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKA._CRS.IRQ0 */ | |
ShiftLeft (One, And (PARC, 0x0F), IRQ0) /* \_SB_.LNKA._CRS.IRQ0 */ | |
Return (RTLA) /* \_SB_.LNKA._CRS.RTLA */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PARC) /* \_SB_.PARC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PARC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKB) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x02) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PBRC, 0x80, PBRC) /* \_SB_.PBRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSB) /* \_SB_.PRSB */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLB, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLB, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKB._CRS.IRQ0 */ | |
ShiftLeft (One, And (PBRC, 0x0F), IRQ0) /* \_SB_.LNKB._CRS.IRQ0 */ | |
Return (RTLB) /* \_SB_.LNKB._CRS.RTLB */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PBRC) /* \_SB_.PBRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PBRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKC) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x03) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PCRC, 0x80, PCRC) /* \_SB_.PCRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSC) /* \_SB_.PRSC */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLC, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLC, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKC._CRS.IRQ0 */ | |
ShiftLeft (One, And (PCRC, 0x0F), IRQ0) /* \_SB_.LNKC._CRS.IRQ0 */ | |
Return (RTLC) /* \_SB_.LNKC._CRS.RTLC */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PCRC) /* \_SB_.PCRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PCRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKD) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x04) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PDRC, 0x80, PDRC) /* \_SB_.PDRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSD) /* \_SB_.PRSD */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLD, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLD, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKD._CRS.IRQ0 */ | |
ShiftLeft (One, And (PDRC, 0x0F), IRQ0) /* \_SB_.LNKD._CRS.IRQ0 */ | |
Return (RTLD) /* \_SB_.LNKD._CRS.RTLD */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PDRC) /* \_SB_.PDRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PDRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKE) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x05) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PERC, 0x80, PERC) /* \_SB_.PERC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSE) /* \_SB_.PRSE */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLE, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLE, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKE._CRS.IRQ0 */ | |
ShiftLeft (One, And (PERC, 0x0F), IRQ0) /* \_SB_.LNKE._CRS.IRQ0 */ | |
Return (RTLE) /* \_SB_.LNKE._CRS.RTLE */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PERC) /* \_SB_.PERC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PERC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKF) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x06) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PFRC, 0x80, PFRC) /* \_SB_.PFRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSF) /* \_SB_.PRSF */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLF, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLF, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKF._CRS.IRQ0 */ | |
ShiftLeft (One, And (PFRC, 0x0F), IRQ0) /* \_SB_.LNKF._CRS.IRQ0 */ | |
Return (RTLF) /* \_SB_.LNKF._CRS.RTLF */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PFRC) /* \_SB_.PFRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PFRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKG) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x07) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PGRC, 0x80, PGRC) /* \_SB_.PGRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSG) /* \_SB_.PRSG */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLG, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLG, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKG._CRS.IRQ0 */ | |
ShiftLeft (One, And (PGRC, 0x0F), IRQ0) /* \_SB_.LNKG._CRS.IRQ0 */ | |
Return (RTLG) /* \_SB_.LNKG._CRS.RTLG */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PGRC) /* \_SB_.PGRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PGRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
Device (LNKH) | |
{ | |
Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
Name (_UID, 0x08) // _UID: Unique ID | |
Method (_DIS, 0, Serialized) // _DIS: Disable Device | |
{ | |
Or (PHRC, 0x80, PHRC) /* \_SB_.PHRC */ | |
} | |
Method (_PRS, 0, Serialized) // _PRS: Possible Resource Settings | |
{ | |
Return (PRSH) /* \_SB_.PRSH */ | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RTLH, ResourceTemplate () | |
{ | |
IRQ (Level, ActiveLow, Shared, ) | |
{} | |
}) | |
CreateWordField (RTLH, One, IRQ0) | |
Store (Zero, IRQ0) /* \_SB_.LNKH._CRS.IRQ0 */ | |
ShiftLeft (One, And (PHRC, 0x0F), IRQ0) /* \_SB_.LNKH._CRS.IRQ0 */ | |
Return (RTLH) /* \_SB_.LNKH._CRS.RTLH */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Decrement (Local0) | |
Store (Local0, PHRC) /* \_SB_.PHRC */ | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (And (PHRC, 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
} | |
OperationRegion (LPC0, PCI_Config, 0x40, 0xC0) | |
Field (LPC0, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x40), | |
IOD0, 8, | |
IOD1, 8, | |
Offset (0xB0), | |
RAEN, 1, | |
, 13, | |
RCBA, 18 | |
} | |
Device (DMAC) | |
{ | |
Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
IO (Decode16, | |
0x0000, // Range Minimum | |
0x0000, // Range Maximum | |
0x01, // Alignment | |
0x20, // Length | |
) | |
IO (Decode16, | |
0x0081, // Range Minimum | |
0x0081, // Range Maximum | |
0x01, // Alignment | |
0x11, // Length | |
) | |
IO (Decode16, | |
0x0093, // Range Minimum | |
0x0093, // Range Maximum | |
0x01, // Alignment | |
0x0D, // Length | |
) | |
IO (Decode16, | |
0x00C0, // Range Minimum | |
0x00C0, // Range Maximum | |
0x01, // Alignment | |
0x20, // Length | |
) | |
DMA (Compatibility, NotBusMaster, Transfer8_16, ) | |
{4} | |
}) | |
} | |
Device (FWHD) | |
{ | |
Name (_HID, EisaId ("INT0800") /* Intel 82802 Firmware Hub Device */) // _HID: Hardware ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFF000000, // Address Base | |
0x01000000, // Address Length | |
) | |
}) | |
} | |
Device (HPET) | |
{ | |
Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID | |
Name (_UID, Zero) // _UID: Unique ID | |
Name (BUF0, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xFED00000, // Address Base | |
0x00000400, // Address Length | |
_Y10) | |
}) | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (LGreaterEqual (OSYS, 0x07D1)) | |
{ | |
If (HPAE) | |
{ | |
Return (0x0F) | |
} | |
} | |
Else | |
{ | |
If (HPAE) | |
{ | |
Return (0x0B) | |
} | |
} | |
Return (Zero) | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
If (HPAE) | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0.LPCB.HPET._Y10._BAS, HPT0) // _BAS: Base Address | |
If (LEqual (HPAS, One)) | |
{ | |
Store (0xFED01000, HPT0) /* \_SB_.PCI0.LPCB.HPET._CRS.HPT0 */ | |
} | |
If (LEqual (HPAS, 0x02)) | |
{ | |
Store (0xFED02000, HPT0) /* \_SB_.PCI0.LPCB.HPET._CRS.HPT0 */ | |
} | |
If (LEqual (HPAS, 0x03)) | |
{ | |
Store (0xFED03000, HPT0) /* \_SB_.PCI0.LPCB.HPET._CRS.HPT0 */ | |
} | |
} | |
Return (BUF0) /* \_SB_.PCI0.LPCB.HPET.BUF0 */ | |
} | |
} | |
Device (IPIC) | |
{ | |
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 | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0024, // Range Minimum | |
0x0024, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0028, // Range Minimum | |
0x0028, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x002C, // Range Minimum | |
0x002C, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0030, // Range Minimum | |
0x0030, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0034, // Range Minimum | |
0x0034, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0038, // Range Minimum | |
0x0038, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x003C, // Range Minimum | |
0x003C, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00A0, // Range Minimum | |
0x00A0, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00A4, // Range Minimum | |
0x00A4, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00A8, // Range Minimum | |
0x00A8, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00AC, // Range Minimum | |
0x00AC, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00B0, // Range Minimum | |
0x00B0, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00B4, // Range Minimum | |
0x00B4, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00B8, // Range Minimum | |
0x00B8, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x00BC, // Range Minimum | |
0x00BC, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x04D0, // Range Minimum | |
0x04D0, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IRQNoFlags () | |
{2} | |
}) | |
} | |
Device (LDRC) | |
{ | |
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
IO (Decode16, | |
0x002E, // Range Minimum | |
0x002E, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x004E, // Range Minimum | |
0x004E, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0061, // Range Minimum | |
0x0061, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0063, // Range Minimum | |
0x0063, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0065, // Range Minimum | |
0x0065, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0067, // Range Minimum | |
0x0067, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0070, // Range Minimum | |
0x0070, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0080, // Range Minimum | |
0x0080, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0092, // Range Minimum | |
0x0092, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x00B2, // Range Minimum | |
0x00B2, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
IO (Decode16, | |
0x0680, // Range Minimum | |
0x0680, // Range Maximum | |
0x01, // Alignment | |
0x20, // Length | |
) | |
IO (Decode16, | |
0x1000, // Range Minimum | |
0x1000, // Range Maximum | |
0x01, // Alignment | |
0x10, // Length | |
) | |
IO (Decode16, | |
0xFFFF, // Range Minimum | |
0xFFFF, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0xFFFF, // Range Minimum | |
0xFFFF, // Range Maximum | |
0x01, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0400, // Range Minimum | |
0x0400, // Range Maximum | |
0x01, // Alignment | |
0x54, // Length | |
) | |
IO (Decode16, | |
0x0458, // Range Minimum | |
0x0458, // Range Maximum | |
0x01, // Alignment | |
0x28, // Length | |
) | |
IO (Decode16, | |
0x0500, // Range Minimum | |
0x0500, // Range Maximum | |
0x01, // Alignment | |
0x80, // Length | |
) | |
IO (Decode16, | |
0x164E, // Range Minimum | |
0x164E, // Range Maximum | |
0x01, // Alignment | |
0x02, // Length | |
) | |
}) | |
} | |
Device (RTC) | |
{ | |
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 | |
0x01, // Alignment | |
0x08, // Length | |
) | |
IRQNoFlags () | |
{8} | |
}) | |
} | |
Device (TIMR) | |
{ | |
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 | |
0x01, // Alignment | |
0x04, // Length | |
) | |
IO (Decode16, | |
0x0050, // Range Minimum | |
0x0050, // Range Maximum | |
0x10, // Alignment | |
0x04, // Length | |
) | |
IRQNoFlags () | |
{0} | |
}) | |
} | |
Device (CWDT) | |
{ | |
Name (_HID, EisaId ("INT3F0D") /* ACPI Motherboard Resources */) // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _CID: Compatible ID | |
Name (BUF0, ResourceTemplate () | |
{ | |
IO (Decode16, | |
0x0454, // Range Minimum | |
0x0454, // Range Maximum | |
0x04, // Alignment | |
0x04, // Length | |
) | |
}) | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (LEqual (WDTE, One)) | |
{ | |
Return (0x0F) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Return (BUF0) /* \_SB_.PCI0.LPCB.CWDT.BUF0 */ | |
} | |
} | |
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 (And (MBEC, 0xFFFF)) | |
{ | |
Return (CRS1) /* \_SB_.PCI0.LPCB.RMSC.CRS1 */ | |
} | |
Else | |
{ | |
Return (CRS2) /* \_SB_.PCI0.LPCB.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 (PS2M) | |
{ | |
Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
{ | |
If (SYNA) | |
{ | |
Return (0x180A2E4F) | |
} | |
If (ALPS) | |
{ | |
Return (0x0713A906) | |
} | |
If (ELAN) | |
{ | |
Return (0x05018416) | |
} | |
If (STLC) | |
{ | |
Return (0x41C18C4E) | |
} | |
Return (0x060A2E4F) | |
} | |
Name (CID0, Package (0x05) | |
{ | |
0x000A2E4F, | |
0x02002E4F, | |
0x030FD041, | |
0x130FD041, | |
0x120FD041 | |
}) | |
Name (CID1, Package (0x03) | |
{ | |
0x000A2E4F, | |
0x02002E4F, | |
0x130FD041 | |
}) | |
Name (CID2, Package (0x01) | |
{ | |
0x130FD041 | |
}) | |
Method (_CID, 0, NotSerialized) // _CID: Compatible ID | |
{ | |
If (SYNA) | |
{ | |
Return (CID1) /* \_SB_.PCI0.LPCB.PS2M.CID1 */ | |
} | |
If (STLC) | |
{ | |
Return (CID2) /* \_SB_.PCI0.LPCB.PS2M.CID2 */ | |
} | |
Return (CID0) /* \_SB_.PCI0.LPCB.PS2M.CID0 */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
ShiftLeft (One, 0x0E, Local0) | |
If (And (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 | |
{ | |
ShiftLeft (One, 0x0A, Local0) | |
If (And (IOST, Local0)) | |
{ | |
Return (CRS1) /* \_SB_.PCI0.LPCB.PS2M.CRS1 */ | |
} | |
Else | |
{ | |
Return (CRS2) /* \_SB_.PCI0.LPCB.PS2M.CRS2 */ | |
} | |
} | |
} | |
Device (PS2K) | |
{ | |
Name (_HID, EisaId ("ATK3001")) // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP030B")) // _CID: Compatible ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (And (IOST, 0x0400)) | |
{ | |
Return (0x0F) | |
} | |
Else | |
{ | |
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} | |
}) | |
Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
{ | |
StartDependentFn (0x00, 0x00) | |
{ | |
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} | |
} | |
EndDependentFn () | |
}) | |
} | |
} | |
Device (IDE0) | |
{ | |
Name (_ADR, 0x001F0002) // _ADR: Address | |
} | |
Device (IDE1) | |
{ | |
Name (_ADR, 0x001F0005) // _ADR: Address | |
} | |
Device (SBUS) | |
{ | |
Name (_ADR, 0x001F0003) // _ADR: Address | |
OperationRegion (SMBP, PCI_Config, 0x40, 0xC0) | |
Field (SMBP, DWordAcc, NoLock, Preserve) | |
{ | |
, 2, | |
I2CE, 1 | |
} | |
OperationRegion (SMPB, PCI_Config, 0x20, 0x04) | |
Field (SMPB, DWordAcc, NoLock, Preserve) | |
{ | |
, 5, | |
SBAR, 11 | |
} | |
OperationRegion (SMBI, SystemIO, ShiftLeft (SBAR, 0x05), 0x10) | |
Field (SMBI, ByteAcc, NoLock, Preserve) | |
{ | |
HSTS, 8, | |
Offset (0x02), | |
HCON, 8, | |
HCOM, 8, | |
TXSA, 8, | |
DAT0, 8, | |
DAT1, 8, | |
HBDR, 8, | |
PECR, 8, | |
RXSA, 8, | |
SDAT, 16 | |
} | |
Method (SSXB, 2, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Arg0, TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (0x48, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRXB, 1, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Or (Arg0, One), TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (0x44, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
} | |
Return (0xFFFF) | |
} | |
Method (SWRB, 3, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Arg0, TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (Arg2, DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
Store (0x48, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRDB, 2, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Or (Arg0, One), TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (0x48, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
} | |
Return (0xFFFF) | |
} | |
Method (SWRW, 3, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Arg0, TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
And (Arg2, 0xFF, DAT1) /* \_SB_.PCI0.SBUS.DAT1 */ | |
And (ShiftRight (Arg2, 0x08), 0xFF, DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
Store (0x4C, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRDW, 2, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
Store (Zero, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Or (Arg0, One), TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (0x4C, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (Or (ShiftLeft (DAT0, 0x08), DAT1)) | |
} | |
Return (0xFFFFFFFF) | |
} | |
Method (SBLW, 4, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
Store (Arg3, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Arg0, TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (SizeOf (Arg2), DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
Store (Zero, Local1) | |
Store (DerefOf (Index (Arg2, Zero)), HBDR) /* \_SB_.PCI0.SBUS.HBDR */ | |
Store (0x54, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
While (LGreater (SizeOf (Arg2), Local1)) | |
{ | |
Store (0x0FA0, Local0) | |
While (LAnd (LNot (And (HSTS, 0x80)), Local0)) | |
{ | |
Decrement (Local0) | |
Stall (0x32) | |
} | |
If (LNot (Local0)) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
Store (0x80, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Increment (Local1) | |
If (LGreater (SizeOf (Arg2), Local1)) | |
{ | |
Store (DerefOf (Index (Arg2, Local1)), HBDR) /* \_SB_.PCI0.SBUS.HBDR */ | |
} | |
} | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SBLR, 3, Serialized) | |
{ | |
Name (TBUF, Buffer (0x0100) {}) | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
Store (Arg2, I2CE) /* \_SB_.PCI0.SBUS.I2CE */ | |
Store (0xBF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (Or (Arg0, One), TXSA) /* \_SB_.PCI0.SBUS.TXSA */ | |
Store (Arg1, HCOM) /* \_SB_.PCI0.SBUS.HCOM */ | |
Store (0x54, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
Store (0x0FA0, Local0) | |
While (LAnd (LNot (And (HSTS, 0x80)), Local0)) | |
{ | |
Decrement (Local0) | |
Stall (0x32) | |
} | |
If (LNot (Local0)) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
Store (DAT0, Index (TBUF, Zero)) | |
Store (0x80, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Store (One, Local1) | |
While (LLess (Local1, DerefOf (Index (TBUF, Zero)))) | |
{ | |
Store (0x0FA0, Local0) | |
While (LAnd (LNot (And (HSTS, 0x80)), Local0)) | |
{ | |
Decrement (Local0) | |
Stall (0x32) | |
} | |
If (LNot (Local0)) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
Store (HBDR, Index (TBUF, Local1)) | |
Store (0x80, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Increment (Local1) | |
} | |
If (COMP ()) | |
{ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
Return (TBUF) /* \_SB_.PCI0.SBUS.SBLR.TBUF */ | |
} | |
Return (Zero) | |
} | |
Method (STRT, 0, Serialized) | |
{ | |
Store (0xC8, Local0) | |
While (Local0) | |
{ | |
If (And (HSTS, 0x40)) | |
{ | |
Decrement (Local0) | |
Sleep (One) | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (One) | |
} | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Store (0x0FA0, Local0) | |
While (Local0) | |
{ | |
If (And (HSTS, One)) | |
{ | |
Decrement (Local0) | |
Stall (0x32) | |
If (LEqual (Local0, Zero)) | |
{ | |
KILL () | |
} | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
Method (COMP, 0, Serialized) | |
{ | |
Store (0x0FA0, Local0) | |
While (Local0) | |
{ | |
If (And (HSTS, 0x02)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
Stall (0x32) | |
If (LEqual (Local0, Zero)) | |
{ | |
KILL () | |
} | |
} | |
} | |
Return (Zero) | |
} | |
Method (KILL, 0, Serialized) | |
{ | |
Or (HCON, 0x02, HCON) /* \_SB_.PCI0.SBUS.HCON */ | |
Or (HSTS, 0xFF, HSTS) /* \_SB_.PCI0.SBUS.HSTS */ | |
} | |
} | |
Device (GFX0) | |
{ | |
Name (_ADR, 0x00020000) // _ADR: Address | |
OperationRegion (VSID, PCI_Config, Zero, 0x04) | |
Field (VSID, ByteAcc, NoLock, Preserve) | |
{ | |
REG0, 32 | |
} | |
Name (PCTG, Package (0x0B) {}) | |
Name (GPSP, Buffer (0x24) {}) | |
Name (NLIM, Zero) | |
Name (RET1, Zero) | |
Name (PSAP, Zero) | |
CreateDWordField (GPSP, Zero, RETN) | |
CreateDWordField (GPSP, 0x04, VRV1) | |
CreateDWordField (GPSP, 0x08, TMGP) | |
CreateDWordField (GPSP, 0x0C, PDTS) | |
CreateDWordField (GPSP, 0x10, SFAN) | |
CreateDWordField (GPSP, 0x14, SKNT) | |
CreateDWordField (GPSP, 0x18, CPUE) | |
CreateDWordField (GPSP, 0x1C, TM01) | |
CreateDWordField (GPSP, 0x20, TM02) | |
Scope (^^PCI0) | |
{ | |
OperationRegion (MCHP, PCI_Config, 0x40, 0xC0) | |
Field (MCHP, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x60), | |
TASM, 10, | |
Offset (0x62) | |
} | |
} | |
OperationRegion (IGDP, PCI_Config, 0x40, 0xC0) | |
Field (IGDP, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x12), | |
, 1, | |
GIVD, 1, | |
, 2, | |
GUMA, 3, | |
Offset (0x14), | |
, 4, | |
GMFN, 1, | |
Offset (0x18), | |
Offset (0xA4), | |
ASLE, 8, | |
Offset (0xA8), | |
GSSE, 1, | |
GSSB, 14, | |
GSES, 1, | |
Offset (0xB0), | |
, 12, | |
CDVL, 1, | |
Offset (0xB2), | |
Offset (0xB5), | |
LBPC, 8, | |
Offset (0xBC), | |
ASLS, 32 | |
} | |
OperationRegion (IGDM, SystemMemory, ASLB, 0x2000) | |
Field (IGDM, AnyAcc, NoLock, Preserve) | |
{ | |
SIGN, 128, | |
SIZE, 32, | |
OVER, 32, | |
SVER, 256, | |
VVER, 128, | |
GVER, 128, | |
MBOX, 32, | |
DMOD, 32, | |
Offset (0x100), | |
DRDY, 32, | |
CSTS, 32, | |
CEVT, 32, | |
Offset (0x120), | |
DIDL, 32, | |
DDL2, 32, | |
DDL3, 32, | |
DDL4, 32, | |
DDL5, 32, | |
DDL6, 32, | |
DDL7, 32, | |
DDL8, 32, | |
CPDL, 32, | |
CPL2, 32, | |
CPL3, 32, | |
CPL4, 32, | |
CPL5, 32, | |
CPL6, 32, | |
CPL7, 32, | |
CPL8, 32, | |
CADL, 32, | |
CAL2, 32, | |
CAL3, 32, | |
CAL4, 32, | |
CAL5, 32, | |
CAL6, 32, | |
CAL7, 32, | |
CAL8, 32, | |
NADL, 32, | |
NDL2, 32, | |
NDL3, 32, | |
NDL4, 32, | |
NDL5, 32, | |
NDL6, 32, | |
NDL7, 32, | |
NDL8, 32, | |
ASLP, 32, | |
TIDX, 32, | |
CHPD, 32, | |
CLID, 32, | |
CDCK, 32, | |
SXSW, 32, | |
EVTS, 32, | |
CNOT, 32, | |
NRDY, 32, | |
Offset (0x200), | |
SCIE, 1, | |
GEFC, 4, | |
GXFC, 3, | |
GESF, 8, | |
Offset (0x204), | |
PARM, 32, | |
DSLP, 32, | |
Offset (0x300), | |
ARDY, 32, | |
ASLC, 32, | |
TCHE, 32, | |
ALSI, 32, | |
BCLP, 32, | |
PFIT, 32, | |
CBLV, 32, | |
BCLM, 320, | |
CPFM, 32, | |
EPFM, 32, | |
PLUT, 592, | |
PFMB, 32, | |
CCDV, 32, | |
PCFT, 32, | |
Offset (0x400), | |
GVD1, 49152, | |
PHED, 32, | |
BDDC, 2048 | |
} | |
Name (DBTB, Package (0x15) | |
{ | |
Zero, | |
0x07, | |
0x38, | |
0x01C0, | |
0x0E00, | |
0x3F, | |
0x01C7, | |
0x0E07, | |
0x01F8, | |
0x0E38, | |
0x0FC0, | |
Zero, | |
Zero, | |
Zero, | |
Zero, | |
Zero, | |
0x7000, | |
0x7007, | |
0x7038, | |
0x71C0, | |
0x7E00 | |
}) | |
Name (CDCT, Package (0x05) | |
{ | |
Package (0x02) | |
{ | |
0xE4, | |
0x0140 | |
}, | |
Package (0x02) | |
{ | |
0xDE, | |
0x014D | |
}, | |
Package (0x02) | |
{ | |
0xDE, | |
0x014D | |
}, | |
Package (0x02) | |
{ | |
Zero, | |
Zero | |
}, | |
Package (0x02) | |
{ | |
0xDE, | |
0x014D | |
} | |
}) | |
Name (SUCC, One) | |
Name (NVLD, 0x02) | |
Name (CRIT, 0x04) | |
Name (NCRT, 0x06) | |
Method (GSCI, 0, Serialized) | |
{ | |
Method (GBDA, 0, Serialized) | |
{ | |
If (LEqual (GESF, Zero)) | |
{ | |
Store (0x0679, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, One)) | |
{ | |
Store (0x0240, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x04)) | |
{ | |
And (PARM, 0xEFFF0000, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
And (PARM, ShiftLeft (DerefOf (Index (DBTB, IBTT)), 0x10), | |
PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (IBTT, PARM, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x05)) | |
{ | |
Store (IPSC, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (IPAT, 0x08), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Add (PARM, 0x0100, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (LIDS, 0x10), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Add (PARM, 0x00010000, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (IBIA, 0x14), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x06)) | |
{ | |
Store (ITVF, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (ITVM, 0x04), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x07)) | |
{ | |
Store (GIVD, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
XOr (PARM, One, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (GMFN, One), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, 0x1800, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (PARM, ShiftLeft (IDMS, 0x11), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Or (ShiftLeft (DerefOf (Index (DerefOf (Index (CDCT, HVCO)), CDVL | |
)), 0x15), PARM, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (One, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x0A)) | |
{ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
If (ISSC) | |
{ | |
Or (PARM, 0x03, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x0B)) | |
{ | |
Store (KSV0, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (KSV1, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (CRIT) /* \_SB_.PCI0.GFX0.CRIT */ | |
} | |
Method (SBCB, 0, Serialized) | |
{ | |
If (LEqual (GESF, Zero)) | |
{ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (0x000F87FD, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, One)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x03)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x04)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x05)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x06)) | |
{ | |
Store (And (PARM, 0x0F), ITVF) /* \ITVF */ | |
Store (ShiftRight (And (PARM, 0xF0), 0x04), ITVM) /* \ITVM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x07)) | |
{ | |
If (LEqual (PARM, Zero)) | |
{ | |
Store (CLID, Local0) | |
If (And (0x80000000, Local0)) | |
{ | |
And (CLID, 0x0F, CLID) /* \_SB_.PCI0.GFX0.CLID */ | |
GLID (CLID) | |
} | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x08)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x09)) | |
{ | |
And (PARM, 0xFF, IBTT) /* \IBTT */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x0A)) | |
{ | |
And (PARM, 0xFF, IPSC) /* \IPSC */ | |
If (And (ShiftRight (PARM, 0x08), 0xFF)) | |
{ | |
And (ShiftRight (PARM, 0x08), 0xFF, IPAT) /* \IPAT */ | |
Decrement (IPAT) | |
} | |
And (ShiftRight (PARM, 0x14), 0x07, IBIA) /* \IBIA */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x0B)) | |
{ | |
And (ShiftRight (PARM, One), One, IF1E) /* \IF1E */ | |
If (And (PARM, 0x0001E000)) | |
{ | |
And (ShiftRight (PARM, 0x0D), 0x0F, IDMS) /* \IDMS */ | |
} | |
Else | |
{ | |
And (ShiftRight (PARM, 0x11), 0x0F, IDMS) /* \IDMS */ | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x10)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x11)) | |
{ | |
Store (ShiftLeft (LIDS, 0x08), PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Add (PARM, 0x0100, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x12)) | |
{ | |
If (And (PARM, One)) | |
{ | |
If (LEqual (ShiftRight (PARM, One), One)) | |
{ | |
Store (One, ISSC) /* \ISSC */ | |
} | |
Else | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (CRIT) /* \_SB_.PCI0.GFX0.CRIT */ | |
} | |
} | |
Else | |
{ | |
Store (Zero, ISSC) /* \ISSC */ | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x13)) | |
{ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GESF, 0x14)) | |
{ | |
And (PARM, 0x0F, PAVP) /* \PAVP */ | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Store (Zero, PARM) /* \_SB_.PCI0.GFX0.PARM */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
Store (Zero, GESF) /* \_SB_.PCI0.GFX0.GESF */ | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If (LEqual (GEFC, 0x04)) | |
{ | |
Store (GBDA (), GXFC) /* \_SB_.PCI0.GFX0.GXFC */ | |
} | |
If (LEqual (GEFC, 0x06)) | |
{ | |
Store (SBCB (), GXFC) /* \_SB_.PCI0.GFX0.GXFC */ | |
} | |
Store (Zero, GEFC) /* \_SB_.PCI0.GFX0.GEFC */ | |
Store (One, SCIS) /* \SCIS */ | |
Store (Zero, GSSE) /* \_SB_.PCI0.GFX0.GSSE */ | |
Store (Zero, SCIE) /* \_SB_.PCI0.GFX0.SCIE */ | |
Return (Zero) | |
} | |
Method (PDRD, 0, NotSerialized) | |
{ | |
If (LNot (DRDY)) | |
{ | |
Sleep (ASLP) | |
} | |
Return (LNot (DRDY)) | |
} | |
Method (PSTS, 0, NotSerialized) | |
{ | |
If (LGreater (CSTS, 0x02)) | |
{ | |
Sleep (ASLP) | |
} | |
Return (LEqual (CSTS, 0x03)) | |
} | |
Method (GNOT, 2, NotSerialized) | |
{ | |
If (PDRD ()) | |
{ | |
Return (One) | |
} | |
Store (Arg0, CEVT) /* \_SB_.PCI0.GFX0.CEVT */ | |
Store (0x03, CSTS) /* \_SB_.PCI0.GFX0.CSTS */ | |
If (LAnd (LEqual (CHPD, Zero), LEqual (Arg1, Zero))) | |
{ | |
If (LOr (LGreater (OSYS, 0x07D0), LLess (OSYS, 0x07D6))) | |
{ | |
Notify (PCI0, Arg1) | |
} | |
Else | |
{ | |
Notify (GFX0, Arg1) | |
} | |
} | |
If (CondRefOf (HNOT)) | |
{ | |
HNOT (Arg0) | |
} | |
Else | |
{ | |
Notify (GFX0, 0x80) // Status Change | |
} | |
Return (Zero) | |
} | |
Method (GHDS, 1, NotSerialized) | |
{ | |
Store (Arg0, TIDX) /* \_SB_.PCI0.GFX0.TIDX */ | |
Return (GNOT (One, Zero)) | |
} | |
Method (GLID, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
Store (0x03, CLID) /* \_SB_.PCI0.GFX0.CLID */ | |
} | |
Else | |
{ | |
Store (Arg0, CLID) /* \_SB_.PCI0.GFX0.CLID */ | |
} | |
Return (GNOT (0x02, Zero)) | |
} | |
Method (GDCK, 1, NotSerialized) | |
{ | |
Store (Arg0, CDCK) /* \_SB_.PCI0.GFX0.CDCK */ | |
Return (GNOT (0x04, Zero)) | |
} | |
Method (PARD, 0, NotSerialized) | |
{ | |
If (LNot (ARDY)) | |
{ | |
Sleep (ASLP) | |
} | |
Return (LNot (ARDY)) | |
} | |
Method (AINT, 2, NotSerialized) | |
{ | |
If (LNot (And (TCHE, ShiftLeft (One, Arg0)))) | |
{ | |
Return (One) | |
} | |
If (PARD ()) | |
{ | |
Return (One) | |
} | |
If (LEqual (Arg0, 0x02)) | |
{ | |
If (CPFM) | |
{ | |
And (CPFM, 0x0F, Local0) | |
And (EPFM, 0x0F, Local1) | |
If (LEqual (Local0, One)) | |
{ | |
If (And (Local1, 0x06)) | |
{ | |
Store (0x06, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
If (And (Local1, 0x08)) | |
{ | |
Store (0x08, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
Store (One, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
} | |
} | |
If (LEqual (Local0, 0x06)) | |
{ | |
If (And (Local1, 0x08)) | |
{ | |
Store (0x08, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
If (And (Local1, One)) | |
{ | |
Store (One, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
Store (0x06, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
} | |
} | |
If (LEqual (Local0, 0x08)) | |
{ | |
If (And (Local1, One)) | |
{ | |
Store (One, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
If (And (Local1, 0x06)) | |
{ | |
Store (0x06, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Else | |
{ | |
Store (0x08, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
} | |
} | |
} | |
Else | |
{ | |
XOr (PFIT, 0x07, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
} | |
Or (PFIT, 0x80000000, PFIT) /* \_SB_.PCI0.GFX0.PFIT */ | |
Store (0x04, ASLC) /* \_SB_.PCI0.GFX0.ASLC */ | |
} | |
Else | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
Store (Divide (Multiply (Arg1, 0xFF), 0x64, ), BCLP) /* \_SB_.PCI0.GFX0.BCLP */ | |
Or (BCLP, 0x80000000, BCLP) /* \_SB_.PCI0.GFX0.BCLP */ | |
Store (0x02, ASLC) /* \_SB_.PCI0.GFX0.ASLC */ | |
} | |
Else | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (Arg1, ALSI) /* \_SB_.PCI0.GFX0.ALSI */ | |
Store (One, ASLC) /* \_SB_.PCI0.GFX0.ASLC */ | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
} | |
Store (One, ASLE) /* \_SB_.PCI0.GFX0.ASLE */ | |
Return (Zero) | |
} | |
Method (SCIP, 0, NotSerialized) | |
{ | |
If (LNotEqual (OVER, Zero)) | |
{ | |
Return (LNot (GSMI)) | |
} | |
Return (Zero) | |
} | |
Name (OPBS, 0xFFFFFF00) | |
Method (OPTS, 1, NotSerialized) | |
{ | |
If (And (VGAF, One)) | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Store (ASLS, OPBS) /* \_SB_.PCI0.GFX0.OPBS */ | |
} | |
} | |
} | |
Method (OWAK, 1, NotSerialized) | |
{ | |
If (And (VGAF, One)) | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Store (OPBS, ASLS) /* \_SB_.PCI0.GFX0.ASLS */ | |
Store (One, GSES) /* \_SB_.PCI0.GFX0.GSES */ | |
} | |
Store (One, CLID) /* \_SB_.PCI0.GFX0.CLID */ | |
} | |
} | |
Method (OGCD, 0, NotSerialized) | |
{ | |
If (LEqual (CADL, Zero)) | |
{ | |
Store (LCDM, CSTE) /* \_SB_.CSTE */ | |
Return (Zero) | |
} | |
Store (OA2D (CADL), CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL2, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL2), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL3, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL3), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL4, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL4), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL5, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL5), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL6, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL6), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL7, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL7), CSTE, CSTE) /* \_SB_.CSTE */ | |
If (LEqual (CAL8, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CAL8), CSTE, CSTE) /* \_SB_.CSTE */ | |
Return (Zero) | |
} | |
Method (OGND, 0, NotSerialized) | |
{ | |
If (LEqual (NADL, Zero)) | |
{ | |
Store (LCDM, NSTE) /* \_SB_.NSTE */ | |
Return (Zero) | |
} | |
Store (OA2D (NADL), NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL2, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL2), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL3, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL3), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL4, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL4), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL5, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL5), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL6, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL6), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL7, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL7), NSTE, NSTE) /* \_SB_.NSTE */ | |
If (LEqual (NDL8, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (NDL8), NSTE, NSTE) /* \_SB_.NSTE */ | |
Return (Zero) | |
} | |
Method (OGCA, 0, NotSerialized) | |
{ | |
SOID () | |
If (LEqual (CPDL, Zero)) | |
{ | |
Store (LCDM, OCAD) /* \_SB_.OCAD */ | |
Return (Zero) | |
} | |
Store (OA2D (CPDL), OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL2, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL2), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL3, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL3), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL4, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL4), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL5, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL5), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL6, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL6), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL7, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL7), OCAD, OCAD) /* \_SB_.OCAD */ | |
If (LEqual (CPL8, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (OA2D (CPL8), OCAD, OCAD) /* \_SB_.OCAD */ | |
Return (Zero) | |
} | |
Method (OA2D, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (LEqual (Arg0, LFID)) | |
{ | |
Or (Local0, LCDM, Local0) | |
} | |
If (LEqual (Arg0, CRID)) | |
{ | |
Or (Local0, CRTM, Local0) | |
} | |
If (LEqual (Arg0, TVID)) | |
{ | |
Or (Local0, TVOM, Local0) | |
} | |
If (LEqual (Arg0, HDID)) | |
{ | |
Or (Local0, HDMM, Local0) | |
} | |
If (LEqual (Arg0, DVID)) | |
{ | |
Or (Local0, DVIM, Local0) | |
} | |
If (LEqual (Arg0, DPID)) | |
{ | |
Or (Local0, DPOM, Local0) | |
} | |
Return (Local0) | |
} | |
Method (D2OA, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (And (Arg0, LCDM)) | |
{ | |
Return (LFID) /* \_SB_.PCI0.GFX0.LFID */ | |
} | |
If (And (Arg0, CRTM)) | |
{ | |
Return (CRID) /* \_SB_.PCI0.GFX0.CRID */ | |
} | |
If (And (Arg0, TVOM)) | |
{ | |
Return (TVID) /* \_SB_.PCI0.GFX0.TVID */ | |
} | |
If (And (Arg0, HDMM)) | |
{ | |
Return (HDID) /* \_SB_.PCI0.GFX0.HDID */ | |
} | |
If (And (Arg0, DVIM)) | |
{ | |
Return (DVID) /* \_SB_.PCI0.GFX0.DVID */ | |
} | |
If (And (Arg0, DPOM)) | |
{ | |
Return (DPID) /* \_SB_.PCI0.GFX0.DPID */ | |
} | |
Return (Local0) | |
} | |
Name (DDID, Zero) | |
Method (WNDD, 1, NotSerialized) | |
{ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NADL) /* \_SB_.PCI0.GFX0.NADL */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL2) /* \_SB_.PCI0.GFX0.NDL2 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL3) /* \_SB_.PCI0.GFX0.NDL3 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL4) /* \_SB_.PCI0.GFX0.NDL4 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL5) /* \_SB_.PCI0.GFX0.NDL5 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL6) /* \_SB_.PCI0.GFX0.NDL6 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL7) /* \_SB_.PCI0.GFX0.NDL7 */ | |
Store (GDOA (Arg0), DDID) /* \_SB_.PCI0.GFX0.DDID */ | |
Store (DDID, NDL8) /* \_SB_.PCI0.GFX0.NDL8 */ | |
Store (Zero, CONT) /* \_SB_.PCI0.GFX0.CONT */ | |
} | |
Name (CONT, Zero) | |
Method (GDOA, 1, NotSerialized) | |
{ | |
While (LLess (CONT, 0x08)) | |
{ | |
Store (One, Local0) | |
ShiftLeft (Local0, CONT, Local0) | |
And (NSTE, Local0, Local1) | |
Increment (CONT) | |
Store (D2OA (Local1), Local1) | |
If (LNotEqual (Local1, Zero)) | |
{ | |
Return (Local1) | |
} | |
} | |
Return (Zero) | |
} | |
Name (LFID, 0xFFFFFFFF) | |
Name (CRID, 0xFFFFFFFF) | |
Name (TVID, 0xFFFFFFFF) | |
Name (DPID, 0xFFFFFFFF) | |
Name (HDID, 0xFFFFFFFF) | |
Name (DVID, 0xFFFFFFFF) | |
Method (GOID, 1, NotSerialized) | |
{ | |
And (Arg0, 0x0F00, Local0) | |
If (LEqual (Local0, 0x0100)) | |
{ | |
Store (Arg0, CRID) /* \_SB_.PCI0.GFX0.CRID */ | |
} | |
If (LEqual (Local0, 0x0200)) | |
{ | |
Store (Arg0, TVID) /* \_SB_.PCI0.GFX0.TVID */ | |
} | |
If (LEqual (Local0, 0x0400)) | |
{ | |
Store (Arg0, LFID) /* \_SB_.PCI0.GFX0.LFID */ | |
} | |
If (LEqual (Arg0, 0x0300)) | |
{ | |
Store (Arg0, HDID) /* \_SB_.PCI0.GFX0.HDID */ | |
} | |
} | |
Method (SOID, 0, NotSerialized) | |
{ | |
GOID (CPDL) | |
GOID (CPL2) | |
GOID (CPL3) | |
GOID (CPL4) | |
GOID (CPL5) | |
GOID (CPL6) | |
GOID (CPL7) | |
GOID (CPL8) | |
} | |
Method (PRST, 0, NotSerialized) | |
{ | |
If (LEqual (REG0, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
Name (LCDM, 0x0808) | |
Name (CRTM, 0x0101) | |
Name (TVOM, 0x0202) | |
Name (HDMM, 0x0404) | |
Name (DVIM, 0x4040) | |
Name (DPOM, 0x8080) | |
Name (DOSF, One) | |
Name (BRNC, Zero) | |
Name (UPDN, One) | |
Name (NXTD, One) | |
Method (D2AF, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (And (Arg0, LCDM)) | |
{ | |
Or (Local0, One, Local0) | |
} | |
If (And (Arg0, CRTM)) | |
{ | |
Or (Local0, 0x02, Local0) | |
} | |
If (And (Arg0, TVOM)) | |
{ | |
Or (Local0, 0x04, Local0) | |
} | |
If (And (Arg0, DVIM)) | |
{ | |
Or (Local0, 0x08, Local0) | |
} | |
If (And (Arg0, HDMM)) | |
{ | |
Or (Local0, 0x10, Local0) | |
} | |
If (And (Arg0, DPOM)) | |
{ | |
Or (Local0, 0x20, Local0) | |
} | |
If (LNot (Local0)) | |
{ | |
Return (NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Return (Local0) | |
} | |
Method (AF2D, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (And (Arg0, One)) | |
{ | |
Or (Local0, LCDM, Local0) | |
} | |
If (And (Arg0, 0x02)) | |
{ | |
Or (Local0, CRTM, Local0) | |
} | |
If (And (Arg0, 0x04)) | |
{ | |
Or (Local0, TVOM, Local0) | |
} | |
If (And (Arg0, 0x08)) | |
{ | |
Or (Local0, DVIM, Local0) | |
} | |
If (And (Arg0, 0x10)) | |
{ | |
Or (Local0, HDMM, Local0) | |
} | |
If (And (Arg0, 0x20)) | |
{ | |
Or (Local0, DPOM, Local0) | |
} | |
If (LNot (Local0)) | |
{ | |
Return (LCDM) /* \_SB_.PCI0.GFX0.LCDM */ | |
} | |
Return (Local0) | |
} | |
Method (_INI, 0, NotSerialized) // _INI: Initialize | |
{ | |
If (And (SGEN, One)) | |
{ | |
HINI () | |
} | |
} | |
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
{ | |
If (DRDY) | |
{ | |
And (Arg0, 0x03, DOSF) /* \_SB_.PCI0.GFX0.DOSF */ | |
Store (ShiftRight (Arg0, 0x02), BRNC) /* \_SB_.PCI0.GFX0.BRNC */ | |
And (BRNC, One, BRNC) /* \_SB_.PCI0.GFX0.BRNC */ | |
} | |
} | |
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
{ | |
Store (Zero, NDID) /* \NDID */ | |
If (LNotEqual (DIDL, Zero)) | |
{ | |
Store (SDDL (DIDL), DID1) /* \DID1 */ | |
} | |
If (LNotEqual (DDL2, Zero)) | |
{ | |
Store (SDDL (DDL2), DID2) /* \DID2 */ | |
} | |
If (LNotEqual (DDL3, Zero)) | |
{ | |
Store (SDDL (DDL3), DID3) /* \DID3 */ | |
} | |
If (LNotEqual (DDL4, Zero)) | |
{ | |
Store (SDDL (DDL4), DID4) /* \DID4 */ | |
} | |
If (LNotEqual (DDL5, Zero)) | |
{ | |
Store (SDDL (DDL5), DID5) /* \DID5 */ | |
} | |
If (LEqual (NDID, One)) | |
{ | |
Name (TMP1, Package (0x01) | |
{ | |
0xFFFFFFFF | |
}) | |
Store (Or (0x00010000, DID1), Index (TMP1, Zero)) | |
Return (TMP1) /* \_SB_.PCI0.GFX0._DOD.TMP1 */ | |
} | |
If (LEqual (NDID, 0x02)) | |
{ | |
Name (TMP2, Package (0x02) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Store (Or (0x00010000, DID1), Index (TMP2, Zero)) | |
Store (Or (0x00010000, DID2), Index (TMP2, One)) | |
Return (TMP2) /* \_SB_.PCI0.GFX0._DOD.TMP2 */ | |
} | |
If (LEqual (NDID, 0x03)) | |
{ | |
Name (TMP3, Package (0x03) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Store (Or (0x00010000, DID1), Index (TMP3, Zero)) | |
Store (Or (0x00010000, DID2), Index (TMP3, One)) | |
Store (Or (0x00010000, DID3), Index (TMP3, 0x02)) | |
Return (TMP3) /* \_SB_.PCI0.GFX0._DOD.TMP3 */ | |
} | |
If (LEqual (NDID, 0x04)) | |
{ | |
Name (TMP4, Package (0x04) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Store (Or (0x00010000, DID1), Index (TMP4, Zero)) | |
Store (Or (0x00010000, DID2), Index (TMP4, One)) | |
Store (Or (0x00010000, DID3), Index (TMP4, 0x02)) | |
Store (Or (0x00010000, DID4), Index (TMP4, 0x03)) | |
Return (TMP4) /* \_SB_.PCI0.GFX0._DOD.TMP4 */ | |
} | |
If (LGreater (NDID, 0x04)) | |
{ | |
Name (TMP5, Package (0x05) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Store (Or (0x00010000, DID1), Index (TMP5, Zero)) | |
Store (Or (0x00010000, DID2), Index (TMP5, One)) | |
Store (Or (0x00010000, DID3), Index (TMP5, 0x02)) | |
Store (Or (0x00010000, DID4), Index (TMP5, 0x03)) | |
Store (Or (0x00010000, DID5), Index (TMP5, 0x04)) | |
Return (TMP5) /* \_SB_.PCI0.GFX0._DOD.TMP5 */ | |
} | |
Return (Package (0x01) | |
{ | |
0x0400 | |
}) | |
} | |
Device (DD01) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID1, Zero)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID1)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
Return (CDDS (DID1)) | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID1)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (LCDD) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID2, Zero)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID2)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
Return (CDDS (DID2)) | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID2)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
Method (MINB, 0, NotSerialized) | |
{ | |
If (ARDY) | |
{ | |
Store (BRTI, Local1) | |
ShiftLeft (Local1, 0x04, Local1) | |
Store (DerefOf (Index (^^^LPCB.EC0.PWAC, Local1)), Local0) | |
Or (TCHE, 0x08, TCHE) /* \_SB_.PCI0.GFX0.TCHE */ | |
Or (ASLC, 0x08, ASLC) /* \_SB_.PCI0.GFX0.ASLC */ | |
Store (Local0, PFMB) /* \_SB_.PCI0.GFX0.PFMB */ | |
Or (PFMB, 0x0100, PFMB) /* \_SB_.PCI0.GFX0.PFMB */ | |
Store (One, ASLE) /* \_SB_.PCI0.GFX0.ASLE */ | |
} | |
} | |
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
Add (0x64, One, Local0) | |
Add (Local0, 0x02, Local0) | |
Name (BRPP, Package (0x67) {}) | |
Store (0x64, Index (BRPP, Zero)) | |
Store (0x28, Index (BRPP, One)) | |
Store (0x02, Local1) | |
Store (0x64, Local2) | |
While (LLess (Local1, Local0)) | |
{ | |
Store (Local2, Index (BRPP, Local1)) | |
Increment (Local1) | |
Decrement (Local2) | |
} | |
Store (Zero, Local0) | |
While (LLessEqual (Local0, 0x0A)) | |
{ | |
Store (Multiply (Local0, 0x0A), Index (PCTG, Subtract (0x0A, Local0 | |
))) | |
Increment (Local0) | |
} | |
MINB () | |
Return (BRPP) /* \_SB_.PCI0.GFX0.LCDD._BCL.BRPP */ | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
Store (BRTI, Local4) | |
ShiftLeft (Local4, 0x04, Local4) | |
While (LLess (Local0, 0x0B)) | |
{ | |
Subtract (0x0B, Local0, Local3) | |
Subtract (Local3, One, Local3) | |
Store (Add (Local4, Local3), Local3) | |
Store (DerefOf (Index (^^^LPCB.EC0.PWAC, Local3)), Local1) | |
Store (Divide (Multiply (Local1, 0x64), 0xFF, ), Local2) | |
Store (Local2, Index (PCTG, Local0)) | |
Increment (Local0) | |
} | |
MINB () | |
Return (PCTG) /* \_SB_.PCI0.GFX0.PCTG */ | |
} | |
} | |
Name (BCBH, Zero) | |
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method | |
{ | |
Store (One, BCMD) /* \_SB_.PCI0.GFX0.BCMD */ | |
Store (GCBL (Arg0), Local0) | |
Subtract (0x0A, Local0, LBTN) /* \_SB_.LBTN */ | |
If (BRNC) | |
{ | |
AINT (One, Arg0) | |
} | |
Else | |
{ | |
^^^LPCB.EC0.STBR () | |
} | |
} | |
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
And (CBLV, 0x7FFFFFFF, Local0) | |
Return (Local0) | |
} | |
Else | |
{ | |
Store (BRTI, Local1) | |
ShiftLeft (Local1, 0x04, Local1) | |
Store (LBTN, Local2) | |
Store (Add (Local1, Local2), Local2) | |
Store (Multiply (DerefOf (Index (^^^LPCB.EC0.PWAC, Local2)), 0x64), Local3) | |
Store (Divide (Local3, 0xFF, ), Local3) | |
Return (Local3) | |
} | |
} | |
} | |
Device (DD03) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID3, Zero)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID3)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID3, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID3)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID3)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (DD04) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID4, Zero)) | |
{ | |
Return (0x04) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID4)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID4, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID4)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID4)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (DD05) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID5, Zero)) | |
{ | |
Return (0x05) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID5)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID5, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID5)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID5)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (DD06) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID6, Zero)) | |
{ | |
Return (0x06) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID6)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID6, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID6)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID6)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (DD07) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID7, Zero)) | |
{ | |
Return (0x07) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID7)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID7, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID7)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID7)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Device (DD08) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (LEqual (DID8, Zero)) | |
{ | |
Return (0x08) | |
} | |
Else | |
{ | |
Return (And (0xFFFF, DID8)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If (LEqual (DID8, Zero)) | |
{ | |
Return (0x0B) | |
} | |
Else | |
{ | |
Return (CDDS (DID8)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DID8)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (LEqual (And (Arg0, 0xC0000000), 0xC0000000)) | |
{ | |
Store (NSTE, CSTE) /* \_SB_.CSTE */ | |
} | |
} | |
} | |
Method (SDDL, 1, NotSerialized) | |
{ | |
Increment (NDID) | |
Store (And (Arg0, 0x0F0F), Local0) | |
Or (0x80000000, Local0, Local1) | |
If (LEqual (DIDL, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL2, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL3, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL4, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL5, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL6, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL7, Local0)) | |
{ | |
Return (Local1) | |
} | |
If (LEqual (DDL8, Local0)) | |
{ | |
Return (Local1) | |
} | |
Return (Zero) | |
} | |
Method (CDDS, 1, NotSerialized) | |
{ | |
Store (And (Arg0, 0x0F0F), Local0) | |
If (LEqual (Zero, Local0)) | |
{ | |
Return (0x1D) | |
} | |
If (LEqual (CADL, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL2, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL3, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL4, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL5, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL6, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL7, Local0)) | |
{ | |
Return (0x1F) | |
} | |
If (LEqual (CAL8, Local0)) | |
{ | |
Return (0x1F) | |
} | |
Return (0x1D) | |
} | |
Method (NDDS, 1, NotSerialized) | |
{ | |
Store (And (Arg0, 0x0F0F), Local0) | |
If (LEqual (Zero, Local0)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (NADL, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL2, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL3, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL4, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL5, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL6, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL7, Local0)) | |
{ | |
Return (One) | |
} | |
If (LEqual (NDL8, Local0)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SWHD, 1, Serialized) | |
{ | |
Store (One, UPDN) /* \_SB_.PCI0.GFX0.UPDN */ | |
If (LEqual (DOSF, One)) | |
{ | |
If (\NATK ()) | |
{ | |
Store (Zero, SFUN) /* \_SB_.SFUN */ | |
} | |
Else | |
{ | |
Store (0x04, SFUN) /* \_SB_.SFUN */ | |
} | |
Store (Arg0, SSTE) /* \_SB_.SSTE */ | |
If (\NATK ()) | |
{ | |
Store (AF2D (Arg0), NSTE) /* \_SB_.NSTE */ | |
Store (NSTE, SSTE) /* \_SB_.SSTE */ | |
} | |
ISMI (0x94) | |
Notify (GFX0, 0x81) // Information Change | |
} | |
Else | |
{ | |
Store (One, CEVT) /* \_SB_.PCI0.GFX0.CEVT */ | |
Store (0x03, CSTS) /* \_SB_.PCI0.GFX0.CSTS */ | |
If (LNotEqual (OCAD, OPAD)) | |
{ | |
Store (OCAD, OPAD) /* \_SB_.OPAD */ | |
If (LEqual (OSFG, OSXP)) | |
{ | |
Notify (PCI0, Zero) // Bus Check | |
} | |
Else | |
{ | |
Notify (GFX0, Zero) // Bus Check | |
} | |
Sleep (0x03E8) | |
} | |
Store (AF2D (Arg0), NSTE) /* \_SB_.NSTE */ | |
WNDD (NSTE) | |
Notify (GFX0, 0x80) // Status Change | |
} | |
Return (Zero) | |
} | |
Method (GCDD, 0, NotSerialized) | |
{ | |
OGCD () | |
Return (CSTE) /* \_SB_.CSTE */ | |
} | |
Method (GNDD, 0, NotSerialized) | |
{ | |
OGND () | |
Return (NSTE) /* \_SB_.NSTE */ | |
} | |
Method (GCAD, 0, NotSerialized) | |
{ | |
OGCA () | |
Return (OCAD) /* \_SB_.OCAD */ | |
} | |
Method (GVIF, 0, NotSerialized) | |
{ | |
Store (0x67, VBIF) /* \_SB_.VBIF */ | |
Store (Zero, SFUN) /* \_SB_.SFUN */ | |
ISMI (0x95) | |
Return (VBIF) /* \_SB_.VBIF */ | |
} | |
Method (GNAD, 0, NotSerialized) | |
{ | |
Increment (NXTD) | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x03))) | |
{ | |
Increment (NXTD) | |
} | |
If (And (DOSF, 0x03)) | |
{ | |
If (LEqual (NXTD, 0x05)) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x06)) | |
{ | |
Increment (NXTD) | |
} | |
} | |
If (LEqual (NXTD, 0x07)) | |
{ | |
Increment (NXTD) | |
} | |
If (And (DOSF, 0x03)) | |
{ | |
If (LEqual (NXTD, 0x09)) | |
{ | |
Increment (NXTD) | |
} | |
} | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x0A))) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x0B)) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x0C))) | |
{ | |
Increment (NXTD) | |
} | |
While (LAnd (LGreater (NXTD, 0x0C), LLess (NXTD, 0x10))) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (DOSF, One)) | |
{ | |
If (LEqual (NXTD, 0x11)) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x12)) | |
{ | |
Increment (NXTD) | |
} | |
} | |
If (LEqual (NXTD, 0x13)) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (DOSF, One)) | |
{ | |
While (LAnd (LGreaterEqual (NXTD, 0x14), LLess (NXTD, 0x20))) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x21)) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x22)) | |
{ | |
Increment (NXTD) | |
} | |
} | |
If (LEqual (NXTD, 0x23)) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x24))) | |
{ | |
Increment (NXTD) | |
} | |
While (LAnd (LGreater (NXTD, 0x24), LLess (NXTD, 0x28))) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x28))) | |
{ | |
Increment (NXTD) | |
} | |
While (LAnd (LGreater (NXTD, 0x28), LLess (NXTD, 0x30))) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LEqual (DOSF, One), LEqual (NXTD, 0x30))) | |
{ | |
Increment (NXTD) | |
} | |
If (LGreater (NXTD, 0x30)) | |
{ | |
Store (One, NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Return (Zero) | |
} | |
Method (ADVD, 0, NotSerialized) | |
{ | |
If (And (DOSF, 0x03)) | |
{ | |
GCDD () | |
GCAD () | |
GVIF () | |
} | |
Else | |
{ | |
OGCA () | |
OGCD () | |
} | |
If (\NATK ()) | |
{ | |
If (UPDN) | |
{ | |
Store (D2AF (CSTE), NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
Store (Zero, UPDN) /* \_SB_.PCI0.GFX0.UPDN */ | |
} | |
Store (Zero, Local0) | |
Store (D2AF (OCAD), Local1) | |
Store (Zero, Local2) | |
If (And (VGAF, One)) | |
{ | |
And (VBIF, 0x08, Local2) | |
} | |
If (And (LEqual (Local2, 0x08), And (VGAF, One))) | |
{ | |
And (NXTD, Local1, NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
Store (NXTD, Local0) | |
} | |
While (LNotEqual (NXTD, Local0)) | |
{ | |
GNAD () | |
And (NXTD, Local1, Local0) | |
} | |
Return (NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Return (GNDD ()) | |
} | |
Method (GCDS, 0, NotSerialized) | |
{ | |
If (And (DOSF, 0x03)) | |
{ | |
GCDD () | |
GCAD () | |
GVIF () | |
} | |
Else | |
{ | |
OGCA () | |
OGCD () | |
} | |
Return (D2AF (CSTE)) | |
} | |
Method (NATK, 0, NotSerialized) | |
{ | |
Return (One) | |
} | |
Name (BCMD, Zero) | |
Method (UPBL, 0, NotSerialized) | |
{ | |
If (BRNC) | |
{ | |
GCDD () | |
Store (And (D2AF (CSTE), One), Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (Zero) | |
} | |
Store (CBLV, Local0) | |
Store (Zero, BCMD) /* \_SB_.PCI0.GFX0.BCMD */ | |
Notify (LCDD, 0x86) // Device-Specific | |
Store (0x012C, Local2) | |
And (Local0, 0x7FFFFFFF, Local1) | |
If (LGreaterEqual (Local1, DerefOf (Index (PCTG, One)))) | |
{ | |
Store (Zero, Local2) | |
Store (One, Local1) | |
} | |
If (LLess (MSOS (), OSW8)) | |
{ | |
While (LAnd (LNot (BCMD), Local2)) | |
{ | |
Store (CBLV, Local1) | |
If (LNot (And (Local1, 0x80000000))) | |
{ | |
Store (Local0, Local1) | |
} | |
If (LEqual (Local0, Local1)) | |
{ | |
Sleep (0x0A) | |
Decrement (Local2) | |
Store (Zero, Local1) | |
} | |
Else | |
{ | |
Store (Zero, Local2) | |
Store (One, Local1) | |
} | |
} | |
} | |
If (LAnd (LNot (BCMD), Local1)) | |
{ | |
If (LLess (MSOS (), OSW8)) | |
{ | |
Store (GCBL (CBLV), Local3) | |
Subtract (0x0A, Local3, Local3) | |
Store (Local3, LBTN) /* \_SB_.LBTN */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LLess (LBTN, 0x0F)) | |
{ | |
Increment (LBTN) | |
} | |
Else | |
{ | |
Store (0x0F, LBTN) /* \_SB_.LBTN */ | |
} | |
^^LPCB.EC0.STBR () | |
} | |
Return (Zero) | |
} | |
Method (DWBL, 0, NotSerialized) | |
{ | |
If (BRNC) | |
{ | |
GCDD () | |
Store (And (D2AF (CSTE), One), Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (Zero) | |
} | |
Store (CBLV, Local0) | |
Store (Zero, BCMD) /* \_SB_.PCI0.GFX0.BCMD */ | |
Notify (LCDD, 0x87) // Device-Specific | |
Store (0x012C, Local2) | |
And (Local0, 0x7FFFFFFF, Local1) | |
If (LLessEqual (Local1, DerefOf (Index (PCTG, 0x0A)))) | |
{ | |
Store (Zero, Local2) | |
Store (One, Local1) | |
} | |
If (LLess (MSOS (), OSW8)) | |
{ | |
While (LAnd (LNot (BCMD), Local2)) | |
{ | |
Store (CBLV, Local1) | |
If (LNot (And (Local1, 0x80000000))) | |
{ | |
Store (Local0, Local1) | |
} | |
If (LEqual (Local0, Local1)) | |
{ | |
Sleep (0x0A) | |
Decrement (Local2) | |
Store (Zero, Local1) | |
} | |
Else | |
{ | |
Store (Zero, Local2) | |
Store (One, Local1) | |
} | |
} | |
} | |
If (LAnd (LNot (BCMD), Local1)) | |
{ | |
If (LLess (MSOS (), OSW8)) | |
{ | |
Store (GCBL (CBLV), Local3) | |
Subtract (0x0A, Local3, Local3) | |
Store (Local3, LBTN) /* \_SB_.LBTN */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LGreater (LBTN, Zero)) | |
{ | |
Decrement (LBTN) | |
} | |
If (LGreater (LBTN, 0x0F)) | |
{ | |
Store (0x0F, LBTN) /* \_SB_.LBTN */ | |
} | |
^^LPCB.EC0.STBR () | |
} | |
Return (Zero) | |
} | |
Method (GCBL, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
And (Arg0, 0x7FFFFFFF, Arg0) | |
While (LLess (Local0, 0x0A)) | |
{ | |
Store (DerefOf (Index (PCTG, Local0)), Local1) | |
Store (DerefOf (Index (PCTG, Add (Local0, One))), Local2) | |
If (LAnd (LLessEqual (Arg0, Local1), LGreater (Arg0, Local2))) | |
{ | |
Break | |
} | |
Increment (Local0) | |
} | |
Return (Local0) | |
} | |
Name (HGCK, Zero) | |
Name (HPWR, Zero) | |
Name (HPOK, Zero) | |
Name (HGDP, Zero) | |
Name (NTSA, Zero) | |
Name (HGAP, Zero) | |
Name (HPLG, Zero) | |
Name (HPEJ, Zero) | |
Name (HPLE, Zero) | |
Name (HLMX, Zero) | |
Name (HLMM, Zero) | |
Name (HCMX, Zero) | |
Name (HCMM, Zero) | |
Name (HDMX, Zero) | |
Name (HDMU, Zero) | |
Name (HHMX, Zero) | |
Name (HHMM, Zero) | |
Name (HPMX, Zero) | |
Name (HPMM, Zero) | |
Name (HVGF, Zero) | |
Name (BOTF, Zero) | |
Name (DONE, Zero) | |
Name (CMO1, Zero) | |
Name (TLST, One) | |
Name (DSM2, Zero) | |
Name (DSM5, Zero) | |
Name (QATH, Zero) | |
Name (HGDD, One) | |
Name (HHKM, One) | |
Name (BLCD, 0x0101) | |
Name (BCRT, 0x0202) | |
Name (BTVO, 0x0808) | |
Name (BHDM, 0x0404) | |
Name (BDVI, 0x4040) | |
Name (BDPO, 0x8080) | |
Name (RST1, Buffer (0xF8) | |
{ | |
0x00 /* . */ | |
}) | |
Method (HINI, 0, NotSerialized) | |
{ | |
If (LOr (LEqual (MSOS (), OSEG), LEqual (MSOS (), OSXP))) | |
{ | |
SGPL (0x32, One, Zero) | |
Sleep (0x0A) | |
SGPL (0x36, One, One) | |
} | |
Store (One, HPWR) /* \_SB_.PCI0.GFX0.HPWR */ | |
Store (One, HPOK) /* \_SB_.PCI0.GFX0.HPOK */ | |
Store (Zero, HGDP) /* \_SB_.PCI0.GFX0.HGDP */ | |
Store (Zero, HGAP) /* \_SB_.PCI0.GFX0.HGAP */ | |
Store (Zero, HPLG) /* \_SB_.PCI0.GFX0.HPLG */ | |
Store (Zero, HPEJ) /* \_SB_.PCI0.GFX0.HPEJ */ | |
Store (One, HPLE) /* \_SB_.PCI0.GFX0.HPLE */ | |
Store (Zero, HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
Store (Zero, HLMM) /* \_SB_.PCI0.GFX0.HLMM */ | |
Store (Zero, HCMX) /* \_SB_.PCI0.GFX0.HCMX */ | |
Store (Zero, HCMM) /* \_SB_.PCI0.GFX0.HCMM */ | |
Store (Zero, HDMX) /* \_SB_.PCI0.GFX0.HDMX */ | |
Store (Zero, HDMU) /* \_SB_.PCI0.GFX0.HDMU */ | |
Store (Zero, HHMX) /* \_SB_.PCI0.GFX0.HHMX */ | |
Store (Zero, HHMM) /* \_SB_.PCI0.GFX0.HHMM */ | |
SAVO () | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
Name (_T_2, Zero) // _T_x: Emitted by ASL Compiler | |
Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (LEqual (Arg0, ToUUID ("9d95a0a0-0060-4d48-b34d-7e5fea129fd4"))) | |
{ | |
Store (Zero, Local0) | |
Store (ShiftLeft (DerefOf (Index (Arg3, 0x03)), 0x18), Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, 0x02)), 0x10), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, One)), 0x08), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, Zero)), Zero), Local0, | |
Local0) | |
While (One) | |
{ | |
Store (ToInteger (Arg2), _T_0) /* \_SB_.PCI0.GFX0._DSM._T_0 */ | |
If (LEqual (_T_0, Zero)) | |
{ | |
Return (Unicode ("?")) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x01, 0x30, 0x00, 0x07 /* .0.. */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
If (And (Local0, 0x10)) | |
{ | |
And (Local0, 0x0F, Local1) | |
EVD9 () | |
Store (Local1, HGAP) /* \_SB_.PCI0.GFX0.HGAP */ | |
} | |
Or (DSM2, 0x10, DSM2) /* \_SB_.PCI0.GFX0.DSM2 */ | |
Return (DSM2) /* \_SB_.PCI0.GFX0.DSM2 */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03)) | |
{ | |
And (Local0, 0x03, Local0) | |
If (LEqual (Local0, One)) | |
{ | |
^^PEG0.PEGP.DON () | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (Local0, 0x02)) | |
{ | |
^^PEG0.PEGP.DOFF () | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (^^PEG0.PEGP.DSTA ()) | |
} | |
} | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x04)) | |
{ | |
Name (NFBU, Buffer (0x04) | |
{ | |
0x00, 0x90, 0x10, 0x04 /* .... */ | |
}) | |
Name (HBDP, Zero) | |
CreateField (NFBU, Zero, 0x0C, BDRF) | |
CreateField (NFBU, 0x0C, One, BDOF) | |
CreateField (NFBU, 0x0D, 0x02, PSRF) | |
CreateField (NFBU, 0x0F, One, PSOF) | |
CreateField (NFBU, 0x10, 0x04, PTVF) | |
CreateField (NFBU, 0x14, One, PTVO) | |
CreateField (NFBU, 0x15, 0x05, TVFF) | |
CreateField (NFBU, 0x1A, One, TVOF) | |
While (One) | |
{ | |
Store (ToInteger (HBDP), _T_1) /* \_SB_.PCI0.GFX0._DSM._T_1 */ | |
If (LEqual (_T_1, 0x07)) | |
{ | |
Store (0x10, Index (NFBU, Zero)) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, 0x0B)) | |
{ | |
Store (0x11, Index (NFBU, Zero)) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, 0x0D)) | |
{ | |
Store (0x12, Index (NFBU, Zero)) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, 0x0E)) | |
{ | |
Store (0x14, Index (NFBU, Zero)) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, 0x0F)) | |
{ | |
Store (0x18, Index (NFBU, Zero)) | |
} | |
Else | |
{ | |
Store (HBDP, Index (NFBU, Zero)) | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
Return (NFBU) /* \_SB_.PCI0.GFX0._DSM.NFBU */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x05)) | |
{ | |
Store (Local0, \CADL) | |
Store (ShiftRight (Local0, 0x0C), \CSTE) | |
If (LEqual (QATH, One)) | |
{ | |
Store (Zero, QATH) /* \_SB_.PCI0.GFX0.QATH */ | |
Return (Zero) | |
} | |
Store (Local0, Local1) | |
If (And (Local1, 0x01000000)) | |
{ | |
If (LGreater (TLST, 0x0A)) | |
{ | |
Store (One, TLST) /* \_SB_.PCI0.GFX0.TLST */ | |
} | |
Store (TLST, Local0) | |
Store (ShiftLeft (Local0, 0x08), Local1) | |
Or (One, Local1, Local1) | |
Return (Local1) | |
} | |
Else | |
{ | |
If (LEqual (Local1, Zero)) | |
{ | |
Store (DSM5, Local0) | |
Return (Local0) | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x06)) | |
{ | |
Return (Package (0x1A) | |
{ | |
0x0110, | |
0x2C, | |
0x80000100, | |
0x2C, | |
0x0110, | |
0x80000100, | |
0x2C, | |
0x80007330, | |
0x2C, | |
0x0110, | |
0x80007330, | |
0x2C, | |
0x80000100, | |
0x80007330, | |
0x2C, | |
0x80006340, | |
0x2C, | |
0x0110, | |
0x80006340, | |
0x2C, | |
0x80000100, | |
0x80006340, | |
0x2C, | |
0x80007330, | |
0x80006340, | |
0x2C | |
}) | |
} | |
Else | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x02, 0x00, 0x00, 0x80 /* .... */ | |
}) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
If (LEqual (Arg0, ToUUID ("7ed873d3-c2d0-4e4f-a854-0f1317b01c2c"))) | |
{ | |
If (LEqual (Arg1, One)) | |
{ | |
If (LEqual (Arg2, Zero)) | |
{ | |
Return (Buffer (0x08) | |
{ | |
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* ........ */ | |
}) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Return (Package (0x06) | |
{ | |
0x05, | |
Package (0x02) | |
{ | |
0x80010400, | |
Buffer (0x04) | |
{ | |
0x02, 0x03, 0x03, 0x00 /* .... */ | |
} | |
}, | |
Package (0x02) | |
{ | |
0x80010100, | |
Buffer (0x04) | |
{ | |
0x01, 0x03, 0x03, 0x00 /* .... */ | |
} | |
}, | |
Package (0x02) | |
{ | |
0x80010300, | |
Buffer (0x04) | |
{ | |
0x05, 0x03, 0x03, 0x00 /* .... */ | |
} | |
}, | |
Package (0x02) | |
{ | |
0x80010301, | |
Buffer (0x04) | |
{ | |
0x08, 0x03, 0x03, 0x00 /* .... */ | |
} | |
}, | |
Package (0x02) | |
{ | |
0x80000302, | |
Buffer (0x04) | |
{ | |
0x0A, 0x03, 0x03, 0x00 /* .... */ | |
} | |
} | |
}) | |
} | |
Return (One) | |
} | |
Return (One) | |
} | |
If (LEqual (Arg0, ToUUID ("a486d8f8-0bda-471b-a72b-6042a6b5bee0"))) | |
{ | |
Store (Zero, Local0) | |
Store (ShiftLeft (DerefOf (Index (Arg3, 0x03)), 0x18), Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, 0x02)), 0x10), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, One)), 0x08), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, Zero)), Zero), Local0, | |
Local0) | |
If (LNotEqual (Arg1, 0x0100)) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x02, 0x00, 0x00, 0x80 /* .... */ | |
}) | |
} | |
Name (SUBF, Zero) | |
Store (Arg2, SUBF) /* \_SB_.PCI0.GFX0._DSM.SUBF */ | |
If (LEqual (SUBF, Zero)) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x01, 0x00, 0x03, 0x04 /* .... */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (SUBF, 0x10)) | |
{ | |
ShiftRight (Local0, 0x10, Local2) | |
If (LEqual (Local2, 0x564B)) | |
{ | |
Return (OPVK) /* \OPVK */ | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LEqual (SUBF, 0x1A)) | |
{ | |
If (And (Local0, One)) | |
{ | |
ShiftRight (Local0, 0x18, Local2) | |
Store (Local2, P3MO) /* \_SB_.PCI0.GFX0.P3MO */ | |
} | |
If (DGPS) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x41, 0x00, 0x00, 0x01 /* A... */ | |
}) | |
} | |
Else | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x59, 0x00, 0x00, 0x01 /* Y... */ | |
}) | |
} | |
} | |
} | |
Return (Buffer (0x04) | |
{ | |
0x02, 0x00, 0x00, 0x80 /* .... */ | |
}) | |
} | |
} | |
If (LEqual (Arg0, ToUUID ("a3132d01-8cda-49ba-a52e-bc9d46df6b81"))) | |
{ | |
Store (Zero, Local0) | |
Store (ShiftLeft (DerefOf (Index (Arg3, 0x03)), 0x18), Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, 0x02)), 0x10), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, One)), 0x08), Local0, | |
Local0) | |
Add (ShiftLeft (DerefOf (Index (Arg3, Zero)), Zero), Local0, | |
Local0) | |
If (LNotEqual (Arg1, 0x0100)) | |
{ | |
Return (Buffer (0x04) | |
{ | |
0x02, 0x00, 0x00, 0x80 /* .... */ | |
}) | |
} | |
Name (SFNN, Zero) | |
Store (Arg2, SFNN) /* \_SB_.PCI0.GFX0._DSM.SFNN */ | |
If (LEqual (SFNN, Zero)) | |
{ | |
Return (Buffer (0x08) | |
{ | |
0x01, 0x00, 0x08, 0x00, 0x0F, 0x04, 0x00, 0x00 /* ........ */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x2A)) | |
{ | |
CreateByteField (Arg3, Zero, PSH0) | |
CreateByteField (Arg3, One, PSH1) | |
CreateBitField (Arg3, 0x08, GPUT) | |
CreateBitField (Arg3, 0x09, CPUT) | |
CreateBitField (Arg3, 0x0A, FANS) | |
CreateBitField (Arg3, 0x0B, SKIN) | |
CreateBitField (Arg3, 0x0C, ENGR) | |
CreateBitField (Arg3, 0x0D, SEN1) | |
CreateBitField (Arg3, 0x0E, SEN2) | |
Store (0x00010000, VRV1) /* \_SB_.PCI0.GFX0.VRV1 */ | |
While (One) | |
{ | |
Store (PSH0, _T_2) /* \_SB_.PCI0.GFX0._DSM._T_2 */ | |
If (LEqual (_T_2, Zero)) | |
{ | |
If (CPUT) | |
{ | |
Store (0x0200, RETN) /* \_SB_.PCI0.GFX0.RETN */ | |
Or (RETN, PSH0, RETN) /* \_SB_.PCI0.GFX0.RETN */ | |
Store (\_TZ.RTMP (), PDTS) /* \_SB_.PCI0.GFX0.PDTS */ | |
} | |
Return (GPSP) /* \_SB_.PCI0.GFX0.GPSP */ | |
} | |
Else | |
{ | |
If (LEqual (_T_2, One)) | |
{ | |
Store (0x0300, RETN) /* \_SB_.PCI0.GFX0.RETN */ | |
Or (RETN, PSH0, RETN) /* \_SB_.PCI0.GFX0.RETN */ | |
Store (0x03E8, PDTS) /* \_SB_.PCI0.GFX0.PDTS */ | |
Return (GPSP) /* \_SB_.PCI0.GFX0.GPSP */ | |
} | |
Else | |
{ | |
If (LEqual (_T_2, 0x02)) | |
{ | |
Store (0x0102, RETN) /* \_SB_.PCI0.GFX0.RETN */ | |
Store (0x58, TMGP) /* \_SB_.PCI0.GFX0.TMGP */ | |
Store (Zero, PDTS) /* \_SB_.PCI0.GFX0.PDTS */ | |
Store (Zero, SFAN) /* \_SB_.PCI0.GFX0.SFAN */ | |
Store (Zero, CPUE) /* \_SB_.PCI0.GFX0.CPUE */ | |
Store (Zero, SKNT) /* \_SB_.PCI0.GFX0.SKNT */ | |
Store (Zero, TM01) /* \_SB_.PCI0.GFX0.TM01 */ | |
Store (Zero, TM02) /* \_SB_.PCI0.GFX0.TM02 */ | |
Return (GPSP) /* \_SB_.PCI0.GFX0.GPSP */ | |
} | |
} | |
} | |
Break | |
} | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x20)) | |
{ | |
CreateBitField (Arg3, 0x18, NRIT) | |
CreateBitField (Arg3, 0x19, NRIS) | |
If (NRIS) | |
{ | |
If (NRIT) | |
{ | |
Or (RET1, 0x00100000, RET1) /* \_SB_.PCI0.GFX0.RET1 */ | |
} | |
Else | |
{ | |
Store (Subtract (CPUP, One), SLMT) /* \_SB_.SLMT */ | |
NCPS (0x80) | |
And (RET1, 0xFEFFFFFF, RET1) /* \_SB_.PCI0.GFX0.RET1 */ | |
} | |
} | |
Or (RET1, 0x40000000, RET1) /* \_SB_.PCI0.GFX0.RET1 */ | |
If (NLIM) | |
{ | |
Or (RET1, One, RET1) /* \_SB_.PCI0.GFX0.RET1 */ | |
} | |
Return (RET1) /* \_SB_.PCI0.GFX0.RET1 */ | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x13)) | |
{ | |
Return (Arg3) | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x21)) | |
{ | |
Return (\_PR.CPU0._PSS) /* External reference */ | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x22)) | |
{ | |
CreateDWordField (Arg3, Zero, PCAP) | |
Store (Subtract (CPUP, PCAP), SLMT) /* \_SB_.SLMT */ | |
NCPS (0x80) | |
Store (PCAP, PSAP) /* \_SB_.PCI0.GFX0.PSAP */ | |
Return (PCAP) /* \_SB_.PCI0.GFX0._DSM.PCAP */ | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x23)) | |
{ | |
Return (PSAP) /* \_SB_.PCI0.GFX0.PSAP */ | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x25)) | |
{ | |
Return (\_PR.CPU0._TSS) /* External reference */ | |
} | |
Else | |
{ | |
If (LEqual (SFNN, 0x26)) | |
{ | |
CreateDWordField (Arg3, Zero, TCAP) | |
Store (TCAP, PDC0) /* External reference */ | |
NCPS (0x82) | |
Return (TCAP) /* \_SB_.PCI0.GFX0._DSM.TCAP */ | |
} | |
Else | |
{ | |
Return (0x80000002) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
Method (RSTO, 0, NotSerialized) | |
{ | |
OperationRegion (VGAR, SystemMemory, 0xF8100000, 0x0100) | |
Field (VGAR, DWordAcc, NoLock, Preserve) | |
{ | |
VDID, 32, | |
COST, 32, | |
VREG, 1984 | |
} | |
And (COST, 0xFFFF0000, COST) /* \_SB_.PCI0.GFX0.RSTO.COST */ | |
Store (RST1, VREG) /* \_SB_.PCI0.GFX0.RSTO.VREG */ | |
Or (COST, 0xFFFF0006, COST) /* \_SB_.PCI0.GFX0.RSTO.COST */ | |
} | |
Method (SAVO, 0, NotSerialized) | |
{ | |
OperationRegion (VGAR, SystemMemory, 0xF8100000, 0x0100) | |
Field (VGAR, DWordAcc, NoLock, Preserve) | |
{ | |
VDID, 32, | |
COST, 32, | |
VREG, 1984 | |
} | |
Store (VREG, RST1) /* \_SB_.PCI0.GFX0.RST1 */ | |
} | |
Method (HHKW, 0, Serialized) | |
{ | |
While (LNot (HHKM)) | |
{ | |
Sleep (0x64) | |
} | |
Store (Zero, HHKM) /* \_SB_.PCI0.GFX0.HHKM */ | |
} | |
Method (HHKS, 0, Serialized) | |
{ | |
Store (One, HHKM) /* \_SB_.PCI0.GFX0.HHKM */ | |
} | |
Method (TGPU, 1, NotSerialized) | |
{ | |
HHKW () | |
Store (Arg0, HGDP) /* \_SB_.PCI0.GFX0.HGDP */ | |
Store (Zero, Local0) | |
Add (Arg0, Local0, Local0) | |
Store (Local0, DSM2) /* \_SB_.PCI0.GFX0.DSM2 */ | |
Notify (GFX0, 0xD0) // Hardware-Specific | |
Store (0x1E, Local0) | |
While (Local0) | |
{ | |
If (LNotEqual (HGAP, Arg0)) | |
{ | |
Sleep (0x01F4) | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Store (Zero, DSM2) /* \_SB_.PCI0.GFX0.DSM2 */ | |
HHKS () | |
} | |
Method (MXDS, 1, NotSerialized) | |
{ | |
If (And (Arg0, Zero)) | |
{ | |
Return (LNot (HLMX)) | |
} | |
Else | |
{ | |
Store (Zero, HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
Store (Zero, HCMX) /* \_SB_.PCI0.GFX0.HCMX */ | |
Sleep (0x64) | |
} | |
Return (Zero) | |
} | |
Method (MXMX, 1, NotSerialized) | |
{ | |
Store (One, HLMM) /* \_SB_.PCI0.GFX0.HLMM */ | |
Store (One, HCMM) /* \_SB_.PCI0.GFX0.HCMM */ | |
Store (One, HDMU) /* \_SB_.PCI0.GFX0.HDMU */ | |
Store (One, HHMM) /* \_SB_.PCI0.GFX0.HHMM */ | |
Store (Zero, HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
Store (Zero, HCMX) /* \_SB_.PCI0.GFX0.HCMX */ | |
Store (Zero, HDMX) /* \_SB_.PCI0.GFX0.HDMX */ | |
Store (Zero, HHMX) /* \_SB_.PCI0.GFX0.HHMX */ | |
Return (One) | |
} | |
Method (HUPB, 0, NotSerialized) | |
{ | |
If (LEqual (HGAP, One)) | |
{ | |
Notify (LCDD, 0x86) // Device-Specific | |
} | |
} | |
Method (HDWB, 0, NotSerialized) | |
{ | |
If (LEqual (HGAP, One)) | |
{ | |
Notify (LCDD, 0x87) // Device-Specific | |
} | |
} | |
Method (HDVG, 0, NotSerialized) | |
{ | |
If (LEqual (HGAP, One)) | |
{ | |
HGCA () | |
HGCD () | |
And (\CADL, 0xFF, \CADL) | |
And (\CSTE, 0xFF, \CSTE) | |
If (UPDN) | |
{ | |
Store (HD2A (\CSTE), NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
Store (Zero, UPDN) /* \_SB_.PCI0.GFX0.UPDN */ | |
} | |
Store (HD2A (\CADL), Local1) | |
} | |
Else | |
{ | |
Store (One, QATH) /* \_SB_.PCI0.GFX0.QATH */ | |
EV80 () | |
Store (0x01F4, Local0) | |
While (Local0) | |
{ | |
If (QATH) | |
{ | |
Sleep (0x0A) | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
And (\CADL, 0x0FFF, \CADL) | |
And (\CSTE, 0x0FFF, \CSTE) | |
If (UPDN) | |
{ | |
Store (D2AF (\CSTE), NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
Store (Zero, UPDN) /* \_SB_.PCI0.GFX0.UPDN */ | |
} | |
Store (D2AF (\CADL), Local1) | |
} | |
Store (Zero, Local0) | |
While (LNotEqual (NXTD, Local0)) | |
{ | |
Increment (NXTD) | |
If (LEqual (NXTD, 0x07)) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x0B)) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LGreaterEqual (NXTD, 0x0D), LLessEqual (NXTD, 0x0F))) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x13)) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LGreaterEqual (NXTD, 0x15), LLessEqual (NXTD, 0x17))) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LGreaterEqual (NXTD, 0x19), LLessEqual (NXTD, 0x1F))) | |
{ | |
Increment (NXTD) | |
} | |
If (LEqual (NXTD, 0x23)) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LGreaterEqual (NXTD, 0x25), LLessEqual (NXTD, 0x27))) | |
{ | |
Increment (NXTD) | |
} | |
If (LAnd (LGreaterEqual (NXTD, 0x29), LLessEqual (NXTD, 0x2F))) | |
{ | |
Increment (NXTD) | |
} | |
If (LGreater (NXTD, 0x30)) | |
{ | |
Store (One, NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
And (NXTD, Local1, Local0) | |
} | |
Return (NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Method (GATD, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x10)) | |
{ | |
Return (0x04) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x11)) | |
{ | |
Return (0x05) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x12)) | |
{ | |
Return (0x06) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x20)) | |
{ | |
Return (0x07) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x21)) | |
{ | |
Return (0x08) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x22)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x30)) | |
{ | |
Return (0x0A) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Method (HWHG, 1, Serialized) | |
{ | |
If (LAnd (And (Arg0, 0x30), LEqual (HGAP, One))) | |
{ | |
TGPU (0x02) | |
Sleep (0x2AF8) | |
} | |
Store (One, UPDN) /* \_SB_.PCI0.GFX0.UPDN */ | |
Store (Zero, DONE) /* \_SB_.PCI0.GFX0.DONE */ | |
Store (GATD (Arg0), TLST) /* \_SB_.PCI0.GFX0.TLST */ | |
EV80 () | |
Store (0x01F4, Local0) | |
While (Local0) | |
{ | |
If (DONE) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
Sleep (0x0A) | |
Decrement (Local0) | |
} | |
} | |
Sleep (0x64) | |
} | |
Method (HGCD, 0, NotSerialized) | |
{ | |
If (LEqual (CADL, Zero)) | |
{ | |
Store (BLCD, \CSTE) | |
Return (Zero) | |
} | |
Store (HA2D (CADL), \CSTE) | |
If (LEqual (CAL2, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL2), \CSTE, \CSTE) | |
If (LEqual (CAL3, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL3), \CSTE, \CSTE) | |
If (LEqual (CAL4, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL4), \CSTE, \CSTE) | |
If (LEqual (CAL5, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL5), \CSTE, \CSTE) | |
If (LEqual (CAL6, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL6), \CSTE, \CSTE) | |
If (LEqual (CAL7, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL7), \CSTE, \CSTE) | |
If (LEqual (CAL8, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CAL8), \CSTE, \CSTE) | |
Return (Zero) | |
} | |
Method (HGTP, 1, NotSerialized) | |
{ | |
And (Arg0, 0x0FFF, Local0) | |
If (LEqual (Local0, 0x0100)) | |
{ | |
Store (Arg0, CRID) /* \_SB_.PCI0.GFX0.CRID */ | |
} | |
If (LEqual (Local0, 0x0110)) | |
{ | |
Store (Arg0, LFID) /* \_SB_.PCI0.GFX0.LFID */ | |
} | |
If (LEqual (Local0, 0x0340)) | |
{ | |
Store (Arg0, DPID) /* \_SB_.PCI0.GFX0.DPID */ | |
} | |
If (LEqual (Local0, 0x0330)) | |
{ | |
Store (Arg0, HDID) /* \_SB_.PCI0.GFX0.HDID */ | |
} | |
} | |
Method (HDTP, 0, NotSerialized) | |
{ | |
HGTP (CPDL) | |
HGTP (CPL2) | |
HGTP (CPL3) | |
HGTP (CPL4) | |
HGTP (CPL5) | |
HGTP (CPL6) | |
HGTP (CPL7) | |
HGTP (CPL8) | |
} | |
Method (HGCA, 0, NotSerialized) | |
{ | |
HDTP () | |
If (LEqual (CPDL, Zero)) | |
{ | |
Store (BLCD, \CADL) | |
Return (Zero) | |
} | |
Store (HA2D (CPDL), \CADL) | |
If (LEqual (CPL2, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL2), \CADL, \CADL) | |
If (LEqual (CPL3, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL3), \CADL, \CADL) | |
If (LEqual (CPL4, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL4), \CADL, \CADL) | |
If (LEqual (CPL5, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL5), \CADL, \CADL) | |
If (LEqual (CPL6, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL6), \CADL, \CADL) | |
If (LEqual (CPL7, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL7), \CADL, \CADL) | |
If (LEqual (CPL8, Zero)) | |
{ | |
Return (Zero) | |
} | |
Or (HA2D (CPL8), \CADL, \CADL) | |
Return (Zero) | |
} | |
Method (HA2D, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (LEqual (Arg0, LFID)) | |
{ | |
Or (Local0, BLCD, Local0) | |
} | |
If (LEqual (Arg0, CRID)) | |
{ | |
Or (Local0, BCRT, Local0) | |
} | |
If (LEqual (Arg0, TVID)) | |
{ | |
Or (Local0, BTVO, Local0) | |
} | |
If (LEqual (Arg0, HDID)) | |
{ | |
Or (Local0, BHDM, Local0) | |
} | |
If (LEqual (Arg0, DVID)) | |
{ | |
Or (Local0, BDVI, Local0) | |
} | |
If (LEqual (Arg0, DPID)) | |
{ | |
Or (Local0, BDPO, Local0) | |
} | |
Return (Local0) | |
} | |
Method (HD2A, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
If (And (Arg0, BLCD)) | |
{ | |
Or (Local0, One, Local0) | |
} | |
If (And (Arg0, BCRT)) | |
{ | |
Or (Local0, 0x02, Local0) | |
} | |
If (And (Arg0, BTVO)) | |
{ | |
Or (Local0, 0x04, Local0) | |
} | |
If (And (Arg0, BDVI)) | |
{ | |
Or (Local0, 0x08, Local0) | |
} | |
If (And (Arg0, BHDM)) | |
{ | |
Or (Local0, 0x10, Local0) | |
} | |
If (And (Arg0, BDPO)) | |
{ | |
Or (Local0, 0x20, Local0) | |
} | |
If (LNot (Local0)) | |
{ | |
Return (NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Return (Local0) | |
} | |
Method (NWM1, 1, NotSerialized) | |
{ | |
Notify (WMI1, Arg0) | |
} | |
Method (EVD0, 0, NotSerialized) | |
{ | |
Notify (GFX0, 0xD0) // Hardware-Specific | |
NWM1 (0xD0) | |
} | |
Method (EVD9, 0, NotSerialized) | |
{ | |
Notify (GFX0, 0xD9) // Hardware-Specific | |
NWM1 (0xD9) | |
} | |
Method (EVDA, 0, NotSerialized) | |
{ | |
Notify (GFX0, 0xDA) // Hardware-Specific | |
NWM1 (0xDA) | |
} | |
Method (EV80, 0, NotSerialized) | |
{ | |
Notify (GFX0, 0x80) // Status Change | |
NWM1 (0x80) | |
} | |
Method (EV81, 0, NotSerialized) | |
{ | |
Notify (GFX0, 0x81) // Information Change | |
NWM1 (0x81) | |
} | |
Name (_PSC, Zero) // _PSC: Power State Current | |
Name (P3MO, 0x02) | |
Name (DGPS, Zero) | |
Device (^^MEM2) | |
{ | |
Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (CRS1, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x20000000, // Address Base | |
0x00200000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0x40000000, // Address Base | |
0x00200000, // Address Length | |
) | |
}) | |
Name (CRS2, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x20000000, // Address Base | |
0x00200000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0x40004000, // Address Base | |
0x00001000, // Address Length | |
) | |
}) | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (IGDS) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
If (LOr (LEqual (And (PNHM, 0x0FFF0FF0), 0x000206A0), LEqual (And ( | |
PNHM, 0x0FFF0FFF), 0x000306A0))) | |
{ | |
Return (CRS1) /* \_SB_.MEM2.CRS1 */ | |
} | |
Return (CRS2) /* \_SB_.MEM2.CRS2 */ | |
} | |
} | |
} | |
Device (RP02) | |
{ | |
Name (_ADR, 0x001C0001) // _ADR: Address | |
OperationRegion (LCTL, PCI_Config, 0x50, 0x04) | |
Field (LCTL, ByteAcc, NoLock, Preserve) | |
{ | |
, 4, | |
PELD, 1, | |
PERL, 1 | |
} | |
OperationRegion (SLOT, PCI_Config, 0x54, 0x10) | |
Field (SLOT, ByteAcc, NoLock, Preserve) | |
{ | |
SCAP, 32, | |
SCTL, 16, | |
ABP1, 1, | |
PFD1, 1, | |
MSC1, 1, | |
PDC1, 1, | |
CC10, 1, | |
MS10, 1, | |
PDS1, 1, | |
RSV0, 1, | |
LASC, 1, | |
RSV1, 7 | |
} | |
OperationRegion (RHUB, PCI_Config, 0x60, 0x10) | |
Field (RHUB, ByteAcc, NoLock, Preserve) | |
{ | |
PMID, 16, | |
PMES, 1, | |
PMEP, 1, | |
RSV2, 14 | |
} | |
OperationRegion (MISC, PCI_Config, 0xD8, 0x08) | |
Field (MISC, ByteAcc, NoLock, Preserve) | |
{ | |
RSV4, 30, | |
PMCE, 1, | |
HPCE, 1, | |
PMMS, 1, | |
HPPD, 1, | |
HPAB, 1, | |
HPCC, 1, | |
HPLA, 1, | |
RSV3, 25, | |
HPCS, 1, | |
PMCS, 1 | |
} | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
LSCX, 1, | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1, | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
Store (One, PDC1) /* \_SB_.PCI0.RP02.PDC1 */ | |
Store (One, HPCS) /* \_SB_.PCI0.RP02.HPCS */ | |
Store (Zero, PELD) /* \_SB_.PCI0.RP02.PELD */ | |
Sleep (0xFA) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR05 ()) | |
} | |
Return (PR05 ()) | |
} | |
Device (WLAN) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
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 (LEqual (SNUM, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
If (LNotEqual (BSCC, 0x02)) | |
{ | |
Return (Zero) | |
} | |
Return (One) | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x03)) | |
} | |
} | |
} | |
Device (EHC1) | |
{ | |
Name (_ADR, 0x001D0000) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0D, 0x03)) | |
} | |
} | |
Device (XHC1) | |
{ | |
Name (_ADR, 0x00140000) // _ADR: Address | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0D, 0x03)) | |
} | |
} | |
} | |
} | |
Scope (\) | |
{ | |
OperationRegion (IO_T, SystemIO, 0x1000, 0x10) | |
Field (IO_T, ByteAcc, NoLock, Preserve) | |
{ | |
TRPI, 16, | |
Offset (0x04), | |
Offset (0x06), | |
Offset (0x08), | |
TRP0, 8, | |
Offset (0x0A), | |
Offset (0x0B), | |
Offset (0x0C), | |
Offset (0x0D), | |
Offset (0x0E), | |
Offset (0x0F), | |
Offset (0x10) | |
} | |
OperationRegion (IO_D, SystemIO, 0x0810, 0x04) | |
Field (IO_D, ByteAcc, NoLock, Preserve) | |
{ | |
TRPD, 8 | |
} | |
OperationRegion (IO_H, SystemIO, 0x1000, 0x04) | |
Field (IO_H, ByteAcc, NoLock, Preserve) | |
{ | |
TRPH, 8 | |
} | |
OperationRegion (RCRB, SystemMemory, SRCB, 0x4000) | |
Field (RCRB, DWordAcc, Lock, Preserve) | |
{ | |
Offset (0x1000), | |
Offset (0x3000), | |
Offset (0x3404), | |
HPAS, 2, | |
, 5, | |
HPAE, 1, | |
Offset (0x3418), | |
, 1, | |
, 1, | |
SATD, 1, | |
SMBD, 1, | |
HDAD, 1, | |
Offset (0x341A), | |
RP1D, 1, | |
RP2D, 1, | |
RP3D, 1, | |
RP4D, 1, | |
RP5D, 1, | |
RP6D, 1, | |
RP7D, 1, | |
RP8D, 1, | |
Offset (0x359C), | |
UP0D, 1, | |
UP1D, 1, | |
UP2D, 1, | |
UP3D, 1, | |
UP4D, 1, | |
UP5D, 1, | |
UP6D, 1, | |
UP7D, 1, | |
UP8D, 1, | |
UP9D, 1, | |
UPAD, 1, | |
UPBD, 1, | |
UPCD, 1, | |
UPDD, 1, | |
, 1, | |
Offset (0x359E) | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Device (XHC) | |
{ | |
Name (_ADR, 0x00140000) // _ADR: Address | |
OperationRegion (XPRT, PCI_Config, 0x74, 0x6C) | |
Field (XPRT, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x01), | |
PMEE, 1, | |
, 6, | |
PMES, 1, | |
Offset (0x5C), | |
PR2, 32, | |
PR2M, 32, | |
PR3, 32, | |
PR3M, 32 | |
} | |
Name (XRST, Zero) | |
Method (CUID, 1, Serialized) | |
{ | |
If (LEqual (Arg0, ToUUID ("7c9512a9-1705-4cb4-af7d-506a2423ab71"))) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (POSC, 3, Serialized) | |
{ | |
CreateDWordField (Arg2, Zero, CDW1) | |
CreateDWordField (Arg2, 0x08, CDW3) | |
If (LNotEqual (Arg1, One)) | |
{ | |
Or (CDW1, 0x08, CDW1) /* \_SB_.PCI0.XHC_.POSC.CDW1 */ | |
} | |
If (LEqual (XHCI, Zero)) | |
{ | |
Or (CDW1, 0x02, CDW1) /* \_SB_.PCI0.XHC_.POSC.CDW1 */ | |
} | |
If (LNot (And (CDW1, One))) | |
{ | |
If (And (CDW3, One)) | |
{ | |
ESEL () | |
} | |
Else | |
{ | |
XSEL () | |
} | |
} | |
Return (Arg2) | |
} | |
Method (XSEL, 0, Serialized) | |
{ | |
If (LOr (LEqual (XHCI, 0x02), LEqual (XHCI, 0x03))) | |
{ | |
Store (One, XUSB) /* \_SB_.XUSB */ | |
Store (One, XRST) /* \_SB_.PCI0.XHC_.XRST */ | |
Store (Zero, Local0) | |
And (PR3, 0xFFFFFFF0, Local0) | |
Or (Local0, XHPM, Local0) | |
And (Local0, PR3M, PR3) /* \_SB_.PCI0.XHC_.PR3_ */ | |
Store (Zero, Local0) | |
And (PR2, 0xFFFFFFF0, Local0) | |
Or (Local0, XHPM, Local0) | |
And (Local0, PR2M, PR2) /* \_SB_.PCI0.XHC_.PR2_ */ | |
} | |
} | |
Method (ESEL, 0, Serialized) | |
{ | |
If (LOr (LEqual (XHCI, 0x02), LEqual (XHCI, 0x03))) | |
{ | |
And (PR3, 0xFFFFFFF0, PR3) /* \_SB_.PCI0.XHC_.PR3_ */ | |
And (PR2, 0xFFFFFFF0, PR2) /* \_SB_.PCI0.XHC_.PR2_ */ | |
Store (Zero, XUSB) /* \_SB_.XUSB */ | |
Store (Zero, XRST) /* \_SB_.PCI0.XHC_.XRST */ | |
} | |
} | |
Method (XWAK, 1, Serialized) | |
{ | |
If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04))) | |
{ | |
If (LOr (LEqual (XUSB, One), LEqual (XRST, One))) | |
{ | |
XSEL () | |
} | |
} | |
} | |
Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State | |
{ | |
Return (0x02) | |
} | |
Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State | |
{ | |
Return (0x02) | |
} | |
Device (RHUB) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Device (HSP1) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR2, One))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, Zero)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.HSP1._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, Zero)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR2, One))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.HSP1._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.HSP1._PLD.PLDP */ | |
} | |
} | |
Device (HSP2) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR2, 0x02))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, One)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.HSP2._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, One)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR2, 0x02))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.HSP2._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.HSP2._PLD.PLDP */ | |
} | |
} | |
Device (HSP3) | |
{ | |
Name (_ADR, 0x03) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR2, 0x04))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, 0x02)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.HSP3._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, 0x02)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR2, 0x04))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.HSP3._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.HSP3._PLD.PLDP */ | |
} | |
} | |
Device (HSP4) | |
{ | |
Name (_ADR, 0x04) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR2, 0x08))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, 0x03)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.HSP4._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, 0x03)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR2, 0x08))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.HSP4._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.HSP4._PLD.PLDP */ | |
} | |
} | |
Device (SSP1) | |
{ | |
Name (_ADR, 0x05) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR3, One))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, Zero)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.SSP1._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, Zero)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR3, One))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.SSP1._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.SSP1._PLD.PLDP */ | |
} | |
} | |
Device (SSP2) | |
{ | |
Name (_ADR, 0x06) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR3, 0x02))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, One)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.SSP2._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, One)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR3, 0x02))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.SSP2._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.SSP2._PLD.PLDP */ | |
} | |
} | |
Device (SSP3) | |
{ | |
Name (_ADR, 0x07) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR3, 0x04))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, 0x02)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.SSP3._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, 0x02)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR3, 0x04))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.SSP3._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.SSP3._PLD.PLDP */ | |
} | |
} | |
Device (SSP4) | |
{ | |
Name (_ADR, 0x08) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (UPCP, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
If (LNot (And (PR3, 0x08))) | |
{ | |
Store (Zero, Index (UPCP, Zero)) | |
} | |
Store (DerefOf (Index (CNTB, 0x03)), Local0) | |
Store (Local0, Index (UPCP, Zero)) | |
Return (UPCP) /* \_SB_.PCI0.XHC_.RHUB.SSP4._UPC.UPCP */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (PLDP, Package (0x01) | |
{ | |
Buffer (0x10) | |
{ | |
/* 0000 */ 0x01, 0xC6, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, /* ..r..... */ | |
/* 0008 */ 0x69, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 /* i....... */ | |
} | |
}) | |
Store (DerefOf (Index (VISB, 0x03)), Local0) | |
Store (DerefOf (Index (DerefOf (Index (PLDP, Zero)), 0x08)), | |
Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (DerefOf (Index (PLDP, Zero)), 0x08)) | |
CreateBitField (DerefOf (Index (PLDP, Zero)), 0x40, VIS) | |
If (LNot (And (PR3, 0x08))) | |
{ | |
And (VIS, Zero, VIS) /* \_SB_.PCI0.XHC_.RHUB.SSP4._PLD.VIS_ */ | |
} | |
Return (PLDP) /* \_SB_.PCI0.XHC_.RHUB.SSP4._PLD.PLDP */ | |
} | |
} | |
} | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x0D, 0x03)) | |
} | |
} | |
} | |
OperationRegion (_SB.PCI0.LPCB.LPCR, PCI_Config, 0x80, 0x04) | |
Field (\_SB.PCI0.LPCB.LPCR, ByteAcc, NoLock, Preserve) | |
{ | |
CADR, 3, | |
, 1, | |
CBDR, 3, | |
Offset (0x01), | |
LTDR, 2, | |
, 2, | |
FDDR, 1, | |
Offset (0x02), | |
CALE, 1, | |
CBLE, 1, | |
LTLE, 1, | |
FDLE, 1, | |
Offset (0x03), | |
GLLE, 1, | |
GHLE, 1, | |
KCLE, 1, | |
MCLE, 1, | |
C1LE, 1, | |
C2LE, 1, | |
Offset (0x04) | |
} | |
Method (UXDV, 1, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
Store (0xFF, Local0) | |
While (One) | |
{ | |
Store (Add (Arg0, Zero), _T_0) /* \UXDV._T_0 */ | |
If (LEqual (_T_0, 0x03F8)) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02F8)) | |
{ | |
Store (One, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0220)) | |
{ | |
Store (0x02, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0228)) | |
{ | |
Store (0x03, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0238)) | |
{ | |
Store (0x04, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02E8)) | |
{ | |
Store (0x05, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0338)) | |
{ | |
Store (0x06, Local0) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03E8)) | |
{ | |
Store (0x07, Local0) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
Return (Local0) | |
} | |
Method (RRIO, 4, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
While (One) | |
{ | |
Store (Add (Arg0, Zero), _T_0) /* \RRIO._T_0 */ | |
If (LEqual (_T_0, Zero)) | |
{ | |
Store (Zero, CALE) /* \CALE */ | |
Store (UXDV (Arg2), Local0) | |
If (LNotEqual (Local0, 0xFF)) | |
{ | |
Store (Local0, CADR) /* \CADR */ | |
} | |
If (Arg1) | |
{ | |
Store (One, CALE) /* \CALE */ | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Store (Zero, CBLE) /* \CBLE */ | |
Store (UXDV (Arg2), Local0) | |
If (LNotEqual (Local0, 0xFF)) | |
{ | |
Store (Local0, CBDR) /* \CBDR */ | |
} | |
If (Arg1) | |
{ | |
Store (One, CBLE) /* \CBLE */ | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
Store (Zero, LTLE) /* \LTLE */ | |
If (LEqual (Arg2, 0x0378)) | |
{ | |
Store (Zero, LTDR) /* \LTDR */ | |
} | |
If (LEqual (Arg2, 0x0278)) | |
{ | |
Store (One, LTDR) /* \LTDR */ | |
} | |
If (LEqual (Arg2, 0x03BC)) | |
{ | |
Store (0x02, LTDR) /* \LTDR */ | |
} | |
If (Arg1) | |
{ | |
Store (One, LTLE) /* \LTLE */ | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03)) | |
{ | |
Store (Zero, FDLE) /* \FDLE */ | |
If (LEqual (Arg2, 0x03F0)) | |
{ | |
Store (Zero, FDDR) /* \FDDR */ | |
} | |
If (LEqual (Arg2, 0x0370)) | |
{ | |
Store (One, FDDR) /* \FDDR */ | |
} | |
If (Arg1) | |
{ | |
Store (One, FDLE) /* \FDLE */ | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x08)) | |
{ | |
If (LEqual (Arg2, 0x0200)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, GLLE) /* \GLLE */ | |
} | |
Else | |
{ | |
Store (Zero, GLLE) /* \GLLE */ | |
} | |
} | |
If (LEqual (Arg2, 0x0208)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, GHLE) /* \GHLE */ | |
} | |
Else | |
{ | |
Store (Zero, GHLE) /* \GHLE */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x09)) | |
{ | |
If (LEqual (Arg2, 0x0200)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, GLLE) /* \GLLE */ | |
} | |
Else | |
{ | |
Store (Zero, GLLE) /* \GLLE */ | |
} | |
} | |
If (LEqual (Arg2, 0x0208)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, GHLE) /* \GHLE */ | |
} | |
Else | |
{ | |
Store (Zero, GHLE) /* \GHLE */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0A)) | |
{ | |
If (LOr (LEqual (Arg2, 0x60), LEqual (Arg2, 0x64))) | |
{ | |
If (Arg1) | |
{ | |
Store (One, KCLE) /* \KCLE */ | |
} | |
Else | |
{ | |
Store (Zero, KCLE) /* \KCLE */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0B)) | |
{ | |
If (LOr (LEqual (Arg2, 0x62), LEqual (Arg2, 0x66))) | |
{ | |
If (Arg1) | |
{ | |
Store (One, MCLE) /* \MCLE */ | |
} | |
Else | |
{ | |
Store (Zero, MCLE) /* \MCLE */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0C)) | |
{ | |
If (LEqual (Arg2, 0x2E)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, C1LE) /* \C1LE */ | |
} | |
Else | |
{ | |
Store (Zero, C1LE) /* \C1LE */ | |
} | |
} | |
If (LEqual (Arg2, 0x4E)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, C2LE) /* \C2LE */ | |
} | |
Else | |
{ | |
Store (Zero, C2LE) /* \C2LE */ | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x0D)) | |
{ | |
If (LEqual (Arg2, 0x2E)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, C1LE) /* \C1LE */ | |
} | |
Else | |
{ | |
Store (Zero, C1LE) /* \C1LE */ | |
} | |
} | |
If (LEqual (Arg2, 0x4E)) | |
{ | |
If (Arg1) | |
{ | |
Store (One, C2LE) /* \C2LE */ | |
} | |
Else | |
{ | |
Store (Zero, C2LE) /* \C2LE */ | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
Method (RDMA, 3, NotSerialized) | |
{ | |
} | |
Scope (_SB.PCI0) | |
{ | |
Name (PA0H, Zero) | |
Name (PA1H, Zero) | |
Name (PA2H, Zero) | |
Name (PA3H, Zero) | |
Name (PA4H, Zero) | |
Name (PA5H, Zero) | |
Name (PA6H, Zero) | |
Method (NPTS, 1, NotSerialized) | |
{ | |
Store (PM0H, PA0H) /* \_SB_.PCI0.PA0H */ | |
Store (PM1H, PA1H) /* \_SB_.PCI0.PA1H */ | |
Store (PM2H, PA2H) /* \_SB_.PCI0.PA2H */ | |
Store (PM3H, PA3H) /* \_SB_.PCI0.PA3H */ | |
Store (PM4H, PA4H) /* \_SB_.PCI0.PA4H */ | |
Store (PM5H, PA5H) /* \_SB_.PCI0.PA5H */ | |
Store (PM6H, PA6H) /* \_SB_.PCI0.PA6H */ | |
} | |
Method (NWAK, 1, NotSerialized) | |
{ | |
Store (PA0H, PM0H) /* \_SB_.PCI0.PM0H */ | |
Store (PA1H, PM1H) /* \_SB_.PCI0.PM1H */ | |
Store (PA2H, PM2H) /* \_SB_.PCI0.PM2H */ | |
Store (PA3H, PM3H) /* \_SB_.PCI0.PM3H */ | |
Store (PA4H, PM4H) /* \_SB_.PCI0.PM4H */ | |
Store (PA5H, PM5H) /* \_SB_.PCI0.PM5H */ | |
Store (PA6H, PM6H) /* \_SB_.PCI0.PM6H */ | |
} | |
} | |
Scope (_PR) | |
{ | |
Processor (CPU0, 0x01, 0x00000410, 0x06) {} | |
Processor (CPU1, 0x02, 0x00000410, 0x06) {} | |
Processor (CPU2, 0x03, 0x00000410, 0x06) {} | |
Processor (CPU3, 0x04, 0x00000410, 0x06) {} | |
Processor (CPU4, 0x05, 0x00000410, 0x06) {} | |
Processor (CPU5, 0x06, 0x00000410, 0x06) {} | |
Processor (CPU6, 0x07, 0x00000410, 0x06) {} | |
Processor (CPU7, 0x08, 0x00000410, 0x06) {} | |
} | |
Mutex (MUTX, 0x00) | |
OperationRegion (DEB0, SystemIO, 0x80, One) | |
Field (DEB0, ByteAcc, NoLock, Preserve) | |
{ | |
DBG8, 8 | |
} | |
OperationRegion (DEB1, SystemIO, 0x90, 0x02) | |
Field (DEB1, WordAcc, NoLock, Preserve) | |
{ | |
DBG9, 16 | |
} | |
OperationRegion (PRT0, SystemIO, 0x80, 0x04) | |
Field (PRT0, DWordAcc, Lock, Preserve) | |
{ | |
P80H, 32 | |
} | |
Method (P8XH, 2, Serialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (Or (And (P80D, 0xFFFFFF00), Arg1), P80D) /* \P80D */ | |
} | |
If (LEqual (Arg0, One)) | |
{ | |
Store (Or (And (P80D, 0xFFFF00FF), ShiftLeft (Arg1, 0x08) | |
), P80D) /* \P80D */ | |
} | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Store (Or (And (P80D, 0xFF00FFFF), ShiftLeft (Arg1, 0x10) | |
), P80D) /* \P80D */ | |
} | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Store (Or (And (P80D, 0x00FFFFFF), ShiftLeft (Arg1, 0x18) | |
), P80D) /* \P80D */ | |
} | |
Store (P80D, P80H) /* \P80H */ | |
} | |
OperationRegion (SPRT, SystemIO, 0xB2, 0x02) | |
Field (SPRT, ByteAcc, Lock, Preserve) | |
{ | |
SSMP, 8 | |
} | |
Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model | |
{ | |
Store (Arg0, GPIC) /* \GPIC */ | |
Store (Arg0, PICM) /* \PICM */ | |
} | |
Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep | |
{ | |
PTS (Arg0) | |
} | |
Method (_WAK, 1, Serialized) // _WAK: Wake | |
{ | |
WAK (Arg0) | |
Return (Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
} | |
Method (GETB, 3, Serialized) | |
{ | |
Multiply (Arg0, 0x08, Local0) | |
Multiply (Arg1, 0x08, Local1) | |
CreateField (Arg2, Local0, Local1, TBF3) | |
Return (TBF3) /* \GETB.TBF3 */ | |
} | |
Method (PNOT, 0, Serialized) | |
{ | |
If (LGreater (TCNT, One)) | |
{ | |
If (And (PDC0, 0x08)) | |
{ | |
Notify (\_PR.CPU0, 0x80) // Performance Capability Change | |
If (And (PDC0, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU0, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC1, 0x08)) | |
{ | |
Notify (\_PR.CPU1, 0x80) // Performance Capability Change | |
If (And (PDC1, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU1, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC2, 0x08)) | |
{ | |
Notify (\_PR.CPU2, 0x80) // Performance Capability Change | |
If (And (PDC2, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU2, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC3, 0x08)) | |
{ | |
Notify (\_PR.CPU3, 0x80) // Performance Capability Change | |
If (And (PDC3, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU3, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC4, 0x08)) | |
{ | |
Notify (\_PR.CPU4, 0x80) // Performance Capability Change | |
If (And (PDC4, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU4, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC5, 0x08)) | |
{ | |
Notify (\_PR.CPU5, 0x80) // Performance Capability Change | |
If (And (PDC5, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU5, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC6, 0x08)) | |
{ | |
Notify (\_PR.CPU6, 0x80) // Performance Capability Change | |
If (And (PDC6, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU6, 0x81) // C-State Change | |
} | |
} | |
If (And (PDC7, 0x08)) | |
{ | |
Notify (\_PR.CPU7, 0x80) // Performance Capability Change | |
If (And (PDC7, 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU7, 0x81) // C-State Change | |
} | |
} | |
} | |
Else | |
{ | |
Notify (\_PR.CPU0, 0x80) // Performance Capability Change | |
Sleep (0x64) | |
Notify (\_PR.CPU0, 0x81) // C-State Change | |
} | |
} | |
Method (TRAP, 2, Serialized) | |
{ | |
Store (Arg1, SMIF) /* \SMIF */ | |
If (LEqual (Arg0, TRTP)) | |
{ | |
Store (Zero, TRP0) /* \TRP0 */ | |
} | |
If (LEqual (Arg0, TRTD)) | |
{ | |
Store (Arg1, DTSF) /* \DTSF */ | |
Store (Zero, TRPD) /* \TRPD */ | |
Return (DTSF) /* \DTSF */ | |
} | |
Return (SMIF) /* \SMIF */ | |
} | |
Scope (_SB.PCI0) | |
{ | |
Method (_INI, 0, NotSerialized) // _INI: Initialize | |
{ | |
Store (0x07D0, OSYS) /* \OSYS */ | |
If (CondRefOf (\_OSI, Local0)) | |
{ | |
If (_OSI ("Windows 2001")) | |
{ | |
Store (0x07D1, OSYS) /* \OSYS */ | |
} | |
If (_OSI ("Windows 2001 SP1")) | |
{ | |
Store (0x07D1, OSYS) /* \OSYS */ | |
} | |
If (_OSI ("Windows 2001 SP2")) | |
{ | |
Store (0x07D2, OSYS) /* \OSYS */ | |
} | |
If (_OSI ("Windows 2001.1")) | |
{ | |
Store (0x07D3, OSYS) /* \OSYS */ | |
} | |
If (_OSI ("Windows 2006")) | |
{ | |
Store (0x07D6, OSYS) /* \OSYS */ | |
} | |
If (_OSI ("Windows 2009")) | |
{ | |
Store (0x07D9, OSYS) /* \OSYS */ | |
} | |
} | |
} | |
Method (NHPG, 0, Serialized) | |
{ | |
Store (Zero, ^RP01.HPEX) /* \_SB_.PCI0.RP01.HPEX */ | |
Store (Zero, ^RP02.HPEX) /* \_SB_.PCI0.RP02.HPEX */ | |
Store (Zero, ^RP03.HPEX) /* \_SB_.PCI0.RP03.HPEX */ | |
Store (Zero, ^RP04.HPEX) /* \_SB_.PCI0.RP04.HPEX */ | |
Store (One, ^RP01.HPSX) /* \_SB_.PCI0.RP01.HPSX */ | |
Store (One, ^RP02.HPSX) /* \_SB_.PCI0.RP02.HPSX */ | |
Store (One, ^RP03.HPSX) /* \_SB_.PCI0.RP03.HPSX */ | |
Store (One, ^RP04.HPSX) /* \_SB_.PCI0.RP04.HPSX */ | |
} | |
Method (NPME, 0, Serialized) | |
{ | |
Store (Zero, ^RP01.PMEX) /* \_SB_.PCI0.RP01.PMEX */ | |
Store (Zero, ^RP02.PMEX) /* \_SB_.PCI0.RP02.PMEX */ | |
Store (Zero, ^RP03.PMEX) /* \_SB_.PCI0.RP03.PMEX */ | |
Store (Zero, ^RP04.PMEX) /* \_SB_.PCI0.RP04.PMEX */ | |
Store (Zero, ^RP05.PMEX) /* \_SB_.PCI0.RP05.PMEX */ | |
Store (Zero, ^RP06.PMEX) /* \_SB_.PCI0.RP06.PMEX */ | |
Store (Zero, ^RP07.PMEX) /* \_SB_.PCI0.RP07.PMEX */ | |
Store (Zero, ^RP08.PMEX) /* \_SB_.PCI0.RP08.PMEX */ | |
Store (One, ^RP01.PMSX) /* \_SB_.PCI0.RP01.PMSX */ | |
Store (One, ^RP02.PMSX) /* \_SB_.PCI0.RP02.PMSX */ | |
Store (One, ^RP03.PMSX) /* \_SB_.PCI0.RP03.PMSX */ | |
Store (One, ^RP04.PMSX) /* \_SB_.PCI0.RP04.PMSX */ | |
Store (One, ^RP05.PMSX) /* \_SB_.PCI0.RP05.PMSX */ | |
Store (One, ^RP06.PMSX) /* \_SB_.PCI0.RP06.PMSX */ | |
Store (One, ^RP07.PMSX) /* \_SB_.PCI0.RP07.PMSX */ | |
Store (One, ^RP08.PMSX) /* \_SB_.PCI0.RP08.PMSX */ | |
} | |
} | |
Scope (\) | |
{ | |
Name (PICM, Zero) | |
Name (PRWP, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
Method (GPRW, 2, NotSerialized) | |
{ | |
Store (Arg0, Index (PRWP, Zero)) | |
Store (ShiftLeft (SS1, One), Local0) | |
Or (Local0, ShiftLeft (SS2, 0x02), Local0) | |
Or (Local0, ShiftLeft (SS3, 0x03), Local0) | |
Or (Local0, ShiftLeft (SS4, 0x04), Local0) | |
If (And (ShiftLeft (One, Arg1), Local0)) | |
{ | |
Store (Arg1, Index (PRWP, One)) | |
} | |
Else | |
{ | |
ShiftRight (Local0, One, Local0) | |
FindSetLeftBit (Local0, Index (PRWP, One)) | |
} | |
Return (PRWP) /* \PRWP */ | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Device (PDRC) | |
{ | |
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
Name (_UID, One) // _UID: Unique ID | |
Name (BUF0, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00004000, // Address Length | |
_Y11) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00008000, // Address Length | |
_Y13) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y14) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y15) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y16) | |
Memory32Fixed (ReadWrite, | |
0xFED20000, // Address Base | |
0x00020000, // Address Length | |
) | |
Memory32Fixed (ReadOnly, | |
0xFED90000, // Address Base | |
0x00004000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED45000, // Address Base | |
0x0004B000, // Address Length | |
) | |
Memory32Fixed (ReadOnly, | |
0xFF000000, // Address Base | |
0x01000000, // Address Length | |
) | |
Memory32Fixed (ReadOnly, | |
0xFEE00000, // Address Base | |
0x00100000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y12) | |
}) | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y11._BAS, RBR0) // _BAS: Base Address | |
ShiftLeft (^^LPCB.RCBA, 0x0E, RBR0) /* \_SB_.PCI0.PDRC._CRS.RBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y12._BAS, TBR0) // _BAS: Base Address | |
Store (TBAB, TBR0) /* \_SB_.PCI0.PDRC._CRS.TBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y12._LEN, TBLN) // _LEN: Length | |
If (LEqual (TBAB, Zero)) | |
{ | |
Store (Zero, TBLN) /* \_SB_.PCI0.PDRC._CRS.TBLN */ | |
} | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y13._BAS, MBR0) // _BAS: Base Address | |
ShiftLeft (MHBR, 0x0F, MBR0) /* \_SB_.PCI0.PDRC._CRS.MBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y14._BAS, DBR0) // _BAS: Base Address | |
ShiftLeft (DIBR, 0x0C, DBR0) /* \_SB_.PCI0.PDRC._CRS.DBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y15._BAS, EBR0) // _BAS: Base Address | |
ShiftLeft (EPBR, 0x0C, EBR0) /* \_SB_.PCI0.PDRC._CRS.EBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y16._BAS, XBR0) // _BAS: Base Address | |
ShiftLeft (PXBR, 0x1A, XBR0) /* \_SB_.PCI0.PDRC._CRS.XBR0 */ | |
CreateDWordField (BUF0, \_SB.PCI0.PDRC._Y16._LEN, XSZ0) // _LEN: Length | |
ShiftRight (0x10000000, PXSZ, XSZ0) /* \_SB_.PCI0.PDRC._CRS.XSZ0 */ | |
Return (BUF0) /* \_SB_.PCI0.PDRC.BUF0 */ | |
} | |
} | |
} | |
Device (_SB.PCI0.LPCB.TPM) | |
{ | |
Name (_STR, Unicode ("TPM 1.2 Device")) // _STR: Description String | |
Name (_UID, One) // _UID: Unique ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFED40000, // Address Base | |
0x00005000, // Address Length | |
) | |
}) | |
OperationRegion (TMMB, SystemMemory, 0xFED40000, 0x5000) | |
Field (TMMB, ByteAcc, Lock, Preserve) | |
{ | |
ACCS, 8, | |
Offset (0x18), | |
TSTA, 8, | |
TBCA, 8, | |
Offset (0xF00), | |
TVID, 16, | |
TDID, 16 | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (LEqual (VIDT, 0x8086)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
If (TPMF) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Scope (_SB.PCI0.LPCB.TPM) | |
{ | |
OperationRegion (TSMI, SystemIO, SMIT, 0x02) | |
Field (TSMI, ByteAcc, NoLock, Preserve) | |
{ | |
INQ, 8, | |
DAT, 8 | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (LEqual (Arg0, ToUUID ("3dddfaa6-361b-4eb4-a424-8d10089d1653") /* Physical Presence Interface */)) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (Arg2), _T_0) /* \_SB_.PCI0.LPCB.TPM_._DSM._T_0 */ | |
If (LEqual (_T_0, Zero)) | |
{ | |
Return (Buffer (0x02) | |
{ | |
0xFF, 0x01 /* .. */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Return ("1.2") | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
Store (0x12, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Store (TMF2, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If (LEqual (DAT, 0xF1)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03)) | |
{ | |
Name (PPI1, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
Store (0x11, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (One) | |
} | |
Store (DAT, Index (PPI1, One)) | |
Return (PPI1) /* \_SB_.PCI0.LPCB.TPM_._DSM.PPI1 */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x04)) | |
{ | |
Return (TRST) /* \TRST */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x05)) | |
{ | |
Name (PPI2, Package (0x03) | |
{ | |
Zero, | |
Zero, | |
Zero | |
}) | |
Store (0x21, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
Store (DAT, Index (PPI2, One)) | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Store (0x31, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If (LEqual (DAT, 0xF0)) | |
{ | |
Store (0x51, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Store (0xFFFFFFF0, Index (PPI2, 0x02)) | |
Return (PPI2) /* \_SB_.PCI0.LPCB.TPM_._DSM.PPI2 */ | |
} | |
} | |
Else | |
{ | |
If (LEqual (DAT, 0xF1)) | |
{ | |
Store (0x51, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Store (0xFFFFFFF1, Index (PPI2, 0x02)) | |
Return (PPI2) /* \_SB_.PCI0.LPCB.TPM_._DSM.PPI2 */ | |
} | |
} | |
Else | |
{ | |
Store (DAT, Index (PPI2, 0x02)) | |
} | |
} | |
Return (PPI2) /* \_SB_.PCI0.LPCB.TPM_._DSM.PPI2 */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x06)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x07)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
Store (0x12, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Store (TMF2, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If (LEqual (DAT, 0xF1)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x08)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
Store (0x43, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
Store (TMF2, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
Return (DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
} | |
Else | |
{ | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
Else | |
{ | |
If (LEqual (Arg0, ToUUID ("376054ed-cc13-4675-901c-4756d7f2d45d"))) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (Arg2), _T_1) /* \_SB_.PCI0.LPCB.TPM_._DSM._T_1 */ | |
If (LEqual (_T_1, Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, One)) | |
{ | |
Store (0x22, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.LPCB.TPM_.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.LPCB.TPM_.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
} | |
} | |
Break | |
} | |
} | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
OperationRegion (ITPD, PCI_Config, 0xE8, 0x04) | |
Field (ITPD, DWordAcc, NoLock, Preserve) | |
{ | |
, 15, | |
TPDI, 1 | |
} | |
OperationRegion (TVID, SystemMemory, 0xFED40F00, 0x02) | |
Field (TVID, WordAcc, NoLock, Preserve) | |
{ | |
VIDT, 16 | |
} | |
} | |
Device (_SB.PCI0.ITPM) | |
{ | |
Name (_HID, "INTC0102") // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP0C31")) // _CID: Compatible ID | |
Name (_STR, Unicode ("TPM 1.2 Device")) // _STR: Description String | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFED40000, // Address Base | |
0x00005000, // Address Length | |
) | |
}) | |
OperationRegion (TSMI, SystemIO, SMIT, 0x02) | |
Field (TSMI, ByteAcc, NoLock, Preserve) | |
{ | |
INQ, 8, | |
DAT, 8 | |
} | |
OperationRegion (TPMR, SystemMemory, 0xFED40000, 0x5000) | |
Field (TPMR, AnyAcc, NoLock, Preserve) | |
{ | |
ACC0, 8 | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (LNotEqual (ACC0, 0xFF)) | |
{ | |
If (LEqual (VIDT, 0x8086)) | |
{ | |
If (TPMF) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Return (Zero) | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
Name (_T_1, Zero) // _T_x: Emitted by ASL Compiler | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (LEqual (Arg0, ToUUID ("3dddfaa6-361b-4eb4-a424-8d10089d1653") /* Physical Presence Interface */)) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (Arg2), _T_0) /* \_SB_.PCI0.ITPM._DSM._T_0 */ | |
If (LEqual (_T_0, Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x7F /* . */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Return ("1.0") | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
Store (0x12, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Store (TMF2, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x03)) | |
{ | |
Name (PPI1, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
Store (0x11, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (One) | |
} | |
Store (DAT, Index (PPI1, One)) | |
Return (PPI1) /* \_SB_.PCI0.ITPM._DSM.PPI1 */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x04)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x05)) | |
{ | |
Name (PPI2, Package (0x03) | |
{ | |
Zero, | |
Zero, | |
Zero | |
}) | |
Store (0x21, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
Store (DAT, Index (PPI2, One)) | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Store (DAT, Index (PPI2, One)) | |
Store (0x31, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If (LEqual (DAT, 0xFFF0)) | |
{ | |
Store (0xFFFFFFF0, Index (PPI2, 0x02)) | |
} | |
Else | |
{ | |
If (LEqual (DAT, 0xFFF1)) | |
{ | |
Store (0xFFFFFFF1, Index (PPI2, 0x02)) | |
} | |
Else | |
{ | |
Store (DAT, Index (PPI2, 0x02)) | |
} | |
} | |
Return (PPI2) /* \_SB_.PCI0.ITPM._DSM.PPI2 */ | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x06)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
Else | |
{ | |
If (LEqual (Arg0, ToUUID ("376054ed-cc13-4675-901c-4756d7f2d45d"))) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (Arg2), _T_1) /* \_SB_.PCI0.ITPM._DSM._T_1 */ | |
If (LEqual (_T_1, Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
If (LEqual (_T_1, One)) | |
{ | |
Store (0x22, TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF1) /* \TMF1 */ | |
Store (TMF1, DAT) /* \_SB_.PCI0.ITPM.DAT_ */ | |
Store (OFST, INQ) /* \_SB_.PCI0.ITPM.INQ_ */ | |
If (LEqual (DAT, 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
} | |
} | |
Break | |
} | |
} | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Scope (_SB.PCI0.LPCB) | |
{ | |
Device (EC0) | |
{ | |
Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
IO (Decode16, | |
0x0062, // Range Minimum | |
0x0062, // Range Maximum | |
0x00, // Alignment | |
0x01, // Length | |
) | |
IO (Decode16, | |
0x0066, // Range Minimum | |
0x0066, // Range Maximum | |
0x00, // Alignment | |
0x01, // Length | |
) | |
}) | |
Name (_GPE, 0x19) // _GPE: General Purpose Events | |
Mutex (MUEC, 0x00) | |
Mutex (MU4T, 0x00) | |
Name (ECFL, Ones) | |
Method (ECAV, 0, NotSerialized) | |
{ | |
If (LGreaterEqual (SLPT, 0x04)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (NVLK, One)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (ECFL, Ones)) | |
{ | |
If (LGreaterEqual (_REV, 0x02)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
Return (ECFL) /* \_SB_.PCI0.LPCB.EC0_.ECFL */ | |
} | |
OperationRegion (PECO, SystemIO, 0x0260, 0x08) | |
Field (PECO, ByteAcc, Lock, Preserve) | |
{ | |
HSTS, 8, | |
HCTL, 8, | |
HCMD, 8, | |
HTAR, 8, | |
HWLR, 8, | |
HRLR, 8, | |
HWDR, 8, | |
HRDR, 8 | |
} | |
Method (PECI, 7, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
While (LEqual (And (PBSY, 0x02), 0x02)) | |
{ | |
If (LGreater (Arg6, 0x1000)) | |
{ | |
Return (Zero) | |
} | |
Add (Arg6, One, Arg6) | |
Sleep (0x0A) | |
} | |
And (PBSY, 0xFD, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Store (Arg0, HTAR) /* \_SB_.PCI0.LPCB.EC0_.HTAR */ | |
Store (Arg1, HWLR) /* \_SB_.PCI0.LPCB.EC0_.HWLR */ | |
Store (Arg2, HRLR) /* \_SB_.PCI0.LPCB.EC0_.HRLR */ | |
Store (Arg3, HCMD) /* \_SB_.PCI0.LPCB.EC0_.HCMD */ | |
Name (TEMP, Zero) | |
Store (Zero, TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
If (LNotEqual (Arg1, Zero)) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (HCMD), _T_0) /* \_SB_.PCI0.LPCB.EC0_.PECI._T_0 */ | |
If (LEqual (_T_0, 0xF7)) | |
{ | |
Store (Zero, TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Store (Zero, TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x02)) | |
{ | |
Store (Zero, TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xA1)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xA2)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xB1)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xB2)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x61)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x62)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xE1)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xE2)) | |
{ | |
Store (Subtract (Arg1, One), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xA5)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xA6)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xB5)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xB6)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x65)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x66)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xE5)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0xE6)) | |
{ | |
Or (HCTL, 0x40, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Store (Subtract (Arg1, 0x02), TEMP) /* \_SB_.PCI0.LPCB.EC0_.PECI.TEMP */ | |
Break | |
} | |
Else | |
{ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
If (LGreater (TEMP, Zero)) | |
{ | |
Store (Zero, Local0) | |
While (LLess (Local0, TEMP)) | |
{ | |
Store (DerefOf (Index (Arg4, Local0)), HWDR) /* \_SB_.PCI0.LPCB.EC0_.HWDR */ | |
Add (Local0, One, Local0) | |
} | |
} | |
Or (HCTL, One, HCTL) /* \_SB_.PCI0.LPCB.EC0_.HCTL */ | |
Name (TIME, 0x5000) | |
Store (Zero, Local0) | |
While (LLess (Local0, TIME)) | |
{ | |
If (And (HSTS, 0x80)) | |
{ | |
Store (0x80, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
If (And (HSTS, 0x40)) | |
{ | |
Store (0x40, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
If (And (HSTS, 0x20)) | |
{ | |
Store (0x20, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
If (And (HSTS, 0x08)) | |
{ | |
Store (0x08, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
If (And (HSTS, 0x04)) | |
{ | |
Store (0x04, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
If (And (HSTS, 0x02)) | |
{ | |
Store (0x02, HSTS) /* \_SB_.PCI0.LPCB.EC0_.HSTS */ | |
Break | |
} | |
} | |
If (LEqual (Local0, TIME)) | |
{ | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (Zero) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
While (LLess (Local0, HRLR)) | |
{ | |
Store (HRDR, Local1) | |
Store (Local1, Index (Arg5, Local0)) | |
Add (Local0, One, Local0) | |
} | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
Return (One) | |
} | |
And (PBSY, 0xFE, PBSY) /* \_SB_.PCI0.LPCB.EC0_.PBSY */ | |
} | |
OperationRegion (ECOR, EmbeddedControl, Zero, 0xFF) | |
Field (ECOR, ByteAcc, Lock, Preserve) | |
{ | |
Offset (0x04), | |
CMD1, 8, | |
CDT1, 8, | |
CDT2, 8, | |
CDT3, 8, | |
Offset (0x80), | |
Offset (0x81), | |
Offset (0x82), | |
Offset (0x83), | |
EB0R, 8, | |
EB1R, 8, | |
EPWF, 8, | |
Offset (0x87), | |
Offset (0x88), | |
Offset (0x89), | |
Offset (0x8A), | |
HKEN, 1, | |
Offset (0x93), | |
TAH0, 16, | |
TAH1, 16, | |
TSTP, 8, | |
Offset (0x9C), | |
CDT4, 8, | |
CDT5, 8, | |
Offset (0xA0), | |
Offset (0xA1), | |
Offset (0xA2), | |
Offset (0xA3), | |
EACT, 8, | |
TH1R, 8, | |
TH1L, 8, | |
TH0R, 8, | |
TH0L, 8, | |
Offset (0xB0), | |
B0PN, 16, | |
Offset (0xB4), | |
Offset (0xB6), | |
Offset (0xB8), | |
Offset (0xBA), | |
Offset (0xBC), | |
Offset (0xBE), | |
B0TM, 16, | |
B0C1, 16, | |
B0C2, 16, | |
B0C3, 16, | |
B0C4, 16, | |
Offset (0xD0), | |
B1PN, 16, | |
Offset (0xD4), | |
Offset (0xD6), | |
Offset (0xD8), | |
Offset (0xDA), | |
Offset (0xDC), | |
Offset (0xDE), | |
B1TM, 16, | |
B1C1, 16, | |
B1C2, 16, | |
B1C3, 16, | |
B1C4, 16, | |
Offset (0xF0), | |
Offset (0xF2), | |
Offset (0xF4), | |
B0SN, 16, | |
Offset (0xF8), | |
Offset (0xFA), | |
Offset (0xFC), | |
B1SN, 16 | |
} | |
Name (SMBF, Zero) | |
OperationRegion (SMBX, EmbeddedControl, 0x18, 0x28) | |
Field (SMBX, ByteAcc, NoLock, Preserve) | |
{ | |
PRTC, 8, | |
SSTS, 5, | |
, 1, | |
ALFG, 1, | |
CDFG, 1, | |
ADDR, 8, | |
CMDB, 8, | |
BDAT, 256, | |
BCNT, 8, | |
, 1, | |
ALAD, 7, | |
ALD0, 8, | |
ALD1, 8 | |
} | |
OperationRegion (SMB2, EmbeddedControl, 0x40, 0x28) | |
Field (SMB2, ByteAcc, NoLock, Preserve) | |
{ | |
PRT2, 8, | |
SST2, 5, | |
, 1, | |
ALF2, 1, | |
CDF2, 1, | |
ADD2, 8, | |
CMD2, 8, | |
BDA2, 256, | |
BCN2, 8, | |
, 1, | |
ALA2, 7, | |
ALR0, 8, | |
ALR1, 8 | |
} | |
Field (SMB2, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
DA20, 8, | |
DA21, 8 | |
} | |
Field (SMBX, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
DAT0, 8, | |
DAT1, 8 | |
} | |
Field (SMBX, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
DT2B, 16 | |
} | |
OperationRegion (NSBS, EmbeddedControl, 0x40, 0x04) | |
Field (NSBS, ByteAcc, NoLock, Preserve) | |
{ | |
A2AD, 8, | |
A2D0, 8, | |
A2D1, 8, | |
A3AD, 8 | |
} | |
OperationRegion (BRAM, SystemIO, 0x025A, 0x02) | |
Field (BRAM, ByteAcc, Lock, Preserve) | |
{ | |
BRAI, 8, | |
BRAD, 8 | |
} | |
IndexField (BRAI, BRAD, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x8F), | |
PBSY, 8, | |
EPWS, 8, | |
EB0S, 8, | |
EB1S, 8, | |
EB0T, 8, | |
EB1T, 8, | |
Offset (0x98), | |
ECPU, 8, | |
ECRT, 8, | |
EPSV, 8, | |
Offset (0xA0), | |
B0VL, 16, | |
B0RC, 16, | |
B0FC, 16, | |
B0MD, 16, | |
B0ST, 16, | |
B0CC, 16, | |
B0DC, 16, | |
B0DV, 16, | |
B1VL, 16, | |
B1RC, 16, | |
B1FC, 16, | |
B1MD, 16, | |
B1ST, 16, | |
B1CC, 16, | |
B1DC, 16, | |
B1DV, 16 | |
} | |
Method (_INI, 0, NotSerialized) // _INI: Initialize | |
{ | |
If (LLessEqual (MSOS (), OSME)) | |
{ | |
Store (One, ECFL) /* \_SB_.PCI0.LPCB.EC0_.ECFL */ | |
} | |
} | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Store (Arg1, ECFL) /* \_SB_.PCI0.LPCB.EC0_.ECFL */ | |
} | |
} | |
} | |
} | |
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) | |
{ | |
Store (Arg0, SMCM) /* \SMCM */ | |
} | |
Method (ASMI, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.ALPR) | |
Store (0xA3, SMCM) /* \SMCM */ | |
Return (\_SB.ALPR) | |
} | |
Scope (_SB) | |
{ | |
OperationRegion (ECMS, SystemIO, 0x72, 0x02) | |
Field (ECMS, ByteAcc, Lock, Preserve) | |
{ | |
EIND, 8, | |
EDAT, 8 | |
} | |
IndexField (EIND, EDAT, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x40), | |
IKFG, 8, | |
Offset (0x43), | |
RAMB, 32, | |
AVOL, 8, | |
LBTN, 8, | |
ERRF, 8, | |
OCLK, 8, | |
WIDE, 1, | |
OVCK, 2, | |
SLPN, 3, | |
ACRD, 1, | |
VGAS, 1, | |
CPUR, 6, | |
CPUF, 2, | |
LBT2, 8, | |
PCMS, 8, | |
ALSL, 8, | |
ALAE, 1, | |
ALDE, 1, | |
ALSP, 1, | |
, 1, | |
FSTG, 4, | |
WLDP, 1, | |
BTDP, 1, | |
WRST, 1, | |
BRST, 1, | |
WRPS, 1, | |
BRPS, 1, | |
Offset (0x52), | |
SYNA, 1, | |
ALPS, 1, | |
ELAN, 1, | |
STLC, 1, | |
Offset (0x53), | |
IKF2, 8, | |
UHDB, 8, | |
OSPM, 8, | |
TCGF, 8, | |
PPIS, 8, | |
PPIR, 8, | |
SIDE, 1, | |
PWBS, 1, | |
WFFG, 1, | |
OCST, 3, | |
SMTT, 1, | |
Offset (0x5A), | |
SP80, 1, | |
Offset (0x5B), | |
SWD2, 1, | |
F9KP, 1, | |
HACF, 6, | |
UWDP, 1, | |
WMDP, 1, | |
GPDP, 1, | |
TGDP, 1, | |
UWST, 1, | |
WMST, 1, | |
GPST, 1, | |
TGST, 1, | |
UWPS, 1, | |
WMPS, 1, | |
GPPS, 1, | |
TGPS, 1, | |
Offset (0x5E), | |
SPDC, 8, | |
DROK, 1, | |
SPDG, 1, | |
Offset (0x60), | |
KBLV, 8, | |
FVGA, 1, | |
P4HN, 1, | |
USSC, 1, | |
MFTM, 1, | |
APBM, 4, | |
EGCP, 8, | |
EGC2, 2, | |
Offset (0x64), | |
VHDA, 1, | |
DP3S, 1, | |
LTCL, 2, | |
LOLK, 2, | |
U3WA, 2, | |
GSDT, 1, | |
Offset (0x66), | |
PA3D, 1, | |
, 3, | |
TCCA, 4, | |
S4TF, 1, | |
BECF, 1, | |
MMOD, 4, | |
Offset (0x68) | |
} | |
OperationRegion (RAMW, SystemMemory, RAMB, 0x0100) | |
Field (RAMW, AnyAcc, NoLock, Preserve) | |
{ | |
TRTY, 8, | |
FSFN, 8, | |
FSTA, 16, | |
FADR, 32, | |
FSIZ, 16, | |
ACTD, 8, | |
AVLD, 8, | |
SETD, 8, | |
ACPF, 8, | |
DCPF, 8, | |
DCP2, 8, | |
DCTP, 8, | |
CTPY, 8, | |
OPAD, 16, | |
OCAD, 16, | |
CSTE, 16, | |
NSTE, 16, | |
SSTE, 16, | |
SFUN, 8, | |
TPSV, 8, | |
TAC0, 8, | |
TCRT, 8, | |
TDO1, 8, | |
TDO2, 8, | |
PPSV, 8, | |
PAC0, 8, | |
T0HL, 8, | |
T0LL, 8, | |
T0F1, 8, | |
T0F2, 8, | |
T1HL, 8, | |
T1LL, 8, | |
T1F1, 8, | |
T1F2, 8, | |
T2HL, 8, | |
T2LL, 8, | |
T2F1, 8, | |
T2F2, 8, | |
T3HL, 8, | |
T3LL, 8, | |
T3F1, 8, | |
T3F2, 8, | |
T4HL, 8, | |
T4LL, 8, | |
T4F1, 8, | |
T4F2, 8, | |
T5HL, 8, | |
T5LL, 8, | |
T5F1, 8, | |
T5F2, 8, | |
T6HL, 8, | |
T6LL, 8, | |
T6F1, 8, | |
T6F2, 8, | |
T7HL, 8, | |
T7LL, 8, | |
T7F1, 8, | |
T7F2, 8, | |
SLPT, 8, | |
AIBF, 8, | |
IDES, 8, | |
VGAF, 16, | |
C4CP, 8, | |
LUXS, 8, | |
LUXL, 8, | |
LUXH, 8, | |
LUXF, 8, | |
MNAM, 64, | |
LCDV, 32, | |
LCDR, 8, | |
PTIM, 8, | |
PTMP, 8, | |
SMIF, 8, | |
DTSE, 8, | |
DTS1, 8, | |
DTS2, 8, | |
MPEN, 8, | |
QFAN, 8, | |
VBIF, 16, | |
BIPA, 32, | |
RTCW, 16, | |
CPUN, 8, | |
ALPR, 32, | |
CIST, 8, | |
GNBF, 32, | |
CPUP, 16, | |
SLMT, 16, | |
LDES, 8, | |
HDDF, 8, | |
GCDF, 16, | |
SMBB, 32, | |
FEBL, 32, | |
TMPB, 8, | |
DSYN, 8, | |
LDFT, 8, | |
TBOT, 16, | |
RTC1, 8, | |
RTC2, 8, | |
RTC3, 8, | |
BRTI, 8, | |
SGEN, 8, | |
RBUF, 32, | |
RVBS, 32, | |
EXTS, 8, | |
USBT, 8, | |
SCMA, 32, | |
CTBO, 8, | |
DOSF, 8, | |
PTAB, 32, | |
CPCH, 32, | |
HTPT, 32, | |
CPUH, 8, | |
XHCB, 32, | |
USBC, 8, | |
VBOF, 16, | |
RSKY, 8, | |
WOLO, 8, | |
INSK, 8, | |
FPBA, 32, | |
FPTR, 32, | |
NVLK, 8, | |
NVLP, 64, | |
ACPI, 8, | |
NRS3, 16, | |
DPS3, 16, | |
S4FG, 8, | |
MODE, 8, | |
S4TM, 32, | |
EVET, 32, | |
PLBA, 64, | |
ALSA, 16, | |
LSTP, 8, | |
EZFU, 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 (OSXP, 0x10) | |
Name (OSEG, 0x20) | |
Name (OSVT, 0x40) | |
Name (OSW7, 0x80) | |
Name (OSW8, 0x0100) | |
Method (MCTH, 2, NotSerialized) | |
{ | |
If (LLess (SizeOf (Arg0), SizeOf (Arg1))) | |
{ | |
Return (Zero) | |
} | |
Add (SizeOf (Arg0), One, Local0) | |
Name (BUF0, Buffer (Local0) {}) | |
Name (BUF1, Buffer (Local0) {}) | |
Store (Arg0, BUF0) /* \MCTH.BUF0 */ | |
Store (Arg1, BUF1) /* \MCTH.BUF1 */ | |
While (Local0) | |
{ | |
Decrement (Local0) | |
If (LNotEqual (DerefOf (Index (BUF0, Local0)), DerefOf (Index ( | |
BUF1, Local0)))) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
Method (MSOS, 0, NotSerialized) | |
{ | |
If (LNotEqual (OSFG, Zero)) | |
{ | |
Return (OSFG) /* \OSFG */ | |
} | |
If (CondRefOf (\_OSI, Local0)) | |
{ | |
If (_OSI ("Windows 2001")) | |
{ | |
Store (OSXP, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2001 SP1")) | |
{ | |
Store (OSXP, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2001 SP2")) | |
{ | |
Store (OSXP, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2006")) | |
{ | |
Store (OSVT, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Linux")) | |
{ | |
Store (OSEG, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2009")) | |
{ | |
Store (OSW7, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2009 SP1")) | |
{ | |
Store (OSW7, OSFG) /* \OSFG */ | |
} | |
If (_OSI ("Windows 2012")) | |
{ | |
Store (OSW8, OSFG) /* \OSFG */ | |
} | |
Return (OSFG) /* \OSFG */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft Windows")) | |
{ | |
Store (OS98, OSFG) /* \OSFG */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft WindowsME: Millennium Edition")) | |
{ | |
Store (OSME, OSFG) /* \OSFG */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft Windows NT")) | |
{ | |
Store (OS2K, OSFG) /* \OSFG */ | |
} | |
Else | |
{ | |
Store (OSXP, OSFG) /* \OSFG */ | |
} | |
} | |
} | |
} | |
Return (OSFG) /* \OSFG */ | |
} | |
Name (ONAM, "ASUSTeK") | |
Method (ADVG, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
Return (\_SB.PCI0.GFX0.ADVD ()) | |
} | |
If (\_SB.PCI0.PEG0.PEGP.PRST ()) | |
{ | |
Return (\_SB.PCI0.PEG0.PEGP.ADVD ()) | |
} | |
Return (0x03) | |
} | |
Method (GCDM, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
Return (\_SB.PCI0.GFX0.GCDS ()) | |
} | |
If (\_SB.PCI0.PEG0.PEGP.PRST ()) | |
{ | |
Return (\_SB.PCI0.PEG0.PEGP.GCDS ()) | |
} | |
Return (One) | |
} | |
Method (SWHG, 1, Serialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
\_SB.PCI0.GFX0.SWHD (Arg0) | |
Return (One) | |
} | |
If (\_SB.PCI0.PEG0.PEGP.PRST ()) | |
{ | |
\_SB.PCI0.PEG0.PEGP.SWHD (Arg0) | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (NATK, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
Return (\_SB.PCI0.GFX0.NATK ()) | |
} | |
If (\_SB.PCI0.PEG0.PEGP.PRST ()) | |
{ | |
Return (\_SB.PCI0.PEG0.PEGP.NATK ()) | |
} | |
Return (One) | |
} | |
} | |
Scope (_SB) | |
{ | |
Name (ATKP, Zero) | |
Name (AITM, Zero) | |
Name (PLMD, Zero) | |
Name (MUTX, One) | |
Name (LEDS, Zero) | |
Name (PWKY, 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) | |
Method (IANQ, 1, Serialized) | |
{ | |
If (LGreaterEqual (AQNO, 0x10)) | |
{ | |
Store (0x64, Local0) | |
While (LAnd (Local0, LGreaterEqual (AQNO, 0x10))) | |
{ | |
Decrement (Local0) | |
Sleep (0x0A) | |
} | |
If (LAnd (LNot (Local0), LGreaterEqual (AQNO, 0x10))) | |
{ | |
Return (Zero) | |
} | |
} | |
Increment (AQTI) | |
And (AQTI, 0x0F, AQTI) /* \_SB_.ATKD.AQTI */ | |
Store (Arg0, Index (ATKQ, AQTI)) | |
Increment (AQNO) | |
Return (One) | |
} | |
Method (GANQ, 0, Serialized) | |
{ | |
If (AQNO) | |
{ | |
Decrement (AQNO) | |
Store (DerefOf (Index (ATKQ, AQHI)), Local0) | |
Increment (AQHI) | |
And (AQHI, 0x0F, AQHI) /* \_SB_.ATKD.AQHI */ | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
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 (WMNB, 3, NotSerialized) | |
{ | |
CreateDWordField (Arg2, Zero, IIA0) | |
CreateDWordField (Arg2, 0x04, IIA1) | |
And (Arg1, 0xFFFFFFFF, Local0) | |
If (LEqual (Local0, 0x54494E49)) | |
{ | |
INIT (IIA0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x53545342)) | |
{ | |
Return (BSTS ()) | |
} | |
If (LEqual (Local0, 0x4E554653)) | |
{ | |
Return (SFUN ()) | |
} | |
If (LEqual (Local0, 0x43455053)) | |
{ | |
Return (SPEC (IIA0)) | |
} | |
If (LEqual (Local0, 0x494E424B)) | |
{ | |
Return (KBNI ()) | |
} | |
If (LEqual (Local0, 0x5256534F)) | |
{ | |
OSVR (IIA0) | |
Return (Zero) | |
} | |
If (LEqual (Local0, 0x53545344)) | |
{ | |
If (LEqual (IIA0, 0x00020017)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (IIA0, 0x00060023)) | |
{ | |
Name (LASV, Zero) | |
If (LEqual (NVLK, One)) | |
{ | |
Return (LASV) /* \_SB_.ATKD.WMNB.LASV */ | |
} | |
Store (Zero, Local0) | |
Store (0xFFFF, FSTA) /* \_SB_.FSTA */ | |
Store (0x55534243, FADR) /* \_SB_.FADR */ | |
FSMI (0x05) | |
If (LEqual (FSTA, 0x02)) | |
{ | |
Store (USBC, Local0) | |
} | |
If (Ones) | |
{ | |
Or (0x04, Local0, Local0) | |
} | |
Store (Local0, LASV) /* \_SB_.ATKD.WMNB.LASV */ | |
Return (Local0) | |
} | |
If (LEqual (IIA0, 0x00060024)) | |
{ | |
Return (Package (0x03) | |
{ | |
0x1E318086, | |
One, | |
0xFFFFFFFF | |
}) | |
} | |
If (LEqual (IIA0, 0x00010002)) | |
{ | |
Return (0x00050002) | |
} | |
If (LEqual (IIA0, 0x00020011)) | |
{ | |
Return (Or (GALE (One), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00020012)) | |
{ | |
Return (Or (GALE (0x02), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00020013)) | |
{ | |
Return (Or (GALE (0x04), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00040015)) | |
{ | |
Return (Or (GALE (0x08), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00020014)) | |
{ | |
Return (Or (GALE (0x10), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00020015)) | |
{ | |
Return (Or (GALE (0x20), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00020016)) | |
{ | |
Return (Or (GALE (0x40), 0x00050000)) | |
} | |
If (LEqual (IIA0, 0x00110011)) | |
{ | |
Return (And (TMPR (), 0xFFFF)) | |
} | |
If (LEqual (IIA0, 0x00110012)) | |
{ | |
Store (TMPR (), Local0) | |
Store (Local0, Local1) | |
ShiftRight (And (Local0, 0xF0000000), 0x1C, Local0) | |
ShiftRight (And (Local1, 0x0F000000), 0x18, Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
Return (Add (Local0, Local1)) | |
} | |
If (LEqual (IIA0, 0x00050012)) | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
Subtract (0x64, Zero, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (Local0, 0x64, Local1) | |
} | |
Else | |
{ | |
Store (0x0A, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Store (Add (GPLV (), Local0), Local1) | |
} | |
Return (Local1) | |
} | |
If (LEqual (IIA0, 0x00050001)) | |
{ | |
If (LNot (ALSP)) | |
{ | |
Return (0x02) | |
} | |
And (GALS (), 0x10, Local0) | |
If (Local0) | |
{ | |
Return (0x00050001) | |
} | |
Else | |
{ | |
Return (0x00050000) | |
} | |
} | |
If (LEqual (IIA0, 0x00050013)) | |
{ | |
And (GALS (), 0x0F0F, Local0) | |
Return (Local0) | |
} | |
If (LEqual (IIA0, 0x00010011)) | |
{ | |
If (WLDP) | |
{ | |
Return (Add (WRST, 0x00030000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010013)) | |
{ | |
If (BTDP) | |
{ | |
Return (Add (BRST, 0x00050000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010021)) | |
{ | |
If (UWDP) | |
{ | |
Return (Add (UWST, 0x00050000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010017)) | |
{ | |
If (WMDP) | |
{ | |
Return (Add (WMST, 0x00050000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010015)) | |
{ | |
If (GPDP) | |
{ | |
Return (Add (GPST, 0x00050000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010019)) | |
{ | |
If (TGDP) | |
{ | |
Return (Add (TGST, 0x00050000)) | |
} | |
} | |
If (LEqual (IIA0, 0x00010001)) | |
{ | |
Return (0x00040000) | |
} | |
If (LEqual (IIA0, 0x00120012)) | |
{ | |
Return (PSTC (Zero)) | |
} | |
If (LEqual (IIA0, 0x00120015)) | |
{ | |
Subtract (SLMT, One, Local0) | |
Return (Or (Local0, 0x00010000)) | |
} | |
If (LEqual (IIA0, 0x00050021)) | |
{ | |
If (GLKB (One)) | |
{ | |
Store (GLKB (0x03), Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (GLKB (0x02), Local0, Local0) | |
Or (Local0, 0x00050000, Local0) | |
Return (Local0) | |
} | |
Return (0x8000) | |
} | |
If (LEqual (IIA0, 0x00120031)) | |
{ | |
If (DP3S) | |
{ | |
Return (0x00010001) | |
} | |
Else | |
{ | |
Return (0x00010000) | |
} | |
} | |
If (LEqual (IIA0, 0x00120032)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (IIA0, 0x00120037)) | |
{ | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00120038)) | |
{ | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00120041)) | |
{ | |
Store (^^PCI0.LPCB.EC0.ST8E (0x16, Zero), Local0) | |
Store (^^PCI0.LPCB.EC0.ST8E (0x17, Zero), Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
If (LEqual (And (Local1, 0x8000), 0x8000)) | |
{ | |
Return (Add (Local1, Local0)) | |
} | |
Else | |
{ | |
Subtract (0x00010000, 0x22, Local2) | |
And (Local2, 0xFFFF, Local2) | |
Return (Local2) | |
} | |
} | |
If (LEqual (IIA0, 0x00120042)) | |
{ | |
Store (^^PCI0.LPCB.EC0.ST8E (0x18, Zero), Local0) | |
Store (^^PCI0.LPCB.EC0.ST8E (0x19, Zero), Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
If (LEqual (And (Local1, 0x8000), 0x8000)) | |
{ | |
Return (Add (Local1, Local0)) | |
} | |
Else | |
{ | |
Subtract (0x00010000, 0x13, Local2) | |
And (Local2, 0xFFFF, Local2) | |
Return (Local2) | |
} | |
} | |
If (LEqual (IIA0, 0x00120043)) | |
{ | |
Store (^^PCI0.LPCB.EC0.BIFW (0x13), Local0) | |
Return (Local0) | |
} | |
If (LEqual (IIA0, 0x00120044)) | |
{ | |
If (And (^^PCI0.LPCB.EC0.EPWS, 0x06)) | |
{ | |
And (^^PCI0.LPCB.EC0.EPWS, 0x06, Local0) | |
Store (Zero, Local1) | |
If (LEqual (Local0, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B0RC, Local1) | |
} | |
Else | |
{ | |
If (LEqual (Local0, 0x04)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B1RC, Local1) | |
} | |
Else | |
{ | |
Store (Add (^^PCI0.LPCB.EC0.B0RC, ^^PCI0.LPCB.EC0.B1RC), Local1) | |
} | |
} | |
Return (Add (Local1, 0x00010000)) | |
} | |
Return (0x0001FFFF) | |
} | |
If (LEqual (IIA0, 0x00120045)) | |
{ | |
If (And (^^PCI0.LPCB.EC0.EPWS, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.ST8E (0x24, Zero), Local0) | |
Store (^^PCI0.LPCB.EC0.ST8E (0x25, Zero), Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
Store (Add (Local1, Local0), Local2) | |
If (LEqual (Local2, Zero)) | |
{ | |
Store (0x1E02, Local2) | |
} | |
Return (Add (Local2, 0x00010000)) | |
} | |
Return (0x0001FFFF) | |
} | |
If (LEqual (IIA0, 0x00120046)) | |
{ | |
If (And (^^PCI0.LPCB.EC0.EPWS, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.ST8E (0x26, Zero), Local0) | |
Store (^^PCI0.LPCB.EC0.ST8E (0x27, Zero), Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
Store (Add (Local1, Local0), Local2) | |
If (LEqual (Local2, Zero)) | |
{ | |
Store (0x1E50, Local2) | |
} | |
Return (Add (Local2, 0x00010000)) | |
} | |
Return (0x0001FFFF) | |
} | |
If (LEqual (IIA0, 0x00120047)) | |
{ | |
If (And (^^PCI0.LPCB.EC0.EPWS, 0x06)) | |
{ | |
Store (Zero, Local1) | |
If (LEqual (Local0, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B0DV, Local1) | |
} | |
Else | |
{ | |
If (LEqual (Local0, 0x04)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B1DV, Local1) | |
} | |
Else | |
{ | |
Store (Add (^^PCI0.LPCB.EC0.B0DV, ^^PCI0.LPCB.EC0.B1DV), Local1) | |
} | |
} | |
Return (Add (Local1, 0x00010000)) | |
} | |
Return (0x0001FFFF) | |
} | |
If (LEqual (IIA0, 0x00120049)) | |
{ | |
If (And (^^PCI0.LPCB.EC0.EPWS, 0x06)) | |
{ | |
Store (Zero, Local1) | |
If (LEqual (Local0, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B0FC, Local1) | |
} | |
Else | |
{ | |
If (LEqual (Local0, 0x04)) | |
{ | |
Store (^^PCI0.LPCB.EC0.B1FC, Local1) | |
} | |
Else | |
{ | |
Store (Add (^^PCI0.LPCB.EC0.B0FC, ^^PCI0.LPCB.EC0.B1FC), Local1) | |
} | |
} | |
Return (Add (Local1, 0x00010000)) | |
} | |
Return (0x0001FFFF) | |
} | |
If (LEqual (IIA0, 0x00080041)) | |
{ | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00080042)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (IIA0, 0x00080043)) | |
{ | |
Return (Zero) | |
} | |
If (LEqual (IIA0, 0x00080044)) | |
{ | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00120048)) | |
{ | |
Store (0x08, Local1) | |
Return (Add (Local1, 0x00010000)) | |
} | |
} | |
If (LEqual (Local0, 0x53564544)) | |
{ | |
If (LEqual (IIA0, 0x00020018)) | |
{ | |
If (LEqual (IIA1, One)) | |
{ | |
Or (EGC2, One, EGC2) /* \_SB_.EGC2 */ | |
Return (One) | |
} | |
If (LEqual (IIA1, 0x02)) | |
{ | |
Or (EGC2, 0x02, EGC2) /* \_SB_.EGC2 */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
If (LEqual (IIA0, 0x00060023)) | |
{ | |
If (LEqual (NVLK, One)) | |
{ | |
Return (Zero) | |
} | |
Store (Zero, Local0) | |
Store (0xFFFF, FSTA) /* \_SB_.FSTA */ | |
Store (0x55534243, FADR) /* \_SB_.FADR */ | |
FSMI (0x05) | |
ShiftRight (IIA1, 0x09, Local0) | |
If (LEqual (And (Local0, One), One)) | |
{ | |
Store (One, VBOF) /* \_SB_.VBOF */ | |
ShiftRight (IIA1, 0x18, Local0) | |
Multiply (Local0, 0x0100, Local0) | |
Or (Local0, VBOF, VBOF) /* \_SB_.VBOF */ | |
} | |
Else | |
{ | |
Store (Zero, VBOF) /* \_SB_.VBOF */ | |
} | |
And (IIA1, 0xFF, Local0) | |
^^PCI0.LPCB.EC0.STA9 (One, Local0) | |
ShiftRight (IIA1, 0x08, Local0) | |
Store (^^PCI0.LPCB.EC0.STA8 (Zero), Local1) | |
If (LEqual (And (Local0, One), One)) | |
{ | |
Store (One, USBC) /* \_SB_.USBC */ | |
Or (Local1, 0x02, Local1) | |
^^PCI0.LPCB.EC0.STA9 (Zero, Local1) | |
} | |
Else | |
{ | |
Store (Zero, USBC) /* \_SB_.USBC */ | |
And (Local1, 0xFD, Local1) | |
^^PCI0.LPCB.EC0.STA9 (Zero, Local1) | |
} | |
Store (0xFFFF, FSTA) /* \_SB_.FSTA */ | |
Store (0x55534243, FADR) /* \_SB_.FADR */ | |
FSMI (0x04) | |
If (LEqual (FSTA, 0x02)) | |
{ | |
Store (0xFFFF, FSTA) /* \_SB_.FSTA */ | |
FSMI (0x06) | |
If (LNotEqual (FSTA, Zero)) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00020011)) | |
{ | |
Return (SALE (Add (IIA1, 0x02))) | |
} | |
If (LEqual (IIA0, 0x00020012)) | |
{ | |
Return (SALE (Add (IIA1, 0x04))) | |
} | |
If (LEqual (IIA0, 0x00020013)) | |
{ | |
Return (SALE (Add (IIA1, 0x08))) | |
} | |
If (LEqual (IIA0, 0x00040015)) | |
{ | |
Return (SALE (Add (IIA1, 0x10))) | |
} | |
If (LEqual (IIA0, 0x00020014)) | |
{ | |
Return (SALE (Add (IIA1, 0x20))) | |
} | |
If (LEqual (IIA0, 0x00020015)) | |
{ | |
Return (SALE (Add (IIA1, 0x40))) | |
} | |
If (LEqual (IIA0, 0x00020016)) | |
{ | |
Return (SALE (Add (IIA1, 0x80))) | |
} | |
If (LEqual (IIA0, 0x00020021)) | |
{ | |
Return (SPRK (IIA1)) | |
} | |
If (LEqual (IIA0, 0x00050011)) | |
{ | |
If (LEqual (IIA1, 0x02)) | |
{ | |
^^PCI0.LPCB.EC0.SPIN (0x72, One) | |
Store (One, ^^PCI0.LPCB.EC0.BLCT) /* \_SB_.PCI0.LPCB.EC0_.BLCT */ | |
} | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00050012)) | |
{ | |
SPLV (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00050001)) | |
{ | |
Return (ALSC (IIA1)) | |
} | |
If (LEqual (IIA0, 0x00050013)) | |
{ | |
Return (ALSL (IIA1)) | |
} | |
If (LEqual (IIA0, 0x00010002)) | |
{ | |
OWGD (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010012)) | |
{ | |
WLED (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010013)) | |
{ | |
BLED (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010003)) | |
{ | |
Return (CWAP (IIA1)) | |
} | |
If (LEqual (IIA0, 0x00010015)) | |
{ | |
GPSC (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010019)) | |
{ | |
GSMC (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010017)) | |
{ | |
WMXC (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00010021)) | |
{ | |
UWBC (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00120012)) | |
{ | |
Return (PSTC (Add (IIA1, One))) | |
} | |
If (LEqual (IIA0, 0x00050021)) | |
{ | |
SLKB (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00120031)) | |
{ | |
DESP (IIA1) | |
Return (One) | |
} | |
If (LEqual (IIA0, 0x00120037)) | |
{ | |
Store (S4FG, Local0) | |
If (LEqual (IIA1, One)) | |
{ | |
Store (One, MODE) /* \_SB_.MODE */ | |
If (LEqual (Local0, Zero)) | |
{ | |
If (CondRefOf (\_SB.IFFS.FFSS)) | |
{ | |
Store (0x03, ^^IFFS.FFSS) /* External reference */ | |
} | |
} | |
Else | |
{ | |
Return (0x00010000) | |
} | |
} | |
Else | |
{ | |
Store (Zero, MODE) /* \_SB_.MODE */ | |
If (LEqual (Local0, Zero)) | |
{ | |
If (CondRefOf (\_SB.IFFS.FFSS)) | |
{ | |
Store (0x02, ^^IFFS.FFSS) /* External reference */ | |
} | |
} | |
Else | |
{ | |
Return (0x00010000) | |
} | |
} | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00120038)) | |
{ | |
Store (S4FG, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
If (CondRefOf (\_SB.IFFS.SFTV)) | |
{ | |
^^IFFS.SFTV (IIA1) | |
} | |
} | |
Store (IIA1, S4TM) /* \_SB_.S4TM */ | |
Return (0x00010000) | |
} | |
If (LEqual (IIA0, 0x00050017)) | |
{ | |
Store (One, ^^PCI0.LPCB.EC0.ORFG) /* \_SB_.PCI0.LPCB.EC0_.ORFG */ | |
Return (0x00010000) | |
} | |
} | |
If (LEqual (Local0, 0x48534C46)) | |
{ | |
FLSH (IIA0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x494E4946)) | |
{ | |
Return (FINI (IIA0)) | |
} | |
If (LEqual (Local0, 0x53524546)) | |
{ | |
Return (FERS (IIA0)) | |
} | |
If (LEqual (Local0, 0x49525746)) | |
{ | |
Return (FWRI (IIA0)) | |
} | |
If (LEqual (Local0, 0x57504346)) | |
{ | |
Return (FCPW (IIA0)) | |
} | |
If (LEqual (Local0, 0x50504346)) | |
{ | |
Return (FCPP ()) | |
} | |
If (LEqual (Local0, 0x50525746)) | |
{ | |
Return (FWRP ()) | |
} | |
If (LEqual (Local0, 0x52534345)) | |
{ | |
Return (ECSR (IIA0)) | |
} | |
If (LEqual (Local0, 0x43534C46)) | |
{ | |
Return (FLSC (IIA0)) | |
} | |
If (LEqual (Local0, 0x43455246)) | |
{ | |
Return (FREC (IIA0)) | |
} | |
If (LEqual (Local0, 0x454D4946)) | |
{ | |
Return (FIME (IIA0)) | |
} | |
If (LEqual (Local0, 0x4C425053)) | |
{ | |
If (LEqual (IIA0, 0x80)) | |
{ | |
If (LGreaterEqual (MSOS (), OSVT)) | |
{ | |
Return (Zero) | |
} | |
Return (One) | |
} | |
If (LGreater (IIA0, 0x0F)) | |
{ | |
Return (Zero) | |
} | |
If (LLess (IIA0, Zero)) | |
{ | |
Return (Zero) | |
} | |
SPLV (IIA0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x50534453)) | |
{ | |
SDSP (IIA0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x50534447)) | |
{ | |
Return (GDSP (IIA0)) | |
} | |
If (LEqual (Local0, 0x44495047)) | |
{ | |
Return (GPID ()) | |
} | |
If (LEqual (Local0, 0x44434C47)) | |
{ | |
Return (GLCD ()) | |
} | |
If (LEqual (Local0, 0x444F4D51)) | |
{ | |
Return (QMOD (IIA0)) | |
} | |
If (LEqual (Local0, 0x49564E41)) | |
{ | |
Return (ANVI (IIA0)) | |
} | |
If (LEqual (Local0, 0x46494243)) | |
{ | |
Return (CBIF (IIA0)) | |
} | |
If (LEqual (Local0, 0x4E464741)) | |
{ | |
Return (AGFN (IIA0)) | |
} | |
If (LEqual (Local0, 0x46494643)) | |
{ | |
CFIF (IIA0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x44495046)) | |
{ | |
Return (0x0118) | |
} | |
If (LEqual (Local0, 0x59454B48)) | |
{ | |
Store (^^PCI0.LPCB.EC0.CDT1, Local0) | |
Return (One) | |
} | |
If (LEqual (Local0, 0x5446424B)) | |
{ | |
Store (IIA0, ^^PCI0.LPCB.EC0.HKEN) /* \_SB_.PCI0.LPCB.EC0_.HKEN */ | |
Return (One) | |
} | |
Return (0xFFFFFFFE) | |
} | |
Method (_WED, 1, NotSerialized) // _Wxx: Wake Event | |
{ | |
If (LEqual (Arg0, 0xFF)) | |
{ | |
Return (GANQ ()) | |
} | |
Return (Ones) | |
} | |
Method (IANE, 1, Serialized) | |
{ | |
IANQ (Arg0) | |
Notify (ATKD, 0xFF) // Hardware-Specific | |
} | |
Method (INIT, 1, NotSerialized) | |
{ | |
Store (One, ATKP) /* \_SB_.ATKP */ | |
Return (MNAM) /* \_SB_.MNAM */ | |
} | |
Method (BSTS, 0, NotSerialized) | |
{ | |
Store (IKFG, Local0) | |
Or (Local0, ShiftLeft (IKF2, 0x08), Local0) | |
Store (^^PCI0.LPCB.EC0.RRAM (0x04FE), Local1) | |
Store (Zero, Local2) | |
If (LEqual (Local1, 0x35)) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x37)) | |
{ | |
Store (One, Local2) | |
} | |
} | |
If (LEqual (Local2, One)) | |
{ | |
If (S4TF) | |
{ | |
If (LEqual (MODE, One)) | |
{ | |
Store (0x08, Local1) | |
Return (Local1) | |
} | |
} | |
} | |
If (ACPF) | |
{ | |
Store (Zero, Local0) | |
Return (Local0) | |
} | |
Else | |
{ | |
Store (^^PCI0.LPCB.EC0.RRAM (0x04FE), Local0) | |
If (LEqual (And (Local0, 0xFF), 0x34)) | |
{ | |
Store (0x05, Local0) | |
Return (Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
Return (Local0) | |
} | |
} | |
And (Local0, 0xFFDF, Local0) | |
Return (Local0) | |
} | |
Method (TMPR, 0, NotSerialized) | |
{ | |
Store (\_TZ.RTMP (), Local0) | |
Store (\_TZ.RFAN (Zero), Local1) | |
ShiftLeft (Local1, 0x10, Local1) | |
Add (\_TZ.KELV (Local0), Local1, Local0) | |
Store (Zero, Local2) | |
If (TENA) | |
{ | |
Store (TDTY, Local2) | |
} | |
Else | |
{ | |
Store (HKTH (), Local3) | |
If (LNotEqual (Local3, 0xFFFF)) | |
{ | |
Store (Local3, Local2) | |
} | |
} | |
ShiftLeft (Local2, 0x18, Local2) | |
Add (Local0, Local2, Local0) | |
Store (\_TZ.RFSE (), Local3) | |
ShiftLeft (Local3, 0x1C, Local3) | |
Add (Local0, Local3, Local0) | |
Return (Local0) | |
} | |
Method (SFUN, 0, NotSerialized) | |
{ | |
Store (0x37, Local0) | |
Or (Local0, 0x40, Local0) | |
Or (Local0, 0x0800, Local0) | |
If (ALSP) | |
{ | |
Or (Local0, 0x2000, Local0) | |
} | |
Or (Local0, 0x00020000, Local0) | |
Or (Local0, 0x00080000, Local0) | |
Or (Local0, 0x00400000, Local0) | |
Return (Local0) | |
} | |
Method (SPEC, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Return (0x00070009) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
Return (One) | |
} | |
} | |
Return (0xFFFFFFFE) | |
} | |
Method (OSVR, 1, NotSerialized) | |
{ | |
If (LEqual (OSFG, Zero)) | |
{ | |
Store (Arg0, OSFG) /* \OSFG */ | |
} | |
} | |
Method (GPLV, 0, NotSerialized) | |
{ | |
Return (LBTN) /* \_SB_.LBTN */ | |
} | |
Method (SPLV, 1, NotSerialized) | |
{ | |
Store (Arg0, LBTN) /* \_SB_.LBTN */ | |
^^PCI0.LPCB.EC0.STBR () | |
Return (One) | |
} | |
Method (SPBL, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x0100)) | |
{ | |
Subtract (0x0B, One, Local0) | |
Return (Local0) | |
} | |
If (LEqual (Arg0, 0x80)) | |
{ | |
Return (One) | |
} | |
If (LGreater (Arg0, 0x0F)) | |
{ | |
Return (Zero) | |
} | |
If (LLess (Arg0, Zero)) | |
{ | |
Return (Zero) | |
} | |
SPLV (Arg0) | |
Return (One) | |
} | |
Method (WLED, 1, NotSerialized) | |
{ | |
OWLD (Arg0) | |
Return (One) | |
} | |
Method (DESP, 1, NotSerialized) | |
{ | |
ODSP (Arg0) | |
Return (One) | |
} | |
Method (KBNI, 0, NotSerialized) | |
{ | |
Return (One) | |
} | |
Method (GALE, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x04)) | |
{ | |
If (LAnd (LEDS, 0x04)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
If (LEqual (Arg0, 0x08)) | |
{ | |
If (LAnd (LEDS, 0x08)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
If (LEqual (Arg0, 0x10)) | |
{ | |
If (LAnd (LEDS, 0x10)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Return (0x02) | |
} | |
Method (SALE, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x10)) {} | |
If (LEqual (Arg0, 0x11)) {} | |
Return (One) | |
} | |
Method (GPRK, 0, NotSerialized) | |
{ | |
If (LEqual (PWKY, Zero)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
Method (SPRK, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (Zero, PWKY) /* \_SB_.PWKY */ | |
Return (One) | |
} | |
If (LEqual (Arg0, One)) | |
{ | |
Store (One, PWKY) /* \_SB_.PWKY */ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (BLED, 1, NotSerialized) | |
{ | |
OBTD (Arg0) | |
Return (One) | |
} | |
Method (UWBC, 1, NotSerialized) | |
{ | |
OUWD (Arg0) | |
Return (One) | |
} | |
Method (WMXC, 1, NotSerialized) | |
{ | |
OWMD (Arg0) | |
Return (One) | |
} | |
Method (GPSC, 1, NotSerialized) | |
{ | |
OGPD (Arg0) | |
Return (One) | |
} | |
Method (GSMC, 1, NotSerialized) | |
{ | |
OTGD (Arg0) | |
Return (One) | |
} | |
Method (RSTS, 0, NotSerialized) | |
{ | |
Return (ORST ()) | |
} | |
Method (SDSP, 1, NotSerialized) | |
{ | |
If (NATK ()) | |
{ | |
Return (SWHG (Arg0)) | |
} | |
Return (Zero) | |
} | |
Method (GPID, 0, NotSerialized) | |
{ | |
Return (LCDR) /* \_SB_.LCDR */ | |
} | |
Method (ALSC, 1, NotSerialized) | |
{ | |
If (Arg0) | |
{ | |
^^PCI0.LPCB.EC0.TALS (One) | |
Store (^^PCI0.LPCB.EC0.RALS (), Local0) | |
} | |
Else | |
{ | |
^^PCI0.LPCB.EC0.TALS (Zero) | |
Store (0x0190, Local0) | |
} | |
Store (Arg0, ALAE) /* \_SB_.ALAE */ | |
If (LEqual (MSOS (), OSW7)) | |
{ | |
^^PCI0.GFX0.AINT (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (MSOS (), OSW8)) | |
{ | |
Notify (ALS, 0x80) // Status Change | |
} | |
} | |
Return (One) | |
} | |
Method (ALSL, 1, NotSerialized) | |
{ | |
Return (One) | |
} | |
Method (GALS, 0, NotSerialized) | |
{ | |
And (LBTN, 0x0F, Local0) | |
Or (Local0, 0x20, Local0) | |
If (ALAE) | |
{ | |
Or (Local0, 0x10, Local0) | |
} | |
Subtract (0x0B, One, Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
Or (Local0, Local1, Local0) | |
Return (Local0) | |
} | |
Method (HWRS, 0, NotSerialized) | |
{ | |
Return (OHWR ()) | |
} | |
Method (GLCD, 0, NotSerialized) | |
{ | |
Return (LCDV) /* \_SB_.LCDV */ | |
} | |
Name (WAPF, Zero) | |
Method (CWAP, 1, NotSerialized) | |
{ | |
Or (Arg0, WAPF, WAPF) /* \_SB_.ATKD.WAPF */ | |
Return (One) | |
} | |
Method (QMOD, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Return (One) | |
} | |
If (LEqual (Arg0, One)) | |
{ | |
^^PCI0.LPCB.EC0.ST98 (QFAN) | |
} | |
If (LEqual (Arg0, 0x02)) | |
{ | |
^^PCI0.LPCB.EC0.ST98 (0xFF) | |
} | |
Return (One) | |
} | |
Method (ANVI, 1, Serialized) | |
{ | |
Store (ASMI (Arg0), Local0) | |
Return (Local0) | |
} | |
Method (PSTC, 1, Serialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (CPUP, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (CPUP, Local0, Local0) | |
Return (Local0) | |
} | |
If (LGreater (Arg0, CPUP)) | |
{ | |
Return (Ones) | |
} | |
Store (Arg0, SLMT) /* \_SB_.SLMT */ | |
If (CIST) | |
{ | |
Notify (\_PR.CPU0, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU1, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU2, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU3, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU4, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU5, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU6, 0x80) // Performance Capability Change | |
Notify (\_PR.CPU7, 0x80) // Performance Capability Change | |
} | |
Return (Zero) | |
} | |
Method (SMBB, 1, Serialized) | |
{ | |
ShiftRight (Arg0, 0x10, Local0) | |
And (Local0, 0xFF, Local0) | |
ShiftRight (Arg0, 0x18, Local1) | |
And (Arg0, 0xFF, Local2) | |
If (And (Local1, One)) | |
{ | |
Return (RBYT (Local1, Local0)) | |
} | |
Else | |
{ | |
Return (WBYT (Local1, Local0, Local2)) | |
} | |
} | |
Method (SMBW, 1, Serialized) | |
{ | |
ShiftRight (Arg0, 0x10, Local0) | |
And (Local0, 0xFF, Local0) | |
ShiftRight (Arg0, 0x18, Local1) | |
And (Arg0, 0xFF, Local2) | |
If (And (Local1, One)) | |
{ | |
Return (RWRD (Local1, Local0)) | |
} | |
Else | |
{ | |
Return (WWRD (Local1, Local0, Local2)) | |
} | |
} | |
Method (SMBK, 1, Serialized) | |
{ | |
ShiftRight (Arg0, 0x08, Local0) | |
And (Local0, 0xFF, Local0) | |
If (Local0) | |
{ | |
ShiftRight (Arg0, 0x10, Local0) | |
And (Local0, 0xFF, Local0) | |
ShiftRight (Arg0, 0x18, Local1) | |
And (Local1, 0xFF, Local1) | |
And (Arg0, 0x0F, Local3) | |
If (And (Local1, One)) | |
{ | |
RBLK (Local1, Local0, Local3) | |
} | |
Else | |
{ | |
WBLK (Local1, Local0, Local3) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
ShiftRight (Arg0, 0x10, Local2) | |
And (Local2, 0xFF, Local2) | |
ShiftRight (Arg0, 0x18, Local1) | |
If (And (Local1, One)) | |
{ | |
Return (DerefOf (Index (RBUF, Local2))) | |
} | |
Else | |
{ | |
And (Arg0, 0xFF, Local1) | |
Store (Local1, Index (RBUF, Local2)) | |
Return (Zero) | |
} | |
} | |
} | |
Method (ECRW, 1, Serialized) | |
{ | |
ShiftRight (Arg0, 0x18, Local0) | |
And (Local0, 0xFF, Local0) | |
ShiftRight (Arg0, 0x10, Local1) | |
And (Local1, 0xFF, Local1) | |
ShiftRight (Arg0, 0x08, Local2) | |
And (Local2, 0xFF, Local2) | |
And (Arg0, 0xFF, Local3) | |
Acquire (^^PCI0.LPCB.EC0.MUEC, 0xFFFF) | |
Store (Local0, ^^PCI0.LPCB.EC0.CDT3) /* \_SB_.PCI0.LPCB.EC0_.CDT3 */ | |
Store (Local1, ^^PCI0.LPCB.EC0.CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Local2, ^^PCI0.LPCB.EC0.CDT1) /* \_SB_.PCI0.LPCB.EC0_.CDT1 */ | |
Store (Local3, ^^PCI0.LPCB.EC0.CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x05, Local0) | |
While (LAnd (Local0, ^^PCI0.LPCB.EC0.CMD1)) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
Store (^^PCI0.LPCB.EC0.CDT3, Local0) | |
Store (^^PCI0.LPCB.EC0.CDT2, Local1) | |
Store (^^PCI0.LPCB.EC0.CDT1, Local2) | |
Store (^^PCI0.LPCB.EC0.CMD1, Local3) | |
Release (^^PCI0.LPCB.EC0.MUEC) | |
ShiftLeft (Local0, 0x08, Local0) | |
Or (Local0, Local1, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Or (Local0, Local2, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Or (Local0, Local3, Local0) | |
Return (Local0) | |
} | |
Method (CBIF, 1, Serialized) | |
{ | |
Store (Arg0, TMPB) /* \_SB_.TMPB */ | |
Store (0x03, ALPR) /* \_SB_.ALPR */ | |
ISMI (0xA3) | |
Return (One) | |
} | |
Method (CFIF, 1, Serialized) | |
{ | |
Store (Arg0, TMPB) /* \_SB_.TMPB */ | |
ISMI (0xA6) | |
Return (One) | |
} | |
Method (GLKB, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
Store (^^PCI0.LPCB.EC0.RRAM (0x0449), Local0) | |
And (Local0, 0x02, Local0) | |
If (Local0) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Return (KBLV) /* \_SB_.KBLV */ | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
If (ALAE) | |
{ | |
And (LSTP, One, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
Store (^^PCI0.LPCB.EC0.ST8E (0x31, Zero), Local0) | |
} | |
Else | |
{ | |
Store (^^PCI0.LPCB.EC0.RRAM (0x04C9), Local0) | |
} | |
If (LLessEqual (Local0, One)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LAnd (LLessEqual (Local0, 0x07), LGreater (Local0, One))) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If (LGreater (Local0, 0x07)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
Return (0x80) | |
} | |
} | |
} | |
} | |
Return (0x80) | |
} | |
} | |
} | |
Return (Ones) | |
} | |
Name (PWKB, Buffer (0x04) | |
{ | |
0x00, 0x55, 0xAA, 0xFF /* .U.. */ | |
}) | |
Method (SLKB, 1, NotSerialized) | |
{ | |
Store (And (Arg0, 0x7F), KBLV) /* \_SB_.KBLV */ | |
If (And (Arg0, 0x80)) | |
{ | |
Store (DerefOf (Index (PWKB, KBLV)), Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
^^PCI0.LPCB.EC0.WRAM (0x044B, Local0) | |
Return (One) | |
} | |
Method (GDSP, 1, NotSerialized) | |
{ | |
If (NATK ()) | |
{ | |
If (LEqual (Arg0, 0x80)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Return (GCDM ()) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (ASHS) | |
{ | |
Name (_HID, "ATK4001" /* Asus Radio Control Button */) // _HID: Hardware ID | |
Method (HSWC, 1, Serialized) | |
{ | |
If (LLess (Arg0, 0x02)) | |
{ | |
OWGD (Arg0) | |
Return (One) | |
} | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Return (OWGS ()) | |
} | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Return (0xFF) | |
} | |
If (LEqual (Arg0, 0x80)) | |
{ | |
Return (One) | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (_OSI ("Windows 2012")) | |
{ | |
Return (0x0F) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Device (AC0) | |
{ | |
Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID | |
Method (_PSR, 0, NotSerialized) // _PSR: Power Source | |
{ | |
Return (^^LPCB.EC0.ACAP ()) | |
} | |
Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
{ | |
PCI0 | |
}) | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Method (ACAP, 0, Serialized) | |
{ | |
Return (ACPF) /* \_SB_.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 (^^LPCB.EC0.BATP (Zero)) | |
{ | |
Return (0x1F) | |
} | |
Else | |
{ | |
Return (0x0F) | |
} | |
} | |
Name (LOW2, 0x012C) | |
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", | |
"ASUSTeK" | |
}) | |
Name (PBST, Package (0x04) | |
{ | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Name (BIXT, Package (0x14) | |
{ | |
Zero, | |
Zero, | |
0x1770, | |
0x1770, | |
One, | |
0x39D0, | |
0x0258, | |
0x012C, | |
0x3C, | |
0x3C, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
"M3N", | |
" ", | |
"LIon", | |
"ASUSTeK" | |
}) | |
Name (NBIX, Package (0x14) | |
{ | |
Zero, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
One, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
"", | |
"", | |
"", | |
"" | |
}) | |
Method (FBIF, 5, NotSerialized) | |
{ | |
Store (Arg0, PUNT) /* \_SB_.PCI0.BAT0.PUNT */ | |
Store (Arg1, Local1) | |
Store (Arg2, Local2) | |
If (LEqual (PUNT, Zero)) | |
{ | |
Multiply (Local1, 0x0A, Local1) | |
Multiply (Local2, 0x0A, Local2) | |
} | |
Store (Arg0, Index (PBIF, Zero)) | |
Store (Local1, Index (PBIF, One)) | |
Store (Local2, Index (PBIF, 0x02)) | |
Store (Local2, LFCC) /* \_SB_.PCI0.BAT0.LFCC */ | |
Store (Arg3, Index (PBIF, 0x03)) | |
Store (Arg4, Index (PBIF, 0x04)) | |
Divide (Local1, 0x0A, Local3, Local5) | |
Store (Local5, Index (PBIF, 0x05)) | |
Divide (Local1, 0x64, Local3, Local6) | |
Store (Local6, Index (PBIF, 0x06)) | |
Store (Local6, LOW2) /* \_SB_.PCI0.BAT0.LOW2 */ | |
Divide (Local1, 0x64, Local3, Local7) | |
Store (Local7, Index (PBIF, 0x07)) | |
Store (Local7, Index (PBIF, 0x08)) | |
} | |
Method (CBIF, 0, NotSerialized) | |
{ | |
If (PUNT) | |
{ | |
Store (DerefOf (Index (PBIF, 0x04)), Local0) | |
Store (Zero, Index (PBIF, Zero)) | |
Multiply (DerefOf (Index (PBIF, One)), Local0, Index (PBIF, One | |
)) | |
Multiply (DerefOf (Index (PBIF, 0x02)), Local0, Index (PBIF, 0x02 | |
)) | |
Multiply (DerefOf (Index (PBIF, 0x05)), Local0, Index (PBIF, 0x05 | |
)) | |
Multiply (DerefOf (Index (PBIF, 0x06)), Local0, Index (PBIF, 0x06 | |
)) | |
Multiply (DerefOf (Index (PBIF, 0x07)), Local0, Index (PBIF, 0x07 | |
)) | |
Multiply (DerefOf (Index (PBIF, 0x08)), Local0, Index (PBIF, 0x08 | |
)) | |
Divide (DerefOf (Index (PBIF, One)), 0x03E8, Local2, Index (PBIF, | |
One)) | |
Divide (DerefOf (Index (PBIF, 0x02)), 0x03E8, Local2, Index (PBIF, | |
0x02)) | |
Divide (DerefOf (Index (PBIF, 0x05)), 0x03E8, Local2, Index (PBIF, | |
0x05)) | |
Divide (DerefOf (Index (PBIF, 0x06)), 0x03E8, Local2, Index (PBIF, | |
0x06)) | |
Divide (DerefOf (Index (PBIF, 0x07)), 0x03E8, Local2, Index (PBIF, | |
0x07)) | |
Divide (DerefOf (Index (PBIF, 0x08)), 0x03E8, Local2, Index (PBIF, | |
0x08)) | |
} | |
} | |
Method (_BIF, 0, NotSerialized) // _BIF: Battery Information | |
{ | |
If (LNot (^^LPCB.EC0.BATP (Zero))) | |
{ | |
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ | |
} | |
If (LEqual (^^LPCB.EC0.GBTT (Zero), 0xFF)) | |
{ | |
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ | |
} | |
BATO () | |
BATS (Zero) | |
Store (^^LPCB.EC0.BIF9 (), Index (PBIF, 0x09)) | |
Store (ONAM, Index (PBIF, 0x0C)) | |
Store (^^LPCB.EC0.BIF0 (), Local0) | |
Store (^^LPCB.EC0.BIF1 (), Local1) | |
Store (^^LPCB.EC0.BIF2 (), Local2) | |
Store (^^LPCB.EC0.BIF3 (), Local3) | |
Store (^^LPCB.EC0.BIF4 (), Local4) | |
If (LNotEqual (Local0, Ones)) | |
{ | |
If (LNotEqual (Local1, Ones)) | |
{ | |
If (LNotEqual (Local2, Ones)) | |
{ | |
If (LNotEqual (Local3, Ones)) | |
{ | |
If (LNotEqual (Local4, Ones)) | |
{ | |
FBIF (Local0, Local1, Local2, Local3, Local4) | |
CBIF () | |
} | |
} | |
} | |
} | |
} | |
If (LEqual (PUNT, Zero)) | |
{ | |
Multiply (Local2, 0x0A, Local2) | |
} | |
Store (Local2, LFCC) /* \_SB_.PCI0.BAT0.LFCC */ | |
BATR () | |
Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */ | |
} | |
Method (FBST, 4, NotSerialized) | |
{ | |
And (Arg1, 0xFFFF, Local1) | |
Store (Zero, Local0) | |
If (^^LPCB.EC0.ACAP ()) | |
{ | |
Store (One, Local0) | |
} | |
If (Local0) | |
{ | |
If (CHGS (Zero)) | |
{ | |
Store (0x02, Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Else | |
{ | |
Store (One, Local0) | |
} | |
If (BLLO) | |
{ | |
ShiftLeft (One, 0x02, Local2) | |
Or (Local0, Local2, Local0) | |
} | |
If (And (^^LPCB.EC0.EB0S, 0x08)) | |
{ | |
ShiftLeft (One, 0x02, Local2) | |
Or (Local0, Local2, Local0) | |
} | |
If (LGreaterEqual (Local1, 0x8000)) | |
{ | |
Subtract (0xFFFF, Local1, Local1) | |
} | |
Store (Arg2, Local2) | |
If (LEqual (PUNT, Zero)) | |
{ | |
Multiply (Local1, ^^LPCB.EC0.B0DV, Local1) | |
Multiply (Local2, 0x0A, Local2) | |
} | |
And (Local0, 0x02, Local3) | |
If (LNot (Local3)) | |
{ | |
Subtract (LFCC, Local2, Local3) | |
Divide (LFCC, 0xC8, Local4, Local5) | |
If (LLess (Local3, Local5)) | |
{ | |
Store (LFCC, Local2) | |
} | |
} | |
Else | |
{ | |
Divide (LFCC, 0xC8, Local4, Local5) | |
Subtract (LFCC, Local5, Local4) | |
If (LGreater (Local2, Local4)) | |
{ | |
Store (Local4, Local2) | |
} | |
} | |
If (LNot (^^LPCB.EC0.ACAP ())) | |
{ | |
Divide (Local2, MBLF, Local3, Local4) | |
If (LLess (Local1, Local4)) | |
{ | |
Store (Local4, Local1) | |
} | |
} | |
Store (Local0, Index (PBST, Zero)) | |
Store (Local1, Index (PBST, One)) | |
Store (Local2, Index (PBST, 0x02)) | |
Store (Arg3, Index (PBST, 0x03)) | |
} | |
Method (CBST, 0, NotSerialized) | |
{ | |
If (PUNT) | |
{ | |
Store (^^LPCB.EC0.B0DV, Index (PBST, 0x03)) | |
Store (DerefOf (Index (PBST, 0x03)), Local0) | |
Multiply (DerefOf (Index (PBST, One)), Local0, Index (PBST, One | |
)) | |
Divide (DerefOf (Index (PBST, One)), 0x03E8, Local1, Index (PBST, | |
One)) | |
Multiply (DerefOf (Index (PBST, 0x02)), Local0, Index (PBST, 0x02 | |
)) | |
Divide (DerefOf (Index (PBST, 0x02)), 0x03E8, Local1, Index (PBST, | |
0x02)) | |
} | |
} | |
Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
{ | |
Store (Zero, Index (PBST, Zero)) | |
Store (Ones, Index (PBST, One)) | |
Store (Ones, Index (PBST, 0x02)) | |
Store (Ones, Index (PBST, 0x03)) | |
If (LNot (^^LPCB.EC0.BATP (Zero))) | |
{ | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
If (LEqual (^^LPCB.EC0.GBTT (Zero), 0xFF)) | |
{ | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
If (MES4) | |
{ | |
Decrement (MES4) | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
BATO () | |
BATS (Zero) | |
Store (^^LPCB.EC0.BSTS (), Local0) | |
Store (^^LPCB.EC0.BCRT (), Local1) | |
Store (^^LPCB.EC0.BRCP (), Local2) | |
Store (^^LPCB.EC0.BVOT (), Local3) | |
If (LNotEqual (Local0, Ones)) | |
{ | |
If (LNotEqual (Local1, Ones)) | |
{ | |
If (LNotEqual (Local2, Ones)) | |
{ | |
If (LNotEqual (Local3, Ones)) | |
{ | |
FBST (Local0, Local1, Local2, Local3) | |
CBST () | |
} | |
} | |
} | |
} | |
BATR () | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
Method (_BIX, 0, NotSerialized) // _BIX: Battery Information Extended | |
{ | |
If (LNot (^^LPCB.EC0.BATP (Zero))) | |
{ | |
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ | |
} | |
If (LEqual (^^LPCB.EC0.GBTT (Zero), 0xFF)) | |
{ | |
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ | |
} | |
_BIF () | |
Store (DerefOf (Index (PBIF, Zero)), Index (BIXT, One)) | |
Store (DerefOf (Index (PBIF, One)), Index (BIXT, 0x02)) | |
Store (DerefOf (Index (PBIF, 0x02)), Index (BIXT, 0x03)) | |
Store (DerefOf (Index (PBIF, 0x03)), Index (BIXT, 0x04)) | |
Store (DerefOf (Index (PBIF, 0x04)), Index (BIXT, 0x05)) | |
Store (DerefOf (Index (PBIF, 0x05)), Index (BIXT, 0x06)) | |
Store (DerefOf (Index (PBIF, 0x06)), Index (BIXT, 0x07)) | |
Store (DerefOf (Index (PBIF, 0x07)), Index (BIXT, 0x08)) | |
Store (DerefOf (Index (PBIF, 0x08)), Index (BIXT, 0x09)) | |
Store (DerefOf (Index (PBIF, 0x09)), Index (BIXT, 0x10)) | |
Store (DerefOf (Index (PBIF, 0x0A)), Index (BIXT, 0x11)) | |
Store (DerefOf (Index (PBIF, 0x0B)), Index (BIXT, 0x12)) | |
Store (DerefOf (Index (PBIF, 0x0C)), Index (BIXT, 0x13)) | |
If (LEqual (DerefOf (Index (BIXT, One)), One)) | |
{ | |
Store (Zero, Index (BIXT, One)) | |
Store (DerefOf (Index (BIXT, 0x05)), Local0) | |
Multiply (DerefOf (Index (BIXT, 0x02)), Local0, Index (BIXT, 0x02 | |
)) | |
Multiply (DerefOf (Index (BIXT, 0x03)), Local0, Index (BIXT, 0x03 | |
)) | |
Multiply (DerefOf (Index (BIXT, 0x06)), Local0, Index (BIXT, 0x06 | |
)) | |
Multiply (DerefOf (Index (BIXT, 0x07)), Local0, Index (BIXT, 0x07 | |
)) | |
Multiply (DerefOf (Index (BIXT, 0x08)), Local0, Index (BIXT, 0x08 | |
)) | |
Multiply (DerefOf (Index (BIXT, 0x09)), Local0, Index (BIXT, 0x09 | |
)) | |
Divide (DerefOf (Index (BIXT, 0x02)), 0x03E8, Local0, Index (BIXT, | |
0x02)) | |
Divide (DerefOf (Index (BIXT, 0x03)), 0x03E8, Local0, Index (BIXT, | |
0x03)) | |
Divide (DerefOf (Index (BIXT, 0x06)), 0x03E8, Local0, Index (BIXT, | |
0x06)) | |
Divide (DerefOf (Index (BIXT, 0x07)), 0x03E8, Local0, Index (BIXT, | |
0x07)) | |
Divide (DerefOf (Index (BIXT, 0x08)), 0x03E8, Local0, Index (BIXT, | |
0x08)) | |
Divide (DerefOf (Index (BIXT, 0x09)), 0x03E8, Local0, Index (BIXT, | |
0x09)) | |
} | |
Store (^^LPCB.EC0.B0C3, Index (BIXT, 0x0A)) | |
Store (0x0001869F, Index (BIXT, 0x0B)) | |
Return (BIXT) /* \_SB_.PCI0.BAT0.BIXT */ | |
} | |
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point | |
{ | |
^^LPCB.EC0.ST8E (0x29, 0xFF) | |
^^LPCB.EC0.ST8E (0x2A, 0xFF) | |
^^LPCB.EC0.ST8E (0x28, 0x0F) | |
If (LNotEqual (Arg0, Zero)) | |
{ | |
Store (DerefOf (Index (PBIF, 0x04)), Local0) | |
Multiply (Arg0, 0x03E8, Local1) | |
Divide (Local1, Local0, Local2, Local3) | |
^^LPCB.EC0.ST9E (0x29, 0xFF, And (Local3, 0xFF)) | |
ShiftRight (Local3, 0x08, Local2) | |
And (Local2, 0xFF, Local2) | |
^^LPCB.EC0.ST9E (0x2A, 0xFF, Local2) | |
} | |
} | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Name (B0CR, Zero) | |
Name (B1CR, Zero) | |
Method (GGCC, 1, Serialized) | |
{ | |
BATO () | |
BATS (Arg0) | |
Store (^LPCB.EC0.BCRT (), Local0) | |
BATR () | |
If (LEqual (Local0, Ones)) | |
{ | |
If (Arg0) | |
{ | |
Store (B1CR, Local0) | |
} | |
Else | |
{ | |
Store (B0CR, Local0) | |
} | |
} | |
And (Local0, 0x8000, Local1) | |
If (Local1) | |
{ | |
Store (Zero, Local0) | |
} | |
If (Arg0) | |
{ | |
Store (Local0, B1CR) /* \_SB_.PCI0.B1CR */ | |
} | |
Else | |
{ | |
Store (Local0, B0CR) /* \_SB_.PCI0.B0CR */ | |
} | |
Return (Local0) | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Name (BADR, 0x0B) | |
Name (CADR, 0x09) | |
Name (SADR, 0x0A) | |
Method (ALMH, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, BADR)) | |
{ | |
NBAT (0x80) | |
} | |
} | |
Method (BIFW, 1, NotSerialized) | |
{ | |
Store (SMBR (RDWD, BADR, Arg0), Local0) | |
Store (DerefOf (Index (Local0, Zero)), Local1) | |
If (Local1) | |
{ | |
Return (Ones) | |
} | |
Else | |
{ | |
Return (DerefOf (Index (Local0, 0x02))) | |
} | |
} | |
Method (BIF0, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1MD, Local0) | |
} | |
Else | |
{ | |
Store (B0MD, Local0) | |
} | |
If (LNotEqual (Local0, 0xFFFF)) | |
{ | |
ShiftRight (Local0, 0x0F, Local1) | |
And (Local1, One, Local1) | |
XOr (Local1, One, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BIF1, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1DC, Local0) | |
} | |
Else | |
{ | |
Store (B0DC, Local0) | |
} | |
And (Local0, 0xFFFF, Local0) | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BIF2, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1FC, Local0) | |
} | |
Else | |
{ | |
Store (B0FC, Local0) | |
} | |
And (Local0, 0xFFFF, Local0) | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BIF3, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1MD, Local0) | |
} | |
Else | |
{ | |
Store (B0MD, Local0) | |
} | |
If (LNotEqual (Local0, 0xFFFF)) | |
{ | |
ShiftRight (Local0, 0x09, Local0) | |
And (Local0, One, Local0) | |
XOr (Local0, One, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BIF4, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1DV, Local0) | |
} | |
Else | |
{ | |
Store (B0DV, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BIF9, 0, NotSerialized) | |
{ | |
Name (BSTR, Buffer (0x20) {}) | |
Store (SMBR (RDBL, BADR, 0x21), Local0) | |
If (LNotEqual (DerefOf (Index (Local0, Zero)), Zero)) | |
{ | |
Store (MNAM, BSTR) /* \_SB_.PCI0.LPCB.EC0_.BIF9.BSTR */ | |
Store (Zero, Index (BSTR, 0x04)) | |
} | |
Else | |
{ | |
Store (DerefOf (Index (Local0, 0x02)), BSTR) /* \_SB_.PCI0.LPCB.EC0_.BIF9.BSTR */ | |
Store (Zero, Index (BSTR, DerefOf (Index (Local0, One)))) | |
} | |
Return (BSTR) /* \_SB_.PCI0.LPCB.EC0_.BIF9.BSTR */ | |
} | |
Method (BIFA, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Store (B1SN, Local0) | |
} | |
Else | |
{ | |
Store (B0SN, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BSTS, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Store (B1ST, Local0) | |
} | |
Else | |
{ | |
Store (B0ST, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BCRT, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Store (B1CC, Local0) | |
} | |
Else | |
{ | |
Store (B0CC, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BRCP, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Store (B1RC, Local0) | |
} | |
Else | |
{ | |
Store (B0RC, Local0) | |
} | |
If (LEqual (Local0, 0xFFFF)) | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Method (BVOT, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Store (B1VL, Local0) | |
} | |
Else | |
{ | |
Store (B0VL, Local0) | |
} | |
Return (Local0) | |
} | |
} | |
Scope (\) | |
{ | |
Method (CHGS, 1, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.BCHG (Arg0), Local0) | |
Return (Local0) | |
} | |
Name (BSLF, Zero) | |
Method (BATS, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
Store (One, BSLF) /* \BSLF */ | |
} | |
Else | |
{ | |
Store (Zero, BSLF) /* \BSLF */ | |
} | |
} | |
Mutex (MMPX, 0x00) | |
Method (BATO, 0, Serialized) | |
{ | |
Acquire (MMPX, 0xFFFF) | |
} | |
Method (BATR, 0, Serialized) | |
{ | |
Release (MMPX) | |
} | |
Name (BLLO, Zero) | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Method (_QA1, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (DCPS (Zero), DCPF) /* \_SB_.DCPF */ | |
If (DCPF) | |
{ | |
Sleep (0x07D0) | |
} | |
Notify (BAT0, 0x80) // Status Change | |
Notify (BAT0, 0x81) // Information Change | |
} | |
Method (_QA5, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (One, BLLO) /* \BLLO */ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6E) | |
} | |
Else | |
{ | |
If (BATP (Zero)) | |
{ | |
Notify (BAT0, 0x80) // Status Change | |
} | |
} | |
} | |
Method (_QA3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (BATP (Zero)) | |
{ | |
Store (BCLE (Zero), Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
Notify (BAT0, 0x80) // Status Change | |
} | |
Else | |
{ | |
Notify (BAT0, 0x81) // Information Change | |
Notify (AC0, 0x80) // Status Change | |
} | |
} | |
} | |
Method (BATP, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
Return (DCP2) /* \_SB_.DCP2 */ | |
} | |
Else | |
{ | |
Return (DCPF) /* \_SB_.DCPF */ | |
} | |
} | |
Method (NBAT, 1, NotSerialized) | |
{ | |
If (BATP (Zero)) | |
{ | |
Notify (BAT0, Arg0) | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Name (MES4, Zero) | |
Method (OEMS, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
If (LLessEqual (MSOS (), OSME)) | |
{ | |
Store (One, \_SB.WIDE) | |
} | |
Else | |
{ | |
Store (Zero, \_SB.WIDE) | |
} | |
} | |
SBRS (Arg0) | |
\_SB.PCI0.LPCB.EC0.EC0S (Arg0) | |
Store (Arg0, \_SB.SLPN) | |
DIAG (Add (Arg0, 0xD0)) | |
PPRJ (Arg0) | |
Store (Arg0, \_SB.SLPT) | |
If (Arg0) | |
{ | |
STRP (One) | |
} | |
PRJS (Arg0) | |
If (LEqual (Arg0, 0x03)) | |
{ | |
\_SB.PCI0.LPCB.EC0.ST8E (0x12, 0xFF) | |
\_SB.PCI0.LPCB.EC0.ST9E (0x12, 0x05, One) | |
If (LEqual (\_SB.DP3S, One)) | |
{ | |
\_SB.PCI0.LPCB.EC0.ST9E (Zero, 0x08, One) | |
} | |
Else | |
{ | |
\_SB.PCI0.LPCB.EC0.ST8E (Zero, 0x08) | |
} | |
} | |
ISMI (0x9D) | |
} | |
Method (OEMW, 1, NotSerialized) | |
{ | |
ISMI (0x9E) | |
Store (Zero, \_SB.SLPT) | |
\_SB.PCI0.LPCB.EC0.EC0W (Arg0) | |
If (LEqual (Arg0, 0x04)) | |
{ | |
If (LLessEqual (MSOS (), OSME)) | |
{ | |
Store (0x02, MES4) /* \MES4 */ | |
} | |
Else | |
{ | |
Store (Zero, MES4) /* \MES4 */ | |
} | |
} | |
SBRW (Arg0) | |
If (LEqual (Arg0, 0x04)) | |
{ | |
Notify (\_SB.SLPB, 0x02) // Device Wake | |
} | |
PRJW (Arg0) | |
DIAG (Add (Arg0, 0xF0)) | |
} | |
} | |
Scope (_SB.PCI0.LPCB.TPM) | |
{ | |
Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
{ | |
Return (OTID ()) | |
} | |
Name (_CID, EisaId ("PNP0C31")) // _CID: Compatible ID | |
OperationRegion (\TCMM, SystemMemory, 0xFED40000, 0x5000) | |
Field (TCMM, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0xF00), | |
VDID, 32 | |
} | |
Method (OTID, 0, Serialized) | |
{ | |
Store (ACCS, Local0) | |
If (LNotEqual (Local0, 0xFF)) | |
{ | |
If (LEqual (VDID, 0x687119FA)) | |
{ | |
Return (0x0435CF4D) | |
} | |
Else | |
{ | |
If (LEqual (VDID, 0x000B15D1)) | |
{ | |
Return (0x0201D824) | |
} | |
Else | |
{ | |
Return (0x310CD041) | |
} | |
} | |
} | |
Else | |
{ | |
Return (0x310CD041) | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (PTID) | |
{ | |
Name (CADR, Zero) | |
Name (WLEN, Zero) | |
Name (RLEN, Zero) | |
Name (CAMD, Zero) | |
Name (OBUF, Buffer (0x10) {}) | |
Name (IBUF, Buffer (0x0F) {}) | |
Name (ERRN, Zero) | |
Name (_HID, EisaId ("INT340E") /* Motherboard Resources */) // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _CID: Compatible ID | |
Name (IVER, 0x00030000) | |
Name (TSDL, Package (0x04) | |
{ | |
Zero, | |
"CPU Temperature", | |
0x05, | |
"PCH Temperature" | |
}) | |
Name (TMPV, Package (0x02) | |
{ | |
0x80000000, | |
0x80000000 | |
}) | |
Name (PSDL, Package (0x04) | |
{ | |
Zero, | |
"CPU Power", | |
One, | |
"Gfx Power" | |
}) | |
Name (PWRV, Package (0x02) | |
{ | |
0x80000000, | |
0x80000000 | |
}) | |
Name (OSDL, Package (0x06) | |
{ | |
0x04, | |
"Fan RPM", | |
"RPM", | |
0x0C, | |
"Battery Capaciy", | |
"mAh" | |
}) | |
Name (OSDV, Package (0x02) | |
{ | |
0x80000000, | |
0x80000000 | |
}) | |
Method (TSDD, 0, NotSerialized) | |
{ | |
Name (TMPC, Zero) | |
Store (^^PCI0.LPCB.EC0.ECPU, TMPC) /* \_SB_.PTID.TSDD.TMPC */ | |
Store (TMPC, Index (TMPV, Zero)) | |
Store (^^PCI0.LPCB.EC0.ECPU, TMPC) /* \_SB_.PTID.TSDD.TMPC */ | |
Store (TMPC, Index (TMPV, One)) | |
Return (TMPV) /* \_SB_.PTID.TMPV */ | |
} | |
Method (PWRG, 0, NotSerialized) | |
{ | |
Return (Ones) | |
} | |
Method (PSDD, 0, NotSerialized) | |
{ | |
Name (PWRC, Zero) | |
Store (PWRG (), PWRC) /* \_SB_.PTID.PSDD.PWRC */ | |
Store (PWRC, Index (PWRV, Zero)) | |
Store (PWRG (), PWRC) /* \_SB_.PTID.PSDD.PWRC */ | |
Store (PWRC, Index (PWRV, One)) | |
Return (PWRV) /* \_SB_.PTID.PWRV */ | |
} | |
Method (OSDG, 0, NotSerialized) | |
{ | |
Return (Ones) | |
} | |
Method (OSDD, 0, NotSerialized) | |
{ | |
Name (OSDC, Zero) | |
Store (OSDG (), OSDC) /* \_SB_.PTID.OSDD.OSDC */ | |
Store (OSDC, Index (OSDV, Zero)) | |
Store (OSDG (), OSDC) /* \_SB_.PTID.OSDD.OSDC */ | |
Store (OSDC, Index (OSDV, One)) | |
Return (OSDV) /* \_SB_.PTID.OSDV */ | |
} | |
Method (SDSP, 0, NotSerialized) | |
{ | |
Return (0x0A) | |
} | |
Name (MBOX, Buffer (0x1A) {}) | |
Name (PADA, Package (0x0A) | |
{ | |
One, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0x1A, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Name (PADD, Package (0x0A) | |
{ | |
0x02, | |
0x0271, | |
0x0270, | |
0x1A, | |
0x62, | |
0x63, | |
0x60, | |
0x61, | |
0x65, | |
0x64 | |
}) | |
Method (PADT, 0, NotSerialized) | |
{ | |
And (^^PCI0.LPCB.EC0.PBSY, 0x80, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (PADD) /* \_SB_.PTID.PADD */ | |
} | |
Return (PADA) /* \_SB_.PTID.PADA */ | |
} | |
Method (RPMD, 0, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
Store (0x0A, Local1) | |
Add (WLEN, Local1, Local1) | |
While (LLess (Local0, RLEN)) | |
{ | |
Store (DerefOf (Index (IBUF, Local0)), Index (MBOX, Local1)) | |
Add (One, Local0, Local0) | |
Add (One, Local1, Local1) | |
} | |
Return (MBOX) /* \_SB_.PTID.MBOX */ | |
} | |
Method (WPMD, 1, NotSerialized) | |
{ | |
If (LNotEqual (SizeOf (Arg0), 0x1A)) | |
{ | |
Return (0xFFFFFFFF) | |
} | |
Store (Zero, Local0) | |
While (LLess (Local0, 0x1A)) | |
{ | |
Store (DerefOf (Index (Arg0, Local0)), Index (MBOX, Local0)) | |
Add (One, Local0, Local0) | |
} | |
Store (DerefOf (Index (Arg0, 0x06)), CADR) /* \_SB_.PTID.CADR */ | |
Store (DerefOf (Index (Arg0, 0x07)), WLEN) /* \_SB_.PTID.WLEN */ | |
Store (DerefOf (Index (Arg0, 0x08)), RLEN) /* \_SB_.PTID.RLEN */ | |
Store (DerefOf (Index (Arg0, 0x09)), CAMD) /* \_SB_.PTID.CAMD */ | |
Name (CUNT, Zero) | |
Store (Zero, CUNT) /* \_SB_.PTID.WPMD.CUNT */ | |
Store (0x0A, Local0) | |
While (LLess (CUNT, WLEN)) | |
{ | |
Store (DerefOf (Index (Arg0, Local0)), Index (OBUF, CUNT)) | |
Add (CUNT, One, CUNT) /* \_SB_.PTID.WPMD.CUNT */ | |
Add (Local0, One, Local0) | |
} | |
Return (Zero) | |
} | |
Name (CYCT, Zero) | |
Method (ISPC, 0, NotSerialized) | |
{ | |
Store (DerefOf (Index (MBOX, 0x03)), CYCT) /* \_SB_.PTID.CYCT */ | |
ShiftLeft (CYCT, 0x08, CYCT) /* \_SB_.PTID.CYCT */ | |
Add (CYCT, DerefOf (Index (MBOX, 0x02)), CYCT) /* \_SB_.PTID.CYCT */ | |
ShiftLeft (CYCT, 0x08, CYCT) /* \_SB_.PTID.CYCT */ | |
Add (CYCT, DerefOf (Index (MBOX, One)), CYCT) /* \_SB_.PTID.CYCT */ | |
ShiftLeft (CYCT, 0x08, CYCT) /* \_SB_.PTID.CYCT */ | |
Add (CYCT, DerefOf (Index (MBOX, Zero)), CYCT) /* \_SB_.PTID.CYCT */ | |
If (LGreaterEqual (CYCT, One)) | |
{ | |
Store (DerefOf (Index (MBOX, 0x04)), Local0) | |
Multiply (Local0, 0x0A, Local0) | |
Sleep (Local0) | |
} | |
Store (^^PCI0.LPCB.EC0.PECI (CADR, WLEN, RLEN, CAMD, OBUF, IBUF, ERRN), Local0) | |
If (LEqual (Local0, One)) | |
{ | |
If (LGreater (CYCT, Zero)) | |
{ | |
Subtract (CYCT, One, CYCT) /* \_SB_.PTID.CYCT */ | |
And (CYCT, 0xFF, Index (MBOX, Zero)) | |
And (CYCT, 0xFF00, Local0) | |
ShiftRight (Local0, 0x08, Index (MBOX, One)) | |
And (CYCT, 0x00FF0000, Local0) | |
ShiftRight (Local0, 0x10, Index (MBOX, 0x02)) | |
And (CYCT, 0xFF000000, Local0) | |
ShiftRight (Local0, 0x18, Index (MBOX, 0x03)) | |
} | |
} | |
} | |
Method (ENPC, 0, NotSerialized) | |
{ | |
Store (Zero, CYCT) /* \_SB_.PTID.CYCT */ | |
} | |
Method (RPCS, 0, NotSerialized) | |
{ | |
Name (TPCS, Zero) | |
If (LGreater (CYCT, Zero)) | |
{ | |
Store (One, TPCS) /* \_SB_.PTID.RPCS.TPCS */ | |
ISPC () | |
} | |
Else | |
{ | |
Store (Zero, TPCS) /* \_SB_.PTID.RPCS.TPCS */ | |
} | |
Return (TPCS) /* \_SB_.PTID.RPCS.TPCS */ | |
} | |
Method (RPEC, 0, NotSerialized) | |
{ | |
Name (TPEC, Zero) | |
Store (ERRN, TPEC) /* \_SB_.PTID.RPEC.TPEC */ | |
Return (TPEC) /* \_SB_.PTID.RPEC.TPEC */ | |
} | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (AGFN, 1, Serialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Return (GNBF) /* \_SB_.GNBF */ | |
} | |
Store (Zero, Local0) | |
OperationRegion (\PARM, SystemMemory, Arg0, 0x08) | |
Field (PARM, DWordAcc, NoLock, Preserve) | |
{ | |
MFUN, 16, | |
SFUN, 16, | |
LEN, 16, | |
STAS, 8, | |
EROR, 8 | |
} | |
Store (Zero, EROR) /* \_SB_.ATKD.AGFN.EROR */ | |
Store (One, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
If (LEqual (MFUN, 0x02)) | |
{ | |
BSMI (Arg0) | |
And (STAS, 0xFE, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
} | |
And (MFUN, 0xF0, Local0) | |
If (LEqual (Local0, 0x10)) | |
{ | |
MF1X (Arg0, LEN, MFUN, SFUN) | |
} | |
If (LEqual (MFUN, 0x42)) | |
{ | |
MF42 (Arg0, SFUN, LEN) | |
And (STAS, 0xFE, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
} | |
If (LEqual (MFUN, One)) | |
{ | |
GVER (Arg0, LEN) | |
And (STAS, 0xFE, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
} | |
If (LEqual (MFUN, 0x30)) | |
{ | |
MF30 (Arg0, SFUN, LEN) | |
And (STAS, 0xFE, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
} | |
AGLN (Arg0, MFUN, SFUN, LEN) | |
If (LEqual (STAS, One)) | |
{ | |
Store (One, EROR) /* \_SB_.ATKD.AGFN.EROR */ | |
Or (STAS, 0x02, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
} | |
And (STAS, 0xFE, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
Or (STAS, 0x80, STAS) /* \_SB_.ATKD.AGFN.STAS */ | |
Return (Zero) | |
} | |
Method (GVER, 2, NotSerialized) | |
{ | |
OperationRegion (\FGVR, SystemMemory, Arg0, Arg1) | |
Field (FGVR, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
APID, 16, | |
APRV, 32 | |
} | |
Return (Zero) | |
} | |
Method (MF30, 3, NotSerialized) | |
{ | |
OperationRegion (FM30, SystemMemory, Arg0, 0x08) | |
Field (FM30, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x06), | |
SM30, 8, | |
EM30, 8 | |
} | |
Store (One, Local0) | |
If (LEqual (Arg1, Zero)) | |
{ | |
Store (G30V (Arg0, Arg2), Local0) | |
} | |
If (LEqual (Arg1, One)) | |
{ | |
Store (EC01 (Arg0, Arg2), Local0) | |
} | |
If (LEqual (Arg1, 0x02)) | |
{ | |
Store (EC02 (Arg0, Arg2), Local0) | |
} | |
If (Local0) | |
{ | |
Store (Local0, EM30) /* \_SB_.ATKD.MF30.EM30 */ | |
Or (SM30, 0x02, SM30) /* \_SB_.ATKD.MF30.SM30 */ | |
} | |
Or (SM30, 0x80, SM30) /* \_SB_.ATKD.MF30.SM30 */ | |
Return (Zero) | |
} | |
Method (G30V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F300, SystemMemory, Arg0, Arg1) | |
Field (F300, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G30V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G30V.SVER */ | |
Return (Zero) | |
} | |
Method (EC01, 2, NotSerialized) | |
{ | |
If (LLess (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 | |
} | |
Store (^^PCI0.LPCB.EC0.ECXT (ECMD, EDA1, EDA2, EDA3, EDA4, EDA5), Local0) | |
Store (DerefOf (Index (Local0, One)), EDA1) /* \_SB_.ATKD.EC01.EDA1 */ | |
Store (DerefOf (Index (Local0, 0x02)), EDA2) /* \_SB_.ATKD.EC01.EDA2 */ | |
Store (DerefOf (Index (Local0, 0x03)), EDA3) /* \_SB_.ATKD.EC01.EDA3 */ | |
Store (DerefOf (Index (Local0, 0x04)), EDA4) /* \_SB_.ATKD.EC01.EDA4 */ | |
Store (DerefOf (Index (Local0, 0x05)), EDA5) /* \_SB_.ATKD.EC01.EDA5 */ | |
Return (DerefOf (Index (Local0, Zero))) | |
} | |
Method (EC02, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x30)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (FEC2, SystemMemory, Arg0, Arg1) | |
Field (FEC2, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BUSN, 8, | |
PROT, 8, | |
DADD, 8, | |
DREG, 8, | |
DAT0, 8, | |
DAT1, 8, | |
BLEN, 8, | |
REVB, 8, | |
BLKK, 256 | |
} | |
Store (Package (0x02) | |
{ | |
Zero, | |
Buffer (0x20) {} | |
}, Local1) | |
Store (BLEN, Index (Local1, Zero)) | |
Store (BLKK, Index (Local1, One)) | |
Store (^^PCI0.LPCB.EC0.ECSB (BUSN, PROT, DADD, DREG, DAT0, DAT1, Local1), Local0) | |
If (LEqual (DerefOf (Index (Local0, Zero)), Zero)) | |
{ | |
Store (DerefOf (Index (Local0, One)), DAT0) /* \_SB_.ATKD.EC02.DAT0 */ | |
Store (DerefOf (Index (Local0, 0x02)), DAT1) /* \_SB_.ATKD.EC02.DAT1 */ | |
Store (DerefOf (Index (Local0, 0x03)), BLEN) /* \_SB_.ATKD.EC02.BLEN */ | |
Store (DerefOf (Index (Local0, 0x04)), BLKK) /* \_SB_.ATKD.EC02.BLKK */ | |
} | |
Store (DerefOf (Index (Local0, Zero)), Local2) | |
And (Local2, 0x3F, Local2) | |
Return (Local2) | |
} | |
Method (GENW, 1, NotSerialized) | |
{ | |
Store (Zero, RTCW) /* \_SB_.RTCW */ | |
} | |
Method (BSMI, 1, Serialized) | |
{ | |
Store (Arg0, BIPA) /* \_SB_.BIPA */ | |
ISMI (0xA1) | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (MF1X, 4, NotSerialized) | |
{ | |
OperationRegion (FM1X, SystemMemory, Arg0, 0x08) | |
Field (FM1X, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x06), | |
SM1X, 8, | |
EM1X, 8 | |
} | |
Store (One, Local0) | |
If (LEqual (Arg2, 0x10)) | |
{ | |
Store (MF10 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x11)) | |
{ | |
Store (MF11 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x12)) | |
{ | |
Store (MF12 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x13)) | |
{ | |
Store (MF13 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x14)) | |
{ | |
Store (MF14 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x15)) | |
{ | |
Store (MF15 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x16)) | |
{ | |
Store (MF16 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x17)) | |
{ | |
Store (MF17 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x18)) | |
{ | |
Store (MF18 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x19)) | |
{ | |
Store (MF19 (Arg0, Arg1, Arg3), Local0) | |
} | |
If (LEqual (Arg2, 0x1F)) | |
{ | |
Store (MF1F (Arg0, Arg1, Arg3), Local0) | |
} | |
And (SM1X, 0xFE, SM1X) /* \_SB_.ATKD.MF1X.SM1X */ | |
If (Local0) | |
{ | |
Store (Local0, EM1X) /* \_SB_.ATKD.MF1X.EM1X */ | |
Or (SM1X, 0x02, SM1X) /* \_SB_.ATKD.MF1X.SM1X */ | |
} | |
Or (SM1X, 0x80, SM1X) /* \_SB_.ATKD.MF1X.SM1X */ | |
} | |
Method (MF10, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G10V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (SRTC (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G10V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F100, SystemMemory, Arg0, Arg1) | |
Field (F100, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G10V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G10V.SVER */ | |
Return (Zero) | |
} | |
Method (SRTC, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F101, SystemMemory, Arg0, Arg1) | |
Field (F101, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DLTM, 16 | |
} | |
Store (DLTM, RTCW) /* \_SB_.RTCW */ | |
Return (Zero) | |
} | |
Method (MF11, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G11V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GBAT (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (ASBR (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Store (ASBE (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x04)) | |
{ | |
Store (BTCR (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G11V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F110, SystemMemory, Arg0, Arg1) | |
Field (F100, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G11V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G11V.SVER */ | |
Return (Zero) | |
} | |
Method (GBAT, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F111, SystemMemory, Arg0, Arg1) | |
Field (F111, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BTNM, 8, | |
BTTP, 8 | |
} | |
Store (One, BTNM) /* \_SB_.ATKD.GBAT.BTNM */ | |
Store (Zero, BTTP) /* \_SB_.ATKD.GBAT.BTTP */ | |
Return (Zero) | |
} | |
Method (ASBR, 2, NotSerialized) | |
{ | |
If (LLess (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 (LGreaterEqual (BATN, One)) | |
{ | |
Return (0x11) | |
} | |
If (LEqual (BATA, Zero)) | |
{ | |
Store (^^PCI0.LPCB.EC0.SMBR (^^PCI0.LPCB.EC0.RDWD, ^^PCI0.LPCB.EC0.BADR, REGS), Local0) | |
Store (DerefOf (Index (Local0, 0x02)), BDAT) /* \_SB_.ATKD.ASBR.BDAT */ | |
Store (DerefOf (Index (Local0, Zero)), Local2) | |
And (Local2, 0x1F, Local2) | |
If (Local2) | |
{ | |
Add (Local2, 0x10, Local2) | |
} | |
Return (Local2) | |
} | |
If (LEqual (BATA, One)) | |
{ | |
Store (^^PCI0.LPCB.EC0.SMBW (^^PCI0.LPCB.EC0.WRWD, ^^PCI0.LPCB.EC0.BADR, REGS, 0x02, BDAT), Local0) | |
Store (DerefOf (Index (Local0, Zero)), Local2) | |
And (Local2, 0x1F, Local2) | |
If (Local2) | |
{ | |
Add (Local2, 0x10, Local2) | |
} | |
Return (Local2) | |
} | |
If (LEqual (BATA, 0x02)) | |
{ | |
Store (^^PCI0.LPCB.EC0.SMBR (^^PCI0.LPCB.EC0.RDBL, ^^PCI0.LPCB.EC0.BADR, REGS), Local0) | |
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) | |
Store (DerefOf (Index (Local0, 0x02)), BKUF) /* \_SB_.ATKD.ASBR.BKUF */ | |
Store (DAT1, BLK1) /* \_SB_.ATKD.ASBR.BLK1 */ | |
Store (DAT2, BLK2) /* \_SB_.ATKD.ASBR.BLK2 */ | |
Store (DAT3, BLK3) /* \_SB_.ATKD.ASBR.BLK3 */ | |
Store (DAT4, BLK4) /* \_SB_.ATKD.ASBR.BLK4 */ | |
Store (DAT5, BLK5) /* \_SB_.ATKD.ASBR.BLK5 */ | |
Store (DAT6, BLK6) /* \_SB_.ATKD.ASBR.BLK6 */ | |
Store (DAT7, BLK7) /* \_SB_.ATKD.ASBR.BLK7 */ | |
Store (DAT8, BLK8) /* \_SB_.ATKD.ASBR.BLK8 */ | |
Store (DerefOf (Index (Local0, One)), BLEN) /* \_SB_.ATKD.ASBR.BLEN */ | |
Store (DerefOf (Index (Local0, Zero)), Local2) | |
And (Local2, 0x1F, Local2) | |
If (Local2) | |
{ | |
Add (Local2, 0x10, Local2) | |
} | |
Return (Local2) | |
} | |
Return (0x10) | |
} | |
Method (ASBE, 2, Serialized) | |
{ | |
If (LLess (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 (LGreater (BATN, One)) | |
{ | |
Return (0x11) | |
} | |
If (LEqual (BATA, Zero)) | |
{ | |
Store (^^PCI0.LPCB.EC0.RBEP (REGS), Local2) | |
And (Local2, 0xFF, Local3) | |
Store (Local3, BDAT) /* \_SB_.ATKD.ASBE.BDAT */ | |
ShiftRight (Local2, 0x08, Local2) | |
And (Local2, 0x1F, Local2) | |
If (Local2) | |
{ | |
Add (Local2, 0x10, Local2) | |
} | |
Return (Local2) | |
} | |
If (LEqual (BATA, One)) | |
{ | |
Store (^^PCI0.LPCB.EC0.WBEP (REGS, BDAT), Local2) | |
And (Local2, 0x1F, Local2) | |
If (Local2) | |
{ | |
Add (Local2, 0x10, Local2) | |
} | |
Return (Local2) | |
} | |
Return (0x10) | |
} | |
Method (BTCR, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F114, SystemMemory, Arg0, Arg1) | |
Field (F114, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BCDC, 8 | |
} | |
SBTL (BCDC) | |
Return (Zero) | |
} | |
Method (MF12, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G12V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GLDI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (LDCR (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G12V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F120, SystemMemory, Arg0, Arg1) | |
Field (F120, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G12V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G12V.SVER */ | |
Return (Zero) | |
} | |
Method (GLDI, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F121, SystemMemory, Arg0, Arg1) | |
Field (F121, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDI0, 32, | |
LDI1, 32 | |
} | |
Store (Zero, Local0) | |
Or (Local0, 0x10, Local0) | |
Or (Local0, 0x20, Local0) | |
Store (Local0, LDI0) /* \_SB_.ATKD.GLDI.LDI0 */ | |
Return (Zero) | |
} | |
Method (LDCR, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F122, SystemMemory, Arg0, Arg1) | |
Field (F122, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDNM, 8, | |
LCRT, 8 | |
} | |
If (LEqual (LDNM, 0x04)) | |
{ | |
WLED (LCRT) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (MF13, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G13V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GTSI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (GTSV (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Store (GVSN (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x04)) | |
{ | |
Store (GVSV (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x05)) | |
{ | |
Store (GFNN (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x06)) | |
{ | |
Store (GFNS (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x07)) | |
{ | |
Store (SFNS (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G13V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F130, SystemMemory, Arg0, Arg1) | |
Field (F130, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G13V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G13V.SVER */ | |
Return (Zero) | |
} | |
Method (GTSI, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F131, SystemMemory, Arg0, Arg1) | |
Field (F131, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
THRI, 32 | |
} | |
Store (Zero, Local0) | |
Or (Local0, One, Local0) | |
If (LGreaterEqual (CPUN, One)) | |
{ | |
Or (Local0, 0x0100, Local0) | |
} | |
If (LGreaterEqual (CPUN, 0x02)) | |
{ | |
Or (Local0, 0x0200, Local0) | |
} | |
If (LGreaterEqual (CPUN, 0x03)) | |
{ | |
Or (Local0, 0x0400, Local0) | |
} | |
If (LGreaterEqual (CPUN, 0x04)) | |
{ | |
Or (Local0, 0x0800, Local0) | |
} | |
Store (Local0, THRI) /* \_SB_.ATKD.GTSI.THRI */ | |
Return (Zero) | |
} | |
Method (GTSV, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F132, SystemMemory, Arg0, Arg1) | |
Field (F132, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
TSNM, 8, | |
TSVL, 8, | |
TSST, 8 | |
} | |
Store (Zero, TSST) /* \_SB_.ATKD.GTSV.TSST */ | |
If (LEqual (TSNM, Zero)) | |
{ | |
Store (\_TZ.RTMP (), TSVL) /* \_SB_.ATKD.GTSV.TSVL */ | |
Return (Zero) | |
} | |
If (LEqual (TSNM, 0x08)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If (LEqual (TSNM, 0x09)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If (LEqual (TSNM, 0x0A)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If (LEqual (TSNM, 0x0B)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (GVSN, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F133, SystemMemory, Arg0, Arg1) | |
Field (F133, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NMVS, 8 | |
} | |
Store (Zero, NMVS) /* \_SB_.ATKD.GVSN.NMVS */ | |
Return (Zero) | |
} | |
Method (GVSV, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0B)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F134, SystemMemory, Arg0, Arg1) | |
Field (F134, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
VSNM, 8, | |
VSVL, 16 | |
} | |
If (LGreater (VSNM, Zero)) | |
{ | |
Return (0x10) | |
} | |
Return (Zero) | |
} | |
Method (GFNN, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F135, SystemMemory, Arg0, Arg1) | |
Field (F135, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NMFN, 32 | |
} | |
Store (One, NMFN) /* \_SB_.ATKD.GFNN.NMFN */ | |
Return (Zero) | |
} | |
Method (GFNS, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0D)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F136, SystemMemory, Arg0, Arg1) | |
Field (F136, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
FNNM, 8, | |
GFNS, 32 | |
} | |
If (Or (LEqual (FNNM, Zero), LGreater (FNNM, One))) | |
{ | |
Return (0x10) | |
} | |
Store (FNNM, Local0) | |
Store (\_TZ.RFAN (Decrement (Local0)), GFNS) /* \_SB_.ATKD.GFNS.GFNS */ | |
Return (Zero) | |
} | |
Method (SFNS, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F137, SystemMemory, Arg0, Arg1) | |
Field (F137, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
FNNB, 8, | |
FNSP, 8 | |
} | |
If (LGreater (FNNB, One)) | |
{ | |
Return (0x10) | |
} | |
^^PCI0.LPCB.EC0.SFNV (FNNB, FNSP) | |
Return (Zero) | |
} | |
Method (MF14, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G14V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GNBT (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (GBTS (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G14V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F140, SystemMemory, Arg0, Arg1) | |
Field (F140, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G14V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G14V.SVER */ | |
Return (Zero) | |
} | |
Method (GNBT, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F141, SystemMemory, Arg0, Arg1) | |
Field (F141, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NBBT, 8 | |
} | |
Store (0x05, NBBT) /* \_SB_.ATKD.GNBT.NBBT */ | |
Return (Zero) | |
} | |
Method (GBTS, 2, NotSerialized) | |
{ | |
If (LLess (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 (0x03) | |
{ | |
0x0C, | |
Zero, | |
Zero | |
}, | |
Package (0x03) | |
{ | |
0x0D, | |
Zero, | |
Zero | |
}, | |
Package (0x03) | |
{ | |
0x0E, | |
Zero, | |
Zero | |
}, | |
Package (0x03) | |
{ | |
0x0F, | |
Zero, | |
Zero | |
}, | |
Package (0x03) | |
{ | |
0x15, | |
Zero, | |
Zero | |
} | |
}) | |
If (LGreater (BTNM, 0x05)) | |
{ | |
Return (0x10) | |
} | |
Store (BTNM, Local0) | |
Decrement (Local0) | |
Store (DerefOf (Index (BTTB, Local0)), Local1) | |
If (LEqual (DerefOf (Index (Local1, One)), Zero)) | |
{ | |
Store (^^PCI0.LPCB.EC0.RPIN (DerefOf (Index (Local1, Zero))), Local2) | |
} | |
If (LEqual (DerefOf (Index (Local1, One)), One)) | |
{ | |
Store (RGPL (DerefOf (Index (Local1, Zero)), One), Local2) | |
} | |
If (LEqual (DerefOf (Index (Local1, One)), 0x03)) {} | |
If (LEqual (DerefOf (Index (Local1, 0x02)), Local2)) | |
{ | |
Store (Zero, BTST) /* \_SB_.ATKD.GBTS.BTST */ | |
} | |
Else | |
{ | |
Store (One, BTST) /* \_SB_.ATKD.GBTS.BTST */ | |
} | |
Return (Zero) | |
} | |
Method (MF15, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G15V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GLDB (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (SLDB (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Store (GDPI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x04)) | |
{ | |
Store (SODP (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G15V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F150, SystemMemory, Arg0, Arg1) | |
Field (F150, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G15V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G15V.SVER */ | |
Return (Zero) | |
} | |
Method (GLDB, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F151, SystemMemory, Arg0, Arg1) | |
Field (F151, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LCDB, 8, | |
MLDB, 8 | |
} | |
Store (GPLV (), LCDB) /* \_SB_.ATKD.GLDB.LCDB */ | |
Store (0x0B, MLDB) /* \_SB_.ATKD.GLDB.MLDB */ | |
Return (Zero) | |
} | |
Method (SLDB, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F152, SystemMemory, Arg0, Arg1) | |
Field (F152, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LCDL, 8, | |
LTPE, 8 | |
} | |
If (LEqual (LTPE, Zero)) | |
{ | |
If (LGreater (LCDL, 0x0B)) | |
{ | |
Return (0x10) | |
} | |
SPLV (LCDL) | |
Return (Zero) | |
} | |
If (LEqual (LTPE, One)) | |
{ | |
^^PCI0.LPCB.EC0.SBRV (LCDL) | |
Return (Zero) | |
} | |
Return (0x11) | |
} | |
Method (GDPI, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F153, SystemMemory, Arg0, Arg1) | |
Field (F153, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ODPI, 32, | |
ODPC, 8 | |
} | |
Store (Zero, Local0) | |
Or (Local0, One, Local0) | |
Or (Local0, 0x02, Local0) | |
Store (Local0, ODPI) /* \_SB_.ATKD.GDPI.ODPI */ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (SODP, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F154, SystemMemory, Arg0, Arg1) | |
Field (F154, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ODPM, 32 | |
} | |
Store (Zero, Local0) | |
Or (Local0, One, Local0) | |
Or (Local0, 0x02, Local0) | |
And (ODPM, Local0, Local0) | |
If (LEqual (Local0, ODPM)) | |
{ | |
SDSP (ODPM) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (MF16, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G16V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (SFBD (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (LCMD (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G16V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F160, SystemMemory, Arg0, Arg1) | |
Field (F160, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G16V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G16V.SVER */ | |
Return (Zero) | |
} | |
Method (SFBD, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F161, SystemMemory, Arg0, Arg1) | |
Field (F161, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NXBD, 8 | |
} | |
If (OFBD (NXBD)) | |
{ | |
Store (NXBD, UHDB) /* \_SB_.UHDB */ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (0x10) | |
} | |
} | |
Method (LCMD, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (MF17, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G17V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GMDL (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (GBSI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Store (GECI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x04)) | |
{ | |
Store (GFII (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G17V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F170, SystemMemory, Arg0, Arg1) | |
Field (F170, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G17V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G17V.SVER */ | |
Return (Zero) | |
} | |
Method (GMDL, 2, NotSerialized) | |
{ | |
If (LLess (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 | |
} | |
Store (Zero, MDL1) /* \_SB_.ATKD.GMDL.MDL1 */ | |
Store (Zero, MDL2) /* \_SB_.ATKD.GMDL.MDL2 */ | |
Store (Zero, MDL3) /* \_SB_.ATKD.GMDL.MDL3 */ | |
Store (Zero, MDL4) /* \_SB_.ATKD.GMDL.MDL4 */ | |
Name (BBUF, Buffer (0x10) {}) | |
CreateDWordField (BBUF, Zero, DAT1) | |
CreateDWordField (BBUF, 0x04, DAT2) | |
CreateDWordField (BBUF, 0x08, DAT3) | |
CreateDWordField (BBUF, 0x0C, DAT4) | |
Store (GBMN (), Local0) | |
Store (SizeOf (Local0), MLEN) /* \_SB_.ATKD.GMDL.MLEN */ | |
Store (GBMN (), BBUF) /* \_SB_.ATKD.GMDL.BBUF */ | |
Store (DAT1, MDL1) /* \_SB_.ATKD.GMDL.MDL1 */ | |
Store (DAT2, MDL2) /* \_SB_.ATKD.GMDL.MDL2 */ | |
Store (DAT3, MDL3) /* \_SB_.ATKD.GMDL.MDL3 */ | |
Store (DAT4, MDL4) /* \_SB_.ATKD.GMDL.MDL4 */ | |
Return (Zero) | |
} | |
Method (GBSI, 2, NotSerialized) | |
{ | |
If (LLess (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, 32 | |
} | |
Store (Zero, BDL1) /* \_SB_.ATKD.GBSI.BDL1 */ | |
Store (Zero, BDL2) /* \_SB_.ATKD.GBSI.BDL2 */ | |
Store (Zero, BDL3) /* \_SB_.ATKD.GBSI.BDL3 */ | |
Store (Zero, BDL4) /* \_SB_.ATKD.GBSI.BDL4 */ | |
Name (BBUF, Buffer (0x10) {}) | |
CreateDWordField (BBUF, Zero, DAT1) | |
CreateDWordField (BBUF, 0x04, DAT2) | |
CreateDWordField (BBUF, 0x08, DAT3) | |
CreateDWordField (BBUF, 0x0C, DAT4) | |
Store (GBRV (), Local0) | |
Store (SizeOf (Local0), BLEN) /* \_SB_.ATKD.GBSI.BLEN */ | |
Store (GBRV (), BBUF) /* \_SB_.ATKD.GBSI.BBUF */ | |
Store (DAT1, BDL1) /* \_SB_.ATKD.GBSI.BDL1 */ | |
Store (DAT2, BDL2) /* \_SB_.ATKD.GBSI.BDL2 */ | |
Store (DAT3, BDL3) /* \_SB_.ATKD.GBSI.BDL3 */ | |
Store (DAT4, BDL4) /* \_SB_.ATKD.GBSI.BDL4 */ | |
Return (Zero) | |
} | |
Method (GECI, 2, NotSerialized) | |
{ | |
If (LLess (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 | |
} | |
Store (Zero, EDL1) /* \_SB_.ATKD.GECI.EDL1 */ | |
Store (Zero, EDL2) /* \_SB_.ATKD.GECI.EDL2 */ | |
Store (Zero, EDL3) /* \_SB_.ATKD.GECI.EDL3 */ | |
Store (Zero, EDL4) /* \_SB_.ATKD.GECI.EDL4 */ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (GFII, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F174, SystemMemory, Arg0, Arg1) | |
Field (F174, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SFII, 8 | |
} | |
Store (BECF, SFII) /* \_SB_.ATKD.GFII.SFII */ | |
Return (Zero) | |
} | |
Method (MF18, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G18V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (GDVI (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (GDVS (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x03)) | |
{ | |
Store (SDPW (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G18V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F180, SystemMemory, Arg0, Arg1) | |
Field (F180, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G18V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G18V.SVER */ | |
Return (Zero) | |
} | |
Method (GDVI, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x18)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F181, SystemMemory, Arg0, Arg1) | |
Field (F181, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDI0, 32, | |
LDI1, 32 | |
} | |
Store (FEBL, LDI0) /* \_SB_.ATKD.GDVI.LDI0 */ | |
Return (Zero) | |
} | |
Method (GDVS, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F182, SystemMemory, Arg0, Arg1) | |
Field (F182, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DNUM, 8, | |
DSTS, 8 | |
} | |
ShiftLeft (One, DNUM, Local0) | |
If (LEqual (And (Local0, FEBL), Zero)) | |
{ | |
Return (0x10) | |
} | |
Return (Zero) | |
} | |
Method (SDPW, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F183, SystemMemory, Arg0, Arg1) | |
Field (F183, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DNUM, 8, | |
DCTR, 8 | |
} | |
ShiftLeft (One, DNUM, Local0) | |
If (LEqual (And (Local0, FEBL), Zero)) | |
{ | |
Return (0x10) | |
} | |
If (LGreater (DCTR, One)) | |
{ | |
Return (0x11) | |
} | |
Return (Zero) | |
} | |
Method (MF19, 3, NotSerialized) | |
{ | |
Store (One, Local0) | |
If (LEqual (Arg2, Zero)) | |
{ | |
Store (G19V (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, One)) | |
{ | |
Store (ACMS (Arg0, Arg1), Local0) | |
} | |
If (LEqual (Arg2, 0x02)) | |
{ | |
Store (CSIN (Arg0, Arg1), Local0) | |
} | |
Return (Local0) | |
} | |
Method (G19V, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F190, SystemMemory, Arg0, Arg1) | |
Field (F190, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
Store (Zero, MVER) /* \_SB_.ATKD.G19V.MVER */ | |
Store (Zero, SVER) /* \_SB_.ATKD.G19V.SVER */ | |
Return (Zero) | |
} | |
Method (ACMS, 2, NotSerialized) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (CSIN, 2, NotSerialized) | |
{ | |
If (LLess (Arg1, 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F192, SystemMemory, Arg0, Arg1) | |
Field (F192, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
CMAX, 16 | |
} | |
Store (0xFF, CMAX) /* \_SB_.ATKD.CSIN.CMAX */ | |
Return (Zero) | |
} | |
Method (NVIN, 2, NotSerialized) | |
{ | |
OperationRegion (FM1F, SystemMemory, Arg0, Arg1) | |
Field (FM1F, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
AM1F, 32 | |
} | |
Return (ANVI (AM1F)) | |
} | |
Method (MF1F, 3, NotSerialized) | |
{ | |
If (LEqual (Arg2, 0x11)) | |
{ | |
Return (NVIN (Arg0, Arg1)) | |
} | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (AGLN, 4, NotSerialized) | |
{ | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (OFBD, 1, NotSerialized) | |
{ | |
Name (FBDT, Package (0x52) | |
{ | |
0x88, | |
0x89, | |
0x8A, | |
0x8B, | |
0x8C, | |
0x8D, | |
0x8E, | |
0x8F, | |
0x70, | |
0x71, | |
0x72, | |
0x73, | |
0x74, | |
0x75, | |
0x76, | |
0x77, | |
0x78, | |
0x79, | |
0x7A, | |
0x7B, | |
0x7C, | |
0x7D, | |
0x7E, | |
0x7F, | |
0x60, | |
0x61, | |
0x62, | |
0x63, | |
0x64, | |
0x65, | |
0x66, | |
0x67, | |
0x91, | |
0x92, | |
0x93, | |
0x96, | |
0xE0, | |
0xE1, | |
0xE2, | |
0xE3, | |
0xE4, | |
0xE5, | |
0xE6, | |
0xE7, | |
0xE8, | |
0xE9, | |
0xEA, | |
0xEB, | |
0xEC, | |
0xED, | |
0xEE, | |
0xEF, | |
0xD0, | |
0xD1, | |
0xD2, | |
0xD3, | |
0xD4, | |
0xD5, | |
0xD6, | |
0xD7, | |
0xD8, | |
0xD9, | |
0xDA, | |
0xDB, | |
0xDC, | |
0xDD, | |
0xDE, | |
0xDF, | |
0xC0, | |
0xC1, | |
0xC2, | |
0xC3, | |
0xC4, | |
0xC5, | |
0xC6, | |
0xC7, | |
0xF1, | |
0xF2, | |
0xF3, | |
0xF6, | |
0xF7, | |
0xFA | |
}) | |
Store (Match (FBDT, MEQ, Arg0, MTR, Zero, Zero), Local0) | |
Increment (Local0) | |
Return (Local0) | |
} | |
Method (GBRV, 0, NotSerialized) | |
{ | |
Store ("214", Local0) | |
Return (Local0) | |
} | |
Method (GBMN, 0, NotSerialized) | |
{ | |
Store ("UX32VD", Local0) | |
Return (Local0) | |
} | |
Method (OGDP, 1, NotSerialized) | |
{ | |
Store (Arg0, Local0) | |
Store (0x02, Local1) | |
Return (Local1) | |
} | |
Method (RSID, 0, NotSerialized) | |
{ | |
Return (Zero) | |
} | |
Method (OSDP, 2, NotSerialized) | |
{ | |
Store (Arg0, Local0) | |
Store (Arg1, Local1) | |
} | |
Method (MF42, 3, NotSerialized) | |
{ | |
OperationRegion (FM42, SystemMemory, Arg0, 0x08) | |
Field (FM42, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x06), | |
SM42, 8, | |
EM42, 8 | |
} | |
Store (One, Local0) | |
If (LEqual (Arg1, One)) | |
{ | |
Store (SFBO (Arg0, Arg2), Local0) | |
} | |
If (LEqual (Arg1, 0x02)) | |
{ | |
Store (SAOC (Arg0, Arg2), Local0) | |
} | |
If (LEqual (Arg1, 0x03)) | |
{ | |
Store (GBST (Arg0, Arg2), Local0) | |
} | |
If (Local0) | |
{ | |
Store (Local0, EM42) /* \_SB_.ATKD.MF42.EM42 */ | |
Or (SM42, 0x02, SM42) /* \_SB_.ATKD.MF42.SM42 */ | |
} | |
Or (SM42, 0x80, SM42) /* \_SB_.ATKD.MF42.SM42 */ | |
Return (Zero) | |
} | |
Method (SFBO, 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 | |
} | |
Store (TBOT, BOT1) /* \_SB_.ATKD.GBST.BOT1 */ | |
Store (RTC3, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (RTC2, Local0, Local0) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (RTC1, Local0, Local0) | |
Store (Local0, BOT2) /* \_SB_.ATKD.GBST.BOT2 */ | |
Return (Zero) | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
OperationRegion (ECID, SystemIO, 0x0257, One) | |
Field (ECID, ByteAcc, NoLock, Preserve) | |
{ | |
EC4D, 8 | |
} | |
OperationRegion (ECIC, SystemIO, 0x0258, One) | |
Field (ECIC, ByteAcc, NoLock, Preserve) | |
{ | |
EC4C, 8 | |
} | |
Method (WEIE, 0, Serialized) | |
{ | |
Store (0x64, Local0) | |
While (LEqual (And (EC4C, 0x02), 0x02)) | |
{ | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (Ones) | |
} | |
Decrement (Local0) | |
Sleep (0x05) | |
} | |
Return (Zero) | |
} | |
Method (WEOF, 0, Serialized) | |
{ | |
Store (0x64, Local0) | |
While (LNotEqual (And (EC4C, One), One)) | |
{ | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (Ones) | |
} | |
Decrement (Local0) | |
Sleep (0x05) | |
} | |
Return (Zero) | |
} | |
Method (WEOE, 0, NotSerialized) | |
{ | |
Store (0x64, Local0) | |
While (LEqual (And (EC4C, One), One)) | |
{ | |
If (LEqual (Local0, Zero)) | |
{ | |
Return (Ones) | |
} | |
Decrement (Local0) | |
Sleep (0x05) | |
Store (EC4D, Local1) | |
} | |
Return (Zero) | |
} | |
Method (ST83, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x83, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (ST84, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x84, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST85, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x85, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (ST86, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x86, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST87, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x87, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LEqual (Arg0, Zero)) | |
{ | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
} | |
Release (MU4T) | |
If (LEqual (Arg0, Zero)) | |
{ | |
Return (Local0) | |
} | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST8E, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x8E, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (ST95, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x95, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LEqual (Arg0, Zero)) | |
{ | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
} | |
Release (MU4T) | |
If (LEqual (Arg0, Zero)) | |
{ | |
Return (Local0) | |
} | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST98, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x98, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST9E, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x9E, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg2, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STA8, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xA8, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (ST9F, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x9F, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg2, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STA9, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xA9, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB0, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xB0, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB1, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xB1, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB2, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xB2, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (GBTT, 1, Serialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (EB0T, Local0) | |
} | |
Else | |
{ | |
Store (EB1T, Local0) | |
} | |
Return (Local0) | |
} | |
Method (WCMD, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg0, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Release (MUEC) | |
} | |
} | |
Method (DLY0, 1, Serialized) | |
{ | |
If (LNot (ECAV ())) | |
{ | |
Return (Ones) | |
} | |
Store (Ones, Local0) | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg0, CDT1) /* \_SB_.PCI0.LPCB.EC0_.CDT1 */ | |
Store (0x6B, CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Zero, CDT3) /* \_SB_.PCI0.LPCB.EC0_.CDT3 */ | |
Store (0xBB, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x7F, Local1) | |
While (LAnd (Local1, CMD1)) | |
{ | |
Sleep (One) | |
Decrement (Local1) | |
} | |
If (LEqual (CMD1, Zero)) | |
{ | |
Store (CDT1, Local0) | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Method (RRAM, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, Local0) | |
And (Local0, 0xFF, Local1) | |
ShiftRight (Local0, 0x08, Local0) | |
And (Local0, 0xFF, Local0) | |
Store (0x80, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Local0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Local1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEOF (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (EC4D, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (WRAM, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, Local0) | |
And (Local0, 0xFF, Local1) | |
ShiftRight (Local0, 0x08, Local0) | |
And (Local0, 0xFF, Local0) | |
Store (0x81, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Local0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Local1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg1, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (One, Local0) | |
Release (MU4T) | |
Return (Local0) | |
} | |
Return (Ones) | |
} | |
Method (STBR, 0, Serialized) | |
{ | |
Store (Zero, Local0) | |
Store (Zero, Local1) | |
Store (Zero, Local2) | |
If (And (VGAF, One)) | |
{ | |
Store (One, Local0) | |
} | |
If (LAnd (Local0, ALDE)) | |
{ | |
Store (One, Local1) | |
} | |
If (Local0) | |
{ | |
Store (One, Local2) | |
} | |
If (Local1) | |
{ | |
ISMI (0x9A) | |
} | |
Else | |
{ | |
If (LEqual (Local2, One)) | |
{ | |
If (LNotEqual (MSOS (), OSEG)) | |
{ | |
If (LLess (MSOS (), OSW8)) | |
{ | |
Store (BRTI, Local4) | |
ShiftLeft (Local4, 0x04, Local4) | |
Store (LBTN, Local3) | |
Store (Add (Local4, Local3), Local3) | |
^^^GFX0.AINT (One, Divide (Multiply (DerefOf (Index (PWAC, Local3)), 0x64 | |
), 0xFF, )) | |
} | |
} | |
Else | |
{ | |
ISMI (0x9A) | |
} | |
} | |
Else | |
{ | |
If (LEqual (Local2, Zero)) | |
{ | |
If (LNot (ALAE)) | |
{ | |
ECCB () | |
} | |
} | |
Else | |
{ | |
If (LEqual (Local2, 0x02)) | |
{ | |
ISMI (0x9A) | |
} | |
Else | |
{ | |
} | |
} | |
} | |
} | |
} | |
Method (ECCB, 0, Serialized) | |
{ | |
If (LOr (ACAP (), LEqual (MSOS (), OSVT))) | |
{ | |
Store (LBTN, Local0) | |
} | |
Else | |
{ | |
Store (LBTN, Local0) | |
} | |
Store (BRTI, Local1) | |
ShiftLeft (Local1, 0x04, Local1) | |
Add (Local0, Local1, Local1) | |
Store (DerefOf (Index (PWAC, Local1)), Local0) | |
SADC (Local0) | |
} | |
Method (SBRV, 1, Serialized) | |
{ | |
ST86 (Zero, Arg0) | |
} | |
Name (DECF, Zero) | |
Method (SFNV, 2, Serialized) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
If (And (DECF, One)) | |
{ | |
Store (RRAM (0x0521), Local0) | |
Or (Local0, 0x80, Local0) | |
WRAM (0x0521, Local0) | |
} | |
If (And (DECF, 0x02)) | |
{ | |
Store (RRAM (0x0522), Local0) | |
Or (Local0, 0x80, Local0) | |
WRAM (0x0522, Local0) | |
} | |
Store (Zero, DECF) /* \_SB_.PCI0.LPCB.EC0_.DECF */ | |
Return (Zero) | |
} | |
If (LEqual (Arg0, One)) | |
{ | |
Store (RRAM (0x0521), Local0) | |
And (Local0, 0x7F, Local0) | |
WRAM (0x0521, Local0) | |
Or (DECF, One, DECF) /* \_SB_.PCI0.LPCB.EC0_.DECF */ | |
ST84 (Zero, Arg1) | |
Return (Zero) | |
} | |
If (LEqual (Arg0, 0x02)) | |
{ | |
Store (RRAM (0x0522), Local0) | |
And (Local0, 0x7F, Local0) | |
WRAM (0x0522, Local0) | |
Or (DECF, 0x02, DECF) /* \_SB_.PCI0.LPCB.EC0_.DECF */ | |
ST84 (One, Arg1) | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
Method (SADC, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If (LNotEqual (WEOE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0xFF, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (0x86, EC4C) /* \_SB_.PCI0.LPCB.EC0_.EC4C */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Zero, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Store (Arg0, EC4D) /* \_SB_.PCI0.LPCB.EC0_.EC4D */ | |
If (LNotEqual (WEIE (), Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (SPIN, 2, Serialized) | |
{ | |
If (Arg1) | |
{ | |
ST87 (0x20, Arg0) | |
} | |
Else | |
{ | |
ST87 (0x40, Arg0) | |
} | |
Return (One) | |
} | |
Method (RPIN, 1, Serialized) | |
{ | |
Store (ST87 (Zero, Arg0), Local1) | |
Return (Local1) | |
} | |
Method (RBAT, 2, Serialized) | |
{ | |
If (LNot (ECAV ())) | |
{ | |
Return (Ones) | |
} | |
Acquire (MUEC, 0xFFFF) | |
Store (0x03, Local0) | |
While (Local0) | |
{ | |
Store (Arg0, CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Arg1, Local1) | |
ShiftLeft (Local1, One, Local1) | |
Add (Local1, 0xDA, Local1) | |
Store (Local1, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x7F, Local1) | |
While (LAnd (CMD1, Local1)) | |
{ | |
Decrement (Local1) | |
Sleep (One) | |
} | |
If (LEqual (CMD1, Zero)) | |
{ | |
Store (CDT1, Local1) | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
Store (Ones, Local1) | |
Decrement (Local0) | |
} | |
} | |
Release (MUEC) | |
Return (Local1) | |
Return (Ones) | |
} | |
Method (WBAT, 3, Serialized) | |
{ | |
Or (Arg0, 0x80, Local3) | |
If (LNot (ECAV ())) | |
{ | |
Return (Ones) | |
} | |
Acquire (MUEC, 0xFFFF) | |
Store (0x03, Local0) | |
While (Local0) | |
{ | |
Store (Arg2, CDT1) /* \_SB_.PCI0.LPCB.EC0_.CDT1 */ | |
Store (Local3, CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Arg1, Local1) | |
ShiftLeft (Local1, One, Local1) | |
Add (Local1, 0xDA, Local1) | |
Store (Local1, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x7F, Local1) | |
While (LAnd (CMD1, Local1)) | |
{ | |
Decrement (Local1) | |
Sleep (One) | |
} | |
} | |
Release (MUEC) | |
Return (Local1) | |
Return (Ones) | |
} | |
Method (FNCT, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg0, CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Arg1, CDT1) /* \_SB_.PCI0.LPCB.EC0_.CDT1 */ | |
Store (0xC4, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x7F, Local0) | |
While (LAnd (Local0, CMD1)) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
Release (MUEC) | |
} | |
} | |
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 (PCLL, 0x0C) | |
Name (GOOD, Zero) | |
Name (UKER, 0x07) | |
Name (DAER, 0x10) | |
Name (CMDN, 0x12) | |
Name (UKE2, 0x13) | |
Name (DADN, 0x17) | |
Name (SBTO, 0x18) | |
Name (USPT, 0x19) | |
Name (SBBY, 0x1A) | |
Method (SWTC, 1, Serialized) | |
{ | |
Store (UKER, Local0) | |
Store (0x03, Local1) | |
While (LAnd (Local0, Local1)) | |
{ | |
Store (0x23, Local2) | |
While (Local2) | |
{ | |
If (PRTC) | |
{ | |
Sleep (One) | |
Decrement (Local2) | |
} | |
Else | |
{ | |
Store (Zero, Local2) | |
Store (SSTS, Local0) | |
} | |
} | |
If (Local0) | |
{ | |
Store (Zero, PRTC) /* \_SB_.PCI0.LPCB.EC0_.PRTC */ | |
Decrement (Local1) | |
If (Local1) | |
{ | |
Sleep (One) | |
Store (Arg0, PRTC) /* \_SB_.PCI0.LPCB.EC0_.PRTC */ | |
} | |
} | |
} | |
Return (Local0) | |
} | |
Method (SMBR, 3, Serialized) | |
{ | |
Store (Package (0x03) | |
{ | |
0x07, | |
Zero, | |
Zero | |
}, Local0) | |
If (LNot (ECAV ())) | |
{ | |
Return (Local0) | |
} | |
If (LNotEqual (Arg0, RDBL)) | |
{ | |
If (LNotEqual (Arg0, RDWD)) | |
{ | |
If (LNotEqual (Arg0, RDBT)) | |
{ | |
If (LNotEqual (Arg0, RCBT)) | |
{ | |
If (LNotEqual (Arg0, RDQK)) | |
{ | |
Return (Local0) | |
} | |
} | |
} | |
} | |
} | |
Acquire (MUEC, 0xFFFF) | |
Store (PRTC, Local1) | |
Store (Zero, Local2) | |
While (LNotEqual (Local1, Zero)) | |
{ | |
Stall (0x0A) | |
Increment (Local2) | |
If (LGreater (Local2, 0x03E8)) | |
{ | |
Store (SBBY, Index (Local0, Zero)) | |
Store (Zero, Local1) | |
} | |
Else | |
{ | |
Store (PRTC, Local1) | |
} | |
} | |
If (LLessEqual (Local2, 0x03E8)) | |
{ | |
ShiftLeft (Arg1, One, Local3) | |
Or (Local3, One, Local3) | |
Store (Local3, ADDR) /* \_SB_.PCI0.LPCB.EC0_.ADDR */ | |
If (LNotEqual (Arg0, RDQK)) | |
{ | |
If (LNotEqual (Arg0, RCBT)) | |
{ | |
Store (Arg2, CMDB) /* \_SB_.PCI0.LPCB.EC0_.CMDB */ | |
} | |
} | |
Store (Zero, BDAT) /* \_SB_.PCI0.LPCB.EC0_.BDAT */ | |
Store (Arg0, PRTC) /* \_SB_.PCI0.LPCB.EC0_.PRTC */ | |
Store (SWTC (Arg0), Index (Local0, Zero)) | |
If (LEqual (DerefOf (Index (Local0, Zero)), Zero)) | |
{ | |
If (LEqual (Arg0, RDBL)) | |
{ | |
Store (BCNT, Index (Local0, One)) | |
Store (BDAT, Index (Local0, 0x02)) | |
} | |
If (LEqual (Arg0, RDWD)) | |
{ | |
Store (0x02, Index (Local0, One)) | |
Store (DT2B, Index (Local0, 0x02)) | |
} | |
If (LEqual (Arg0, RDBT)) | |
{ | |
Store (One, Index (Local0, One)) | |
Store (DAT0, Index (Local0, 0x02)) | |
} | |
If (LEqual (Arg0, RCBT)) | |
{ | |
Store (One, Index (Local0, One)) | |
Store (DAT0, Index (Local0, 0x02)) | |
} | |
} | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Method (SMBW, 5, Serialized) | |
{ | |
Store (Package (0x01) | |
{ | |
0x07 | |
}, Local0) | |
If (LNot (ECAV ())) | |
{ | |
Return (Local0) | |
} | |
If (LNotEqual (Arg0, WRBL)) | |
{ | |
If (LNotEqual (Arg0, WRWD)) | |
{ | |
If (LNotEqual (Arg0, WRBT)) | |
{ | |
If (LNotEqual (Arg0, SDBT)) | |
{ | |
If (LNotEqual (Arg0, WRQK)) | |
{ | |
Return (Local0) | |
} | |
} | |
} | |
} | |
} | |
Acquire (MUEC, 0xFFFF) | |
Store (PRTC, Local1) | |
Store (Zero, Local2) | |
While (LNotEqual (Local1, Zero)) | |
{ | |
Stall (0x0A) | |
Increment (Local2) | |
If (LGreater (Local2, 0x03E8)) | |
{ | |
Store (SBBY, Index (Local0, Zero)) | |
Store (Zero, Local1) | |
} | |
Else | |
{ | |
Store (PRTC, Local1) | |
} | |
} | |
If (LLessEqual (Local2, 0x03E8)) | |
{ | |
Store (Zero, BDAT) /* \_SB_.PCI0.LPCB.EC0_.BDAT */ | |
ShiftLeft (Arg1, One, Local3) | |
Store (Local3, ADDR) /* \_SB_.PCI0.LPCB.EC0_.ADDR */ | |
If (LNotEqual (Arg0, WRQK)) | |
{ | |
If (LNotEqual (Arg0, SDBT)) | |
{ | |
Store (Arg2, CMDB) /* \_SB_.PCI0.LPCB.EC0_.CMDB */ | |
} | |
} | |
If (LEqual (Arg0, WRBL)) | |
{ | |
Store (Arg3, BCNT) /* \_SB_.PCI0.LPCB.EC0_.BCNT */ | |
Store (Arg4, BDAT) /* \_SB_.PCI0.LPCB.EC0_.BDAT */ | |
} | |
If (LEqual (Arg0, WRWD)) | |
{ | |
Store (Arg4, DT2B) /* \_SB_.PCI0.LPCB.EC0_.DT2B */ | |
} | |
If (LEqual (Arg0, WRBT)) | |
{ | |
Store (Arg4, DAT0) /* \_SB_.PCI0.LPCB.EC0_.DAT0 */ | |
} | |
If (LEqual (Arg0, SDBT)) | |
{ | |
Store (Arg4, DAT0) /* \_SB_.PCI0.LPCB.EC0_.DAT0 */ | |
} | |
Store (Arg0, PRTC) /* \_SB_.PCI0.LPCB.EC0_.PRTC */ | |
Store (SWTC (Arg0), Index (Local0, Zero)) | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Mutex (MUEP, 0x00) | |
Method (RBEP, 1, NotSerialized) | |
{ | |
Store (0xFFFF, Local1) | |
Acquire (MUEP, 0xFFFF) | |
Store (RRAM (0x0620), Local3) | |
And (Local3, 0x7F, Local4) | |
WRAM (0x0620, Local4) | |
Store (0x10, Local2) | |
Store (0x10, Local1) | |
While (And (LEqual (Local1, 0x10), LNotEqual (Local2, Zero))) | |
{ | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0635) | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0606) | |
Store (SMBR (RDBT, 0x50, Arg0), Local0) | |
Store (DerefOf (Index (Local0, Zero)), Local1) | |
Decrement (Local2) | |
} | |
WRAM (0x0620, Local3) | |
ShiftLeft (Local1, 0x08, Local1) | |
Or (Local1, DerefOf (Index (Local0, 0x02)), Local1) | |
Release (MUEP) | |
Return (Local1) | |
} | |
Method (WBEP, 2, NotSerialized) | |
{ | |
Store (0xFFFF, Local1) | |
Acquire (MUEP, 0xFFFF) | |
Store (RRAM (0x0620), Local3) | |
And (Local3, 0x7F, Local4) | |
WRAM (0x0620, Local4) | |
Store (0x10, Local2) | |
Store (0x10, Local1) | |
While (And (LEqual (Local1, 0x10), LNotEqual (Local2, Zero))) | |
{ | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0635) | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0606) | |
Store (SMBW (WRBT, 0x50, Arg0, One, Arg1), Local0) | |
Store (DerefOf (Index (Local0, Zero)), Local1) | |
Decrement (Local2) | |
} | |
WRAM (0x0620, Local3) | |
Release (MUEP) | |
Return (Local1) | |
} | |
Method (ECXT, 6, NotSerialized) | |
{ | |
Store (Package (0x06) | |
{ | |
0x10, | |
Zero, | |
Zero, | |
Zero, | |
Zero, | |
Zero | |
}, Local1) | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg1, CDT1) /* \_SB_.PCI0.LPCB.EC0_.CDT1 */ | |
Store (Arg2, CDT2) /* \_SB_.PCI0.LPCB.EC0_.CDT2 */ | |
Store (Arg3, CDT3) /* \_SB_.PCI0.LPCB.EC0_.CDT3 */ | |
Store (Arg4, CDT4) /* \_SB_.PCI0.LPCB.EC0_.CDT4 */ | |
Store (Arg5, CDT5) /* \_SB_.PCI0.LPCB.EC0_.CDT5 */ | |
Store (Arg0, CMD1) /* \_SB_.PCI0.LPCB.EC0_.CMD1 */ | |
Store (0x7F, Local0) | |
While (LAnd (Local0, CMD1)) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
If (Local0) | |
{ | |
Store (Zero, Index (Local1, Zero)) | |
Store (CDT1, Index (Local1, One)) | |
Store (CDT2, Index (Local1, 0x02)) | |
Store (CDT3, Index (Local1, 0x03)) | |
Store (CDT4, Index (Local1, 0x04)) | |
Store (CDT5, Index (Local1, 0x05)) | |
} | |
Else | |
{ | |
Store (0x10, Index (Local1, Zero)) | |
} | |
Release (MUEC) | |
} | |
Return (Local1) | |
} | |
Method (ECSB, 7, NotSerialized) | |
{ | |
Store (Package (0x05) | |
{ | |
0x11, | |
Zero, | |
Zero, | |
Zero, | |
Buffer (0x20) {} | |
}, Local1) | |
If (LGreater (Arg0, One)) | |
{ | |
Return (Local1) | |
} | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (PRTC, Local0) | |
} | |
Else | |
{ | |
Store (PRT2, Local0) | |
} | |
Store (Zero, Local2) | |
While (LNotEqual (Local0, Zero)) | |
{ | |
Stall (0x0A) | |
Increment (Local2) | |
If (LGreater (Local2, 0x03E8)) | |
{ | |
Store (SBBY, Index (Local1, Zero)) | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (PRTC, Local0) | |
} | |
Else | |
{ | |
Store (PRT2, Local0) | |
} | |
} | |
} | |
If (LLessEqual (Local2, 0x03E8)) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (Arg2, ADDR) /* \_SB_.PCI0.LPCB.EC0_.ADDR */ | |
Store (Arg3, CMDB) /* \_SB_.PCI0.LPCB.EC0_.CMDB */ | |
If (LOr (LEqual (Arg1, 0x0A), LEqual (Arg1, 0x0B))) | |
{ | |
Store (DerefOf (Index (Arg6, Zero)), BCNT) /* \_SB_.PCI0.LPCB.EC0_.BCNT */ | |
Store (DerefOf (Index (Arg6, One)), BDAT) /* \_SB_.PCI0.LPCB.EC0_.BDAT */ | |
} | |
Else | |
{ | |
Store (Arg4, DAT0) /* \_SB_.PCI0.LPCB.EC0_.DAT0 */ | |
Store (Arg5, DAT1) /* \_SB_.PCI0.LPCB.EC0_.DAT1 */ | |
} | |
Store (Arg1, PRTC) /* \_SB_.PCI0.LPCB.EC0_.PRTC */ | |
} | |
Else | |
{ | |
Store (Arg2, ADD2) /* \_SB_.PCI0.LPCB.EC0_.ADD2 */ | |
Store (Arg3, CMD2) /* \_SB_.PCI0.LPCB.EC0_.CMD2 */ | |
If (LOr (LEqual (Arg1, 0x0A), LEqual (Arg1, 0x0B))) | |
{ | |
Store (DerefOf (Index (Arg6, Zero)), BCN2) /* \_SB_.PCI0.LPCB.EC0_.BCN2 */ | |
Store (DerefOf (Index (Arg6, One)), BDA2) /* \_SB_.PCI0.LPCB.EC0_.BDA2 */ | |
} | |
Else | |
{ | |
Store (Arg4, DA20) /* \_SB_.PCI0.LPCB.EC0_.DA20 */ | |
Store (Arg5, DA21) /* \_SB_.PCI0.LPCB.EC0_.DA21 */ | |
} | |
Store (Arg1, PRT2) /* \_SB_.PCI0.LPCB.EC0_.PRT2 */ | |
} | |
Store (0x7F, Local0) | |
If (LEqual (Arg0, Zero)) | |
{ | |
While (PRTC) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
} | |
Else | |
{ | |
While (PRT2) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
} | |
If (Local0) | |
{ | |
If (LEqual (Arg0, Zero)) | |
{ | |
Store (SSTS, Local0) | |
Store (DAT0, Index (Local1, One)) | |
Store (DAT1, Index (Local1, 0x02)) | |
Store (BCNT, Index (Local1, 0x03)) | |
Store (BDAT, Index (Local1, 0x04)) | |
} | |
Else | |
{ | |
Store (SST2, Local0) | |
Store (DA20, Index (Local1, One)) | |
Store (DA21, Index (Local1, 0x02)) | |
Store (BCN2, Index (Local1, 0x03)) | |
Store (BDA2, Index (Local1, 0x04)) | |
} | |
And (Local0, 0x1F, Local0) | |
If (Local0) | |
{ | |
Add (Local0, 0x10, Local0) | |
} | |
Store (Local0, Index (Local1, Zero)) | |
} | |
Else | |
{ | |
Store (0x10, Index (Local1, Zero)) | |
} | |
} | |
Release (MUEC) | |
} | |
Return (Local1) | |
} | |
Method (TPSW, 1, NotSerialized) | |
{ | |
And (Arg0, One, Local0) | |
If (Local0) | |
{ | |
ECXT (0xB6, 0xB8, One, One, Zero, Zero) | |
} | |
Else | |
{ | |
ECXT (0xB6, 0xB8, One, 0x02, Zero, Zero) | |
} | |
} | |
Method (TPST, 0, NotSerialized) | |
{ | |
Store (ECXT (0xB6, 0xB8, 0x02, Zero, Zero, Zero), Local0) | |
Store (DerefOf (Index (Local0, One)), Local1) | |
If (LEqual (Local1, Zero)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (LBSW, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
ECXT (0xB6, 0xB9, One, Zero, Zero, Zero) | |
} | |
Else | |
{ | |
ECXT (0xB6, 0xB9, 0x02, Zero, Zero, Zero) | |
} | |
} | |
Method (LBST, 0, NotSerialized) | |
{ | |
Store (RRAM (0x044A), Local0) | |
And (Local0, 0x03, Local0) | |
Return (Local0) | |
} | |
Method (TALS, 1, NotSerialized) | |
{ | |
And (LSTP, One, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
If (Arg0) | |
{ | |
Store (ST8E (0x30, Zero), Local0) | |
Or (Local0, 0x90, Local0) | |
ST9E (0x30, 0xFF, Local0) | |
} | |
Else | |
{ | |
Store (ST8E (0x30, Zero), Local0) | |
And (Local0, 0x6F, Local0) | |
ST9E (0x30, 0xFF, Local0) | |
} | |
} | |
Else | |
{ | |
If (Arg0) | |
{ | |
Store (RRAM (0x04CD), Local0) | |
And (Local0, 0xF1, Local0) | |
Or (Local0, 0x02, Local0) | |
WRAM (0x04CD, Local0) | |
} | |
Else | |
{ | |
Store (RRAM (0x04CD), Local0) | |
And (Local0, 0xFD, Local0) | |
WRAM (0x04CD, Local0) | |
} | |
} | |
} | |
Method (RALS, 0, NotSerialized) | |
{ | |
And (LSTP, One, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
If (ALAE) | |
{ | |
Store (RRAM (0x02A3), Local0) | |
Store (RRAM (0x02A4), Local1) | |
ShiftLeft (Local0, 0x08, Local0) | |
Add (Local0, Local1, Local0) | |
Multiply (Local0, 0x03E8, Local1) | |
Divide (Local1, ALSA, Local2, Local3) | |
Return (Local3) | |
} | |
Else | |
{ | |
Return (0x012C) | |
} | |
} | |
Else | |
{ | |
If (ALAE) | |
{ | |
Store (RRAM (0x04C9), Local0) | |
If (LLessEqual (Local0, One)) | |
{ | |
Store (0x32, Local1) | |
} | |
Else | |
{ | |
If (LLessEqual (Local0, 0x06)) | |
{ | |
Store (0xC8, Local1) | |
} | |
Else | |
{ | |
If (LLessEqual (Local0, 0x0A)) | |
{ | |
Store (0x0190, Local1) | |
} | |
Else | |
{ | |
If (LLessEqual (Local0, 0x0E)) | |
{ | |
Store (0x0258, Local1) | |
} | |
Else | |
{ | |
Store (0x0320, Local1) | |
} | |
} | |
} | |
} | |
Return (Local1) | |
} | |
Else | |
{ | |
Return (0xC8) | |
} | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Name (TSP, 0x0A) | |
Name (TC1, 0x02) | |
Name (TC2, 0x0A) | |
} | |
Scope (_TZ) | |
{ | |
Method (KELV, 1, NotSerialized) | |
{ | |
And (Arg0, 0xFF, Local0) | |
If (LGreaterEqual (Local0, 0x80)) | |
{ | |
Subtract (0x0100, Local0, Local0) | |
Multiply (Local0, 0x0A, Local0) | |
Subtract (0x0AAC, Local0, Local0) | |
Return (Local0) | |
} | |
Multiply (Local0, 0x0A, Local0) | |
Add (Local0, 0x0AAC, Local0) | |
Return (Local0) | |
} | |
Method (CELC, 1, NotSerialized) | |
{ | |
Subtract (Arg0, 0x0AAC, Local0) | |
Divide (Local0, 0x0A, Local1, Local0) | |
Return (Local0) | |
} | |
Name (PLCY, Zero) | |
ThermalZone (THRM) | |
{ | |
Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature | |
{ | |
RCRT () | |
Return (KELV (\_SB.TCRT)) | |
} | |
Method (_TMP, 0, NotSerialized) // _TMP: Temperature | |
{ | |
Store (0x05, Local1) | |
While (Local1) | |
{ | |
Store (RTMP (), Local0) | |
If (LGreater (Local0, \_SB.TCRT)) | |
{ | |
Decrement (Local1) | |
} | |
Else | |
{ | |
Store (Zero, Local1) | |
} | |
} | |
Return (KELV (Local0)) | |
} | |
Name (_PSL, Package (0x04) // _PSL: Passive List | |
{ | |
\_PR.CPU0, | |
\_PR.CPU1, | |
\_PR.CPU2, | |
\_PR.CPU3 | |
}) | |
Method (_TSP, 0, NotSerialized) // _TSP: Thermal Sampling Period | |
{ | |
Multiply (TSP, 0x0A, Local0) | |
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 (\_SB.PPSV)) | |
} | |
Else | |
{ | |
Return (KELV (\_SB.TPSV)) | |
} | |
} | |
Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy | |
{ | |
Store (Zero, PLCY) /* \_TZ_.PLCY */ | |
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.LPCB.EC0.ECAV ()) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ECPU, Local0) | |
If (LLess (Local0, 0x80)) | |
{ | |
Store (Local0, LTMP) /* \_TZ_.LTMP */ | |
} | |
} | |
Return (LTMP) /* \_TZ_.LTMP */ | |
} | |
Method (RCRT, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.LPCB.EC0.ECAV ()) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ECRT, Local0) | |
If (LLess (Local0, 0x80)) | |
{ | |
Store (Local0, \_SB.TCRT) | |
} | |
} | |
} | |
Method (RPSV, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.LPCB.EC0.ECAV ()) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.EPSV, Local0) | |
If (LLess (Local0, 0x80)) | |
{ | |
Store (Local0, \_SB.TPSV) | |
} | |
} | |
} | |
Method (RFAN, 1, NotSerialized) | |
{ | |
If (\_SB.PCI0.LPCB.EC0.ECAV ()) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ST83 (Arg0), Local0) | |
If (LEqual (Local0, 0xFF)) | |
{ | |
Return (Local0) | |
} | |
Store (\_SB.PCI0.LPCB.EC0.TACH (Arg0), Local0) | |
Divide (Local0, 0x64, Local1, Local0) | |
Add (Local0, One, Local0) | |
If (LLessEqual (Local0, 0x3C)) | |
{ | |
Store (Local0, FANS) /* \_TZ_.FANS */ | |
} | |
Else | |
{ | |
Store (FANS, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
Return (Local0) | |
} | |
Method (RFSE, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.LPCB.EC0.ECAV ()) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ST83 (Zero), Local1) | |
If (LLess (Local1, 0x80)) | |
{ | |
If (LLess (Local1, 0x0A)) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
Store (One, Local0) | |
} | |
} | |
Else | |
{ | |
If (LLess (Local1, 0xF5)) | |
{ | |
Store (0x02, Local0) | |
} | |
Else | |
{ | |
Store (0x03, Local0) | |
} | |
} | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
Return (Local0) | |
} | |
Method (TCHG, 0, NotSerialized) | |
{ | |
} | |
Method (THDL, 0, NotSerialized) | |
{ | |
} | |
Method (TMSS, 1, NotSerialized) | |
{ | |
} | |
Method (TMSW, 1, NotSerialized) | |
{ | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Name (PWAC, Buffer (0x40) | |
{ | |
/* 0000 */ 0x1B, 0x21, 0x2F, 0x40, 0x4D, 0x5F, 0x6D, 0x7B, /* .!/@M_m{ */ | |
/* 0008 */ 0x9A, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* ........ */ | |
/* 0010 */ 0x0E, 0x21, 0x2F, 0x40, 0x4E, 0x5F, 0x6D, 0x7B, /* .!/@N_m{ */ | |
/* 0018 */ 0x9A, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* ........ */ | |
/* 0020 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* ........ */ | |
/* 0028 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* ........ */ | |
/* 0030 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* ........ */ | |
/* 0038 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF /* ........ */ | |
}) | |
Name (F8FG, Zero) | |
Name (ORFG, Zero) | |
Name (BLCT, Zero) | |
Method (ACPS, 0, Serialized) | |
{ | |
Return (And (GPWS (), One)) | |
} | |
Method (DCPS, 1, Serialized) | |
{ | |
Store (GPWS (), Local0) | |
If (Arg0) | |
{ | |
And (Local0, 0x04, Local0) | |
} | |
Else | |
{ | |
And (Local0, 0x02, Local0) | |
} | |
If (Local0) | |
{ | |
Store (One, Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
Return (Local0) | |
} | |
Method (GPWS, 0, Serialized) | |
{ | |
Store (EPWS, Local0) | |
Return (Local0) | |
} | |
Method (BCHG, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
If (ECAV ()) | |
{ | |
Store (EB1S, Local0) | |
And (Local0, 0xFF, Local0) | |
If (LNotEqual (Local0, 0xFF)) | |
{ | |
And (Local0, 0x02, Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
Return (Local0) | |
} | |
Else | |
{ | |
If (ECAV ()) | |
{ | |
Store (EB0S, Local0) | |
And (Local0, 0xFF, Local0) | |
If (LNotEqual (Local0, 0xFF)) | |
{ | |
And (Local0, 0x02, Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
Return (Local0) | |
} | |
} | |
Method (BCLE, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
If (ECAV ()) | |
{ | |
Store (Ones, Local0) | |
Store (EB1S, Local1) | |
And (Local1, 0xFFFF, Local1) | |
If (LNotEqual (Local1, 0xFFFF)) | |
{ | |
And (Local1, 0x16, Local1) | |
If (LEqual (Local1, 0x04)) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x02)) | |
{ | |
Store (One, Local0) | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x10)) | |
{ | |
Store (One, Local0) | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
Else | |
{ | |
If (ECAV ()) | |
{ | |
Store (Ones, Local0) | |
Store (EB0S, Local1) | |
And (Local1, 0xFFFF, Local1) | |
If (LNotEqual (Local1, 0xFFFF)) | |
{ | |
And (Local1, 0x16, Local1) | |
If (LEqual (Local1, 0x04)) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x02)) | |
{ | |
Store (One, Local0) | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x10)) | |
{ | |
Store (One, Local0) | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Return (Local0) | |
} | |
} | |
Method (CHBT, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Store (GBTT (Arg0), Local1) | |
If (LEqual (Local1, 0xFF)) | |
{ | |
Store (Zero, Local0) | |
} | |
Else | |
{ | |
And (Local1, 0x10, Local0) | |
If (Local0) | |
{ | |
Store (One, Local0) | |
} | |
} | |
} | |
Else | |
{ | |
Store (DCTP, Local0) | |
} | |
Return (Local0) | |
} | |
Method (TACH, 1, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (ECAV ()) | |
{ | |
While (One) | |
{ | |
Store (Arg0, _T_0) /* \_SB_.PCI0.LPCB.EC0_.TACH._T_0 */ | |
If (LEqual (_T_0, Zero)) | |
{ | |
Store (TAH0, Local0) | |
Break | |
} | |
Else | |
{ | |
If (LEqual (_T_0, One)) | |
{ | |
Store (TAH1, Local0) | |
Break | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Break | |
} | |
Multiply (Local0, 0x02, Local0) | |
If (LNotEqual (Local0, Zero)) | |
{ | |
Divide (0x0041CDB4, Local0, Local1, Local0) | |
Return (Local0) | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Name (HKFG, Zero) | |
Name (KBST, Zero) | |
Name (KBBR, Zero) | |
Name (ALST, Zero) | |
Method (EC0S, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
Store (RRAM (0x0449), KBST) /* \_SB_.PCI0.LPCB.EC0_.KBST */ | |
Store (RRAM (0x044B), KBBR) /* \_SB_.PCI0.LPCB.EC0_.KBBR */ | |
} | |
If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04))) | |
{ | |
Store (RRAM (0x0449), Local0) | |
And (Local0, 0x02, Local1) | |
If (Local1) | |
{ | |
WRAM (0x044B, Zero) | |
And (Local0, 0xFA, Local1) | |
WRAM (0x0449, Local1) | |
} | |
Store (RRAM (0x04CD), ALST) /* \_SB_.PCI0.LPCB.EC0_.ALST */ | |
} | |
If (LEqual (Arg0, 0x05)) | |
{ | |
Store (RRAM (0x0449), Local0) | |
And (Local0, 0x02, Local1) | |
If (Local1) | |
{ | |
WRAM (0x044B, Zero) | |
} | |
} | |
If (LGreater (Arg0, 0x04)) {} | |
Store (HKEN, HKFG) /* \_SB_.PCI0.LPCB.EC0_.HKFG */ | |
} | |
Method (EC0W, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x03)) | |
{ | |
WRAM (0x0449, KBST) | |
WRAM (0x044B, KBBR) | |
Store (ST8E (0x05, Zero), Local0) | |
And (Local0, 0xFF, Local1) | |
Store (ST8E (Zero, Zero), Local0) | |
And (Local0, 0x40, Local2) | |
If (LEqual (Local1, 0x31)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x32)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x33)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x3D)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
Else | |
{ | |
If (LEqual (Local1, 0x3E)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
Else | |
{ | |
If (LEqual (Local2, 0x40)) | |
{ | |
Notify (PWRB, 0x02) // Device Wake | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
If (LLessEqual (Arg0, 0x04)) | |
{ | |
Store (DCPS (Zero), DCPF) /* \_SB_.DCPF */ | |
Store (ACPS (), Local0) | |
If (LNotEqual (Local0, ACPF)) | |
{ | |
Store (ACPS (), ACPF) /* \_SB_.ACPF */ | |
PNOT () | |
} | |
} | |
If (LOr (LEqual (Arg0, 0x03), LEqual (Arg0, 0x04))) | |
{ | |
And (LSTP, One, Local0) | |
If (LEqual (Local0, Zero)) | |
{ | |
If (ALAE) | |
{ | |
TALS (One) | |
If (LEqual (MSOS (), OSW7)) | |
{ | |
Store (RALS (), Local0) | |
^^^GFX0.AINT (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (MSOS (), OSW8)) | |
{ | |
Notify (ALS, 0x80) // Status Change | |
} | |
} | |
} | |
} | |
Else | |
{ | |
WRAM (0x04CD, ALST) | |
Store (RRAM (0x04CD), Local0) | |
And (Local0, 0xFE, Local0) | |
WRAM (0x04CD, Local0) | |
} | |
Store (RRAM (0x0449), Local0) | |
And (Local0, 0x02, Local1) | |
If (Local1) | |
{ | |
Or (Local0, One, Local0) | |
WRAM (0x0449, Local0) | |
} | |
} | |
If (LEqual (Arg0, 0x05)) {} | |
Store (HKFG, HKEN) /* \_SB_.PCI0.LPCB.EC0_.HKEN */ | |
If (And (WOLO, One)) | |
{ | |
Store (0x0580, Local0) | |
Add (Local0, 0x03, Local0) | |
Store (RRAM (Local0), Local1) | |
Or (Local1, 0x05, Local1) | |
WRAM (Local0, Local1) | |
} | |
If (And (DSYN, One)) | |
{ | |
ST9F (0x2B, 0x20, 0x20) | |
} | |
} | |
Name (FHKM, One) | |
Method (FHKW, 0, Serialized) | |
{ | |
While (LNot (FHKM)) | |
{ | |
Sleep (0x0A) | |
} | |
Store (Zero, FHKM) /* \_SB_.PCI0.LPCB.EC0_.FHKM */ | |
} | |
Method (FHKS, 0, Serialized) | |
{ | |
Store (One, FHKM) /* \_SB_.PCI0.LPCB.EC0_.FHKM */ | |
} | |
Method (_Q01, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x52) | |
} | |
} | |
Method (_Q02, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x53) | |
} | |
} | |
Method (_Q03, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x54) | |
} | |
} | |
Method (_Q04, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x55) | |
} | |
} | |
Method (_Q05, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x56) | |
} | |
} | |
Method (_Q0A, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (SLPB, 0x80) // Status Change | |
} | |
Method (_Q0B, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (_OSI ("Windows 2012")) | |
{ | |
Notify (ASHS, 0x88) // Device-Specific | |
} | |
Else | |
{ | |
If (And (^^^^ATKD.WAPF, 0x04)) | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x88) | |
} | |
} | |
Else | |
{ | |
Store (OHWR (), Local0) | |
If (And (Local0, 0x02)) | |
{ | |
If (And (Local0, One)) | |
{ | |
Store (One, Local0) | |
} | |
Else | |
{ | |
Store (Zero, Local0) | |
} | |
} | |
Else | |
{ | |
Store (One, Local0) | |
} | |
If (Local0) | |
{ | |
If (And (^^^^ATKD.WAPF, One)) | |
{ | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Store (WRST, Local0) | |
Or (ShiftLeft (BRST, One), Local0, Local0) | |
Increment (Local0) | |
If (LGreater (Local0, 0x03)) | |
{ | |
Store (Zero, Local0) | |
} | |
Store (DerefOf (Index (WBTL, Local0)), Local1) | |
If (LEqual (Local1, Zero)) | |
{ | |
^^^^ATKD.IANE (0x74) | |
OWLD (Zero) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
} | |
If (LEqual (Local1, One)) | |
{ | |
^^^^ATKD.IANE (0x73) | |
OWLD (One) | |
Sleep (0x0DAC) | |
OBTD (One) | |
} | |
If (LEqual (Local1, 0x02)) | |
{ | |
^^^^ATKD.IANE (0x74) | |
OWLD (Zero) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
} | |
If (LEqual (Local1, 0x03)) | |
{ | |
^^^^ATKD.IANE (0x74) | |
OWLD (Zero) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
^^^^ATKD.IANE (0x5D) | |
} | |
Else | |
{ | |
If (BTDP) | |
{ | |
If (BRST) | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
Else | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Store (WRST, Local0) | |
Or (ShiftLeft (BRST, One), Local0, Local0) | |
Increment (Local0) | |
If (LGreater (Local0, 0x03)) | |
{ | |
Store (Zero, Local0) | |
} | |
Store (DerefOf (Index (WBTL, Local0)), Local1) | |
If (LEqual (Local1, Zero)) | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
If (LEqual (Local1, One)) | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
If (LEqual (Local1, 0x02)) | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
Sleep (0x0DAC) | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
If (LEqual (Local1, 0x03)) | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
Sleep (0x0DAC) | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
If (WRST) | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
} | |
Else | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
} | |
} | |
Else | |
{ | |
If (BTDP) | |
{ | |
If (BRST) | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
Else | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
If (WLDP) {} | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
} | |
} | |
Name (WBTL, Package (0x04) | |
{ | |
Zero, | |
One, | |
0x02, | |
0x03 | |
}) | |
Method (_Q0C, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
^^^^ATKD.IANE (0xC5) | |
} | |
Method (_Q0D, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
^^^^ATKD.IANE (0xC4) | |
} | |
Name (ASBN, Zero) | |
Method (SBRN, 0, Serialized) | |
{ | |
If (^^^GFX0.PRST ()) | |
{ | |
Store (^^^GFX0.GCBL (^^^GFX0.CBLV), Local0) | |
Subtract (0x0A, Local0, Local1) | |
If (LNotEqual (Local1, LBTN)) | |
{ | |
Store (Local1, LBTN) /* \_SB_.LBTN */ | |
} | |
} | |
} | |
Method (_Q0E, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LLess (MSOS (), OSW8)) | |
{ | |
SBRN () | |
} | |
If (LGreaterEqual (MSOS (), OSVT)) | |
{ | |
Store (LBTN, Local0) | |
If (^^^GFX0.PRST ()) | |
{ | |
If (LNotEqual (^^^GFX0.LCDD._DCS (), 0x1F)) | |
{ | |
Return (One) | |
} | |
^^^GFX0.DWBL () | |
Store (One, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
} | |
If (^^^PEG0.PEGP.PRST ()) | |
{ | |
If (LNot (ASBN)) | |
{ | |
If (LNotEqual (^^^PEG0.PEGP.LCDD._DCS (), 0x1F)) | |
{ | |
Return (One) | |
} | |
^^^PEG0.PEGP.DWBL () | |
Store (One, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
} | |
} | |
Store (Zero, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
If (ATKP) | |
{ | |
If (LEqual (^^^GFX0.HGCK, One)) | |
{ | |
Return (One) | |
} | |
If (LGreaterEqual (MSOS (), OSW8)) {} | |
Else | |
{ | |
If (LGreater (Local0, Zero)) | |
{ | |
Decrement (Local0) | |
} | |
If (LGreater (Local0, 0x0A)) | |
{ | |
Store (0x0A, Local0) | |
} | |
Store (Local0, LBTN) /* \_SB_.LBTN */ | |
^^^^ATKD.IANE (Add (Local0, 0x20)) | |
} | |
} | |
} | |
Else | |
{ | |
If (LGreater (LBTN, Zero)) | |
{ | |
Decrement (LBTN) | |
} | |
If (LGreater (LBTN, 0x0A)) | |
{ | |
Store (0x0A, LBTN) /* \_SB_.LBTN */ | |
} | |
STBR () | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (Add (LBTN, 0x20)) | |
} | |
} | |
Return (One) | |
} | |
Method (_Q0F, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LLess (MSOS (), OSW8)) | |
{ | |
SBRN () | |
} | |
If (LGreaterEqual (MSOS (), OSVT)) | |
{ | |
Store (LBTN, Local0) | |
If (^^^GFX0.PRST ()) | |
{ | |
If (LNotEqual (^^^GFX0.LCDD._DCS (), 0x1F)) | |
{ | |
Return (One) | |
} | |
^^^GFX0.UPBL () | |
Store (One, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
} | |
If (^^^PEG0.PEGP.PRST ()) | |
{ | |
If (LNot (ASBN)) | |
{ | |
If (LNotEqual (^^^PEG0.PEGP.LCDD._DCS (), 0x1F)) | |
{ | |
Return (One) | |
} | |
^^^PEG0.PEGP.UPBL () | |
Store (One, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
} | |
} | |
Store (Zero, ASBN) /* \_SB_.PCI0.LPCB.EC0_.ASBN */ | |
If (ATKP) | |
{ | |
If (LEqual (^^^GFX0.HGCK, One)) | |
{ | |
Return (One) | |
} | |
If (LGreaterEqual (MSOS (), OSW8)) {} | |
Else | |
{ | |
If (LLess (Local0, 0x0A)) | |
{ | |
Increment (Local0) | |
} | |
Else | |
{ | |
Store (0x0A, Local0) | |
} | |
Store (Local0, LBTN) /* \_SB_.LBTN */ | |
^^^^ATKD.IANE (Add (Local0, 0x10)) | |
} | |
} | |
} | |
Else | |
{ | |
If (LLess (LBTN, 0x0A)) | |
{ | |
Increment (LBTN) | |
} | |
Else | |
{ | |
Store (0x0A, LBTN) /* \_SB_.LBTN */ | |
} | |
STBR () | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (Add (LBTN, 0x10)) | |
} | |
} | |
Return (One) | |
} | |
Method (_Q10, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LEqual (BLCT, Zero)) | |
{ | |
Store (One, Local0) | |
Store (RPIN (0x72), Local0) | |
XOr (Local0, One, Local0) | |
SPIN (0x72, Local0) | |
If (ATKP) | |
{ | |
Subtract (0x34, Local0, Local0) | |
^^^^ATKD.IANE (Local0) | |
} | |
} | |
Else | |
{ | |
If (LEqual (BLCT, One)) | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x35) | |
} | |
} | |
} | |
} | |
Method (_Q11, 0, Serialized) // _Qxx: EC Query | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
If (LEqual (F8FG, Zero)) | |
{ | |
Store (One, F8FG) /* \_SB_.PCI0.LPCB.EC0_.F8FG */ | |
STB2 (0xE0) | |
STB2 (0x5B) | |
} | |
STB2 (0x19) | |
STB2 (0x99) | |
Return (One) | |
} | |
If (LEqual (ORFG, One)) | |
{ | |
If (LEqual (F8FG, Zero)) | |
{ | |
Store (One, F8FG) /* \_SB_.PCI0.LPCB.EC0_.F8FG */ | |
STB2 (0xE0) | |
STB2 (0x5B) | |
} | |
STB2 (0x19) | |
STB2 (0x99) | |
Return (One) | |
} | |
If (LEqual (^^^GFX0.HGCK, One)) | |
{ | |
Return (One) | |
} | |
FHKW () | |
Store (ADVG (), Local0) | |
If (NATK ()) | |
{ | |
If (LLess (Local0, 0x08)) | |
{ | |
Add (Local0, 0x60, Local1) | |
} | |
Else | |
{ | |
If (LLess (Local0, 0x10)) | |
{ | |
Subtract (Local0, 0x08, Local1) | |
Add (Local1, 0x8C, Local1) | |
} | |
Else | |
{ | |
If (LLess (Local0, 0x20)) | |
{ | |
And (Local0, 0x07, Local1) | |
Add (Local1, 0xA0, Local1) | |
} | |
Else | |
{ | |
If (LLess (Local0, 0x40)) | |
{ | |
While (One) | |
{ | |
Store (ToInteger (Local0), _T_0) /* \_SB_.PCI0.LPCB.EC0_._Q11._T_0 */ | |
If (LEqual (_T_0, 0x20)) | |
{ | |
Store (0xD0, Local1) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x21)) | |
{ | |
Store (0xD1, Local1) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x22)) | |
{ | |
Store (0xD2, Local1) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x24)) | |
{ | |
Store (0xD3, Local1) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x28)) | |
{ | |
Store (0xD4, Local1) | |
} | |
Else | |
{ | |
If (LEqual (_T_0, 0x30)) | |
{ | |
Store (0xD5, Local1) | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
} | |
} | |
} | |
If (ATKP) | |
{ | |
If (LNotEqual (Local1, 0x60)) | |
{ | |
^^^^ATKD.IANE (Local1) | |
} | |
} | |
Else | |
{ | |
SWHG (Local0) | |
} | |
} | |
Else | |
{ | |
SWHG (Local0) | |
} | |
FHKS () | |
} | |
Method (_Q12, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LNot (And (DSYN, One))) | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6B) | |
} | |
} | |
Else | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6F) | |
} | |
} | |
} | |
Method (_Q13, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x20) | |
STB2 (0xE0) | |
STB2 (0xA0) | |
Return (One) | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x32) | |
} | |
} | |
Method (_Q14, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x2E) | |
STB2 (0xE0) | |
STB2 (0xAE) | |
Return (One) | |
} | |
If (LLess (AVOL, 0x0F)) | |
{ | |
Increment (AVOL) | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x31) | |
} | |
} | |
Method (_Q15, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LGreaterEqual (MSOS (), OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x30) | |
STB2 (0xE0) | |
STB2 (0xB0) | |
Return (One) | |
} | |
If (LGreater (AVOL, Zero)) | |
{ | |
Decrement (AVOL) | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x30) | |
} | |
} | |
Method (_Q6F, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x45) | |
} | |
} | |
Method (_Q6E, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x43) | |
} | |
} | |
Method (_Q6C, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x40) | |
} | |
} | |
Method (_Q6D, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x41) | |
} | |
} | |
Method (_Q70, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
} | |
Method (_Q71, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x5C) | |
} | |
} | |
Method (_Q72, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x8A) | |
} | |
} | |
Method (_Q73, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x99) | |
} | |
} | |
Method (_Q74, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x82) | |
} | |
} | |
Method (_Q76, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x7A) | |
} | |
} | |
Method (_Q77, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0xB5) | |
} | |
} | |
Method (_Q85, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x5C) | |
} | |
} | |
Method (_Q84, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (OHWR (), Local0) | |
If (And (Local0, 0x02)) | |
{ | |
If (And (^^^^ATKD.WAPF, 0x04)) | |
{ | |
If (ATKP) | |
{ | |
If (And (Local0, One)) | |
{ | |
^^^^ATKD.IANE (0x80) | |
} | |
Else | |
{ | |
^^^^ATKD.IANE (0x81) | |
} | |
} | |
} | |
Else | |
{ | |
If (And (^^^^ATKD.WAPF, One)) | |
{ | |
If (And (Local0, One)) | |
{ | |
If (WLDP) | |
{ | |
If (LEqual (And (^^^RP02.WLAN.VNUM, 0xFFFF), 0x8086)) | |
{ | |
Sleep (0x09C4) | |
} | |
If (LEqual (WRPS, One)) | |
{ | |
^^^^ATKD.IANE (0x5E) | |
} | |
Else | |
{ | |
^^^^ATKD.IANE (0x5F) | |
} | |
} | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
If (BRPS) | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
Else | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
Store (WRST, WRPS) /* \_SB_.WRPS */ | |
^^^^ATKD.IANE (0x5F) | |
} | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
Store (BRST, BRPS) /* \_SB_.BRPS */ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If (And (Local0, One)) | |
{ | |
If (WLDP) | |
{ | |
If (WRPS) | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
} | |
Else | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
} | |
} | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
If (BRPS) | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
Else | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
Store (WRST, WRPS) /* \_SB_.WRPS */ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
} | |
If (LAnd (WLDP, BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
Store (BRST, BRPS) /* \_SB_.BRPS */ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
} | |
} | |
} | |
Name (OLUX, 0xFF) | |
Method (_QDD, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (RALS (), Local0) | |
Store (RRAM (0x04C9), Local1) | |
If (LNotEqual (OLUX, Local1)) | |
{ | |
If (LEqual (MSOS (), OSW7)) | |
{ | |
^^^GFX0.AINT (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (MSOS (), OSW8)) | |
{ | |
Notify (ALS, 0x80) // Status Change | |
} | |
} | |
If (ATKP) | |
{ | |
Store (Zero, Local2) | |
If (LAnd (LLessEqual (OLUX, One), LGreater (Local1, One))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LLessEqual (OLUX, 0x07), LGreater (Local1, 0x07))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LGreaterEqual (OLUX, 0x07), LLess (Local1, 0x07))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LGreaterEqual (OLUX, One), LLess (Local1, One))) | |
{ | |
Store (One, Local2) | |
} | |
} | |
} | |
} | |
If (Local2) | |
{ | |
^^^^ATKD.IANE (0xC6) | |
} | |
} | |
} | |
Store (Local1, OLUX) /* \_SB_.PCI0.LPCB.EC0_.OLUX */ | |
} | |
Method (_QCD, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (RALS (), Local0) | |
Store (ST8E (0x31, Zero), Local1) | |
If (LNotEqual (OLUX, Local1)) | |
{ | |
If (LEqual (MSOS (), OSW7)) | |
{ | |
^^^GFX0.AINT (Zero, Local0) | |
} | |
Else | |
{ | |
If (LEqual (MSOS (), OSW8)) | |
{ | |
Notify (ALS, 0x80) // Status Change | |
} | |
} | |
If (ATKP) | |
{ | |
Store (Zero, Local2) | |
If (LAnd (LLessEqual (OLUX, One), LGreater (Local1, One))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LLessEqual (OLUX, 0x07), LGreater (Local1, 0x07))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LGreaterEqual (OLUX, 0x07), LLess (Local1, 0x07))) | |
{ | |
Store (One, Local2) | |
} | |
Else | |
{ | |
If (LAnd (LGreaterEqual (OLUX, One), LLess (Local1, One))) | |
{ | |
Store (One, Local2) | |
} | |
} | |
} | |
} | |
If (Local2) | |
{ | |
^^^^ATKD.IANE (0xC6) | |
} | |
} | |
Store (Local1, OLUX) /* \_SB_.PCI0.LPCB.EC0_.OLUX */ | |
} | |
} | |
Method (_QB0, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (\_TZ.THRM, 0x80) // Thermal Status Change | |
} | |
Method (_Q60, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
If (LEqual (PWKY, One)) | |
{ | |
^^^^ATKD.IANE (0xAC) | |
} | |
Else | |
{ | |
Notify (PWRB, 0x80) // Status Change | |
} | |
} | |
Else | |
{ | |
Notify (PWRB, 0x80) // Status Change | |
} | |
} | |
Method (_QA0, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ACPS ()) | |
{ | |
Store (One, ACPF) /* \_SB_.ACPF */ | |
Store (0x58, Local0) | |
} | |
Else | |
{ | |
Store (Zero, ACPF) /* \_SB_.ACPF */ | |
Store (0x57, Local0) | |
} | |
If (LNotEqual (MSOS (), OSVT)) | |
{ | |
STBR () | |
} | |
Notify (AC0, 0x80) // Status Change | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (Local0) | |
} | |
Sleep (0x64) | |
PNOT () | |
Sleep (0x0A) | |
NBAT (0x80) | |
} | |
Method (_Q20, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (CDFG) | |
{ | |
Store (One, SMBF) /* \_SB_.PCI0.LPCB.EC0_.SMBF */ | |
Store (Zero, CDFG) /* \_SB_.PCI0.LPCB.EC0_.CDFG */ | |
} | |
If (ALFG) | |
{ | |
Store (Zero, ALFG) /* \_SB_.PCI0.LPCB.EC0_.ALFG */ | |
} | |
} | |
Method (_QB3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
^^^^ATKD.IANE (0x6D) | |
} | |
Method (ECRS, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg0, ADD2) /* \_SB_.PCI0.LPCB.EC0_.ADD2 */ | |
Store (Arg1, CMD2) /* \_SB_.PCI0.LPCB.EC0_.CMD2 */ | |
Store (0x07, PRT2) /* \_SB_.PCI0.LPCB.EC0_.PRT2 */ | |
Store (0x7F, Local0) | |
While (PRT2) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
If (Local0) | |
{ | |
Store (DA20, Local0) | |
} | |
Else | |
{ | |
Store (Ones, Local0) | |
} | |
Release (MUEC) | |
} | |
Return (Local0) | |
} | |
Method (ECWS, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
Store (Arg0, ADD2) /* \_SB_.PCI0.LPCB.EC0_.ADD2 */ | |
Store (Arg1, CMD2) /* \_SB_.PCI0.LPCB.EC0_.CMD2 */ | |
Store (Arg2, DA20) /* \_SB_.PCI0.LPCB.EC0_.DA20 */ | |
Store (0x06, PRT2) /* \_SB_.PCI0.LPCB.EC0_.PRT2 */ | |
Store (0x07FF, Local0) | |
While (PRT2) | |
{ | |
Sleep (One) | |
Decrement (Local0) | |
} | |
Release (MUEC) | |
} | |
Return (Local0) | |
} | |
Method (_QAC, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Store (ST8E (0x28, Zero), Local0) | |
If (LEqual (And (Local0, One), One)) | |
{ | |
Notify (BAT0, 0x80) // Status Change | |
} | |
} | |
Method (_QD3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
} | |
Method (_QD4, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (LEqual (F8FG, One)) | |
{ | |
Store (Zero, F8FG) /* \_SB_.PCI0.LPCB.EC0_.F8FG */ | |
STB2 (0xE0) | |
STB2 (0xDB) | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (ALS) | |
{ | |
Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
{ | |
If (LGreaterEqual (MSOS (), OSW7)) | |
{ | |
Return ("ACPI0008") | |
} | |
Else | |
{ | |
Return ("PNP0C02") | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (0x0B) | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Name (LUXL, Zero) | |
Method (_ALI, 0, NotSerialized) // _ALI: Ambient Light Illuminance | |
{ | |
Return (^^PCI0.LPCB.EC0.RALS ()) | |
} | |
Method (_ALR, 0, NotSerialized) // _ALR: Ambient Light Response | |
{ | |
Return (OALR) /* \OALR */ | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (LID) | |
{ | |
Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID | |
Method (_LID, 0, NotSerialized) // _LID: Lid Status | |
{ | |
Store (One, Local0) | |
Store (^^PCI0.LPCB.EC0.RPIN (0x46), Local0) | |
If (LEqual (Local0, Ones)) | |
{ | |
Store (One, Local0) | |
} | |
If (And (VGAF, One)) | |
{ | |
Store (One, ^^PCI0.GFX0.CLID) /* \_SB_.PCI0.GFX0.CLID */ | |
} | |
Return (Local0) | |
} | |
} | |
} | |
Scope (_GPE) | |
{ | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Name (KLDT, Zero) | |
Method (_Q83, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (GLID ()) | |
{ | |
WRAM (0x044B, KLDT) | |
} | |
Else | |
{ | |
Store (RRAM (0x044B), KLDT) /* \_SB_.PCI0.LPCB.EC0_.KLDT */ | |
WRAM (0x044B, Zero) | |
} | |
Notify (LID, 0x80) // Status Change | |
If (And (VGAF, One)) | |
{ | |
Store (GLID (), Local0) | |
Store (Local0, LIDS) /* \LIDS */ | |
If (CondRefOf (\_SB.PCI0.GFX0.GLID)) | |
{ | |
^^^GFX0.GLID (LIDS) | |
} | |
} | |
} | |
} | |
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 | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (Package (0x02) | |
{ | |
0x0B, | |
0x04 | |
}) | |
} | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Method (_Q79, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
^^^^ATKD.IANE (0xB1) | |
Return (One) | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (FSMI, 1, NotSerialized) | |
{ | |
Store (Arg0, FSFN) /* \_SB_.FSFN */ | |
Or (Arg0, 0xA0, Local0) | |
ISMI (0x90) | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
Method (FLSH, 1, NotSerialized) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
FSMI (Zero) | |
} | |
Method (FINI, 1, NotSerialized) | |
{ | |
Store (Arg0, FADR) /* \_SB_.FADR */ | |
Return (FSMI (One)) | |
} | |
Method (FERS, 1, NotSerialized) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
Return (FSMI (0x02)) | |
} | |
Method (FWRI, 1, NotSerialized) | |
{ | |
Store (Arg0, FADR) /* \_SB_.FADR */ | |
Store (0x1000, FSIZ) /* \_SB_.FSIZ */ | |
Return (Subtract (0x1000, FSMI (0x03))) | |
} | |
Method (FCPW, 1, NotSerialized) | |
{ | |
Store (Arg0, FADR) /* \_SB_.FADR */ | |
Store (0x1000, FSIZ) /* \_SB_.FSIZ */ | |
Return (FSMI (0x0D)) | |
} | |
Method (FCPP, 0, NotSerialized) | |
{ | |
Store (Zero, FSIZ) /* \_SB_.FSIZ */ | |
Return (FSMI (0x0D)) | |
} | |
Method (FWRP, 0, NotSerialized) | |
{ | |
Store (Zero, FSIZ) /* \_SB_.FSIZ */ | |
Return (Subtract (0x1000, FSMI (0x03))) | |
} | |
Method (FEBW, 1, NotSerialized) | |
{ | |
Store (Arg0, FADR) /* \_SB_.FADR */ | |
Return (FSMI (0x04)) | |
} | |
Method (FEBR, 1, NotSerialized) | |
{ | |
Store (Arg0, FADR) /* \_SB_.FADR */ | |
Return (FSMI (0x05)) | |
} | |
Method (FEDW, 0, NotSerialized) | |
{ | |
Return (FSMI (0x06)) | |
} | |
Method (ECSR, 1, NotSerialized) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
Return (FSMI (0x07)) | |
} | |
Method (FLSC, 1, NotSerialized) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
Return (FSMI (0x08)) | |
} | |
Method (FIME, 1, NotSerialized) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
If (Or (LEqual (Arg0, 0x04), LEqual (Arg0, 0x05))) | |
{ | |
FSMI (0x09) | |
If (LEqual (Arg0, 0x04)) | |
{ | |
Store (FADR, ULCK) /* \_SB_.ATKD.ULCK */ | |
} | |
Store (Zero, FSTA) /* \_SB_.FSTA */ | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
If (LEqual (Arg0, 0x8000)) | |
{ | |
Store (0x1000, FSIZ) /* \_SB_.FSIZ */ | |
FSMI (0x09) | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
Return (FSMI (0x09)) | |
} | |
Method (FREC, 1, NotSerialized) | |
{ | |
If (LEqual (Arg0, 0x8000)) | |
{ | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
FSMI (0x0A) | |
Store (0x1000, FSIZ) /* \_SB_.FSIZ */ | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
Store (Arg0, FSTA) /* \_SB_.FSTA */ | |
Return (FSMI (0x0A)) | |
} | |
Name (ULCK, Zero) | |
} | |
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 (BDFR, 4, NotSerialized) | |
{ | |
ShiftLeft (Arg0, 0x14, Arg0) | |
ShiftLeft (Arg1, 0x0F, Arg1) | |
ShiftLeft (Arg2, 0x0C, Arg2) | |
Add (Arg0, Zero, Local0) | |
Add (Arg1, Local0, Local0) | |
Add (Arg2, Local0, Local0) | |
Add (Arg3, Local0, Local0) | |
Return (Local0) | |
} | |
Method (RBPE, 1, NotSerialized) | |
{ | |
Acquire (MUTE, 0xFFFF) | |
Add (Arg0, PEBS, Local0) | |
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, 0xFFFF) | |
And (Arg0, 0xFFFFFFFE, Arg0) | |
Add (Arg0, PEBS, Local0) | |
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, 0xFFFF) | |
And (Arg0, 0xFFFFFFFC, Arg0) | |
Add (Arg0, PEBS, Local0) | |
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, 0xFFFF) | |
Add (Arg0, PEBS, Local0) | |
OperationRegion (PCFG, SystemMemory, Local0, One) | |
Field (PCFG, ByteAcc, NoLock, Preserve) | |
{ | |
XCFG, 8 | |
} | |
Store (Arg1, XCFG) /* \_SB_.WBPE.XCFG */ | |
Release (MUTE) | |
} | |
Method (WWPE, 2, NotSerialized) | |
{ | |
Acquire (MUTE, 0xFFFF) | |
And (Arg0, 0xFFFFFFFE, Arg0) | |
Add (Arg0, PEBS, Local0) | |
OperationRegion (PCFG, SystemMemory, Local0, 0x02) | |
Field (PCFG, WordAcc, NoLock, Preserve) | |
{ | |
XCFG, 16 | |
} | |
Store (Arg1, XCFG) /* \_SB_.WWPE.XCFG */ | |
Release (MUTE) | |
} | |
Method (WDPE, 2, NotSerialized) | |
{ | |
Acquire (MUTE, 0xFFFF) | |
And (Arg0, 0xFFFFFFFC, Arg0) | |
Add (Arg0, PEBS, Local0) | |
OperationRegion (PCFG, SystemMemory, Local0, 0x04) | |
Field (PCFG, DWordAcc, NoLock, Preserve) | |
{ | |
XCFG, 32 | |
} | |
Store (Arg1, XCFG) /* \_SB_.WDPE.XCFG */ | |
Release (MUTE) | |
} | |
Method (RWDP, 3, NotSerialized) | |
{ | |
Acquire (MUTE, 0xFFFF) | |
And (Arg0, 0xFFFFFFFC, Arg0) | |
Add (Arg0, PEBS, Local0) | |
OperationRegion (PCFG, SystemMemory, Local0, 0x04) | |
Field (PCFG, DWordAcc, NoLock, Preserve) | |
{ | |
XCFG, 32 | |
} | |
And (XCFG, Arg2, Local1) | |
Or (Local1, Arg1, XCFG) /* \_SB_.RWDP.XCFG */ | |
Release (MUTE) | |
} | |
Method (RPME, 1, NotSerialized) | |
{ | |
Add (Arg0, 0x84, Local0) | |
Store (RDPE (Local0), Local1) | |
If (LEqual (Local1, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
If (LAnd (Local1, 0x00010000)) | |
{ | |
WDPE (Local0, And (Local1, 0x00010000)) | |
Return (One) | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Scope (\) | |
{ | |
OperationRegion (PMIO, SystemIO, PMBS, 0x80) | |
Field (PMIO, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
, 1, | |
TDTY, 3, | |
TENA, 1, | |
TTDT, 3, | |
FRCT, 1, | |
, 8, | |
THLS, 1, | |
Offset (0x13), | |
Offset (0x20), | |
, 1, | |
PEHS, 1, | |
, 7, | |
PEPS, 1, | |
BLST, 1, | |
SBPS, 1, | |
Offset (0x22), | |
G00S, 1, | |
G01S, 1, | |
G02S, 1, | |
GPS3, 1, | |
G04S, 1, | |
G05S, 1, | |
G06S, 1, | |
G07S, 1, | |
G08S, 1, | |
G09S, 1, | |
G0AS, 1, | |
G0BS, 1, | |
G0CS, 1, | |
G0DS, 1, | |
G0ES, 1, | |
G0FS, 1, | |
Offset (0x28), | |
, 1, | |
PEHE, 1, | |
, 7, | |
PEPE, 1, | |
BLEN, 1, | |
SBPE, 1, | |
Offset (0x2A), | |
G00E, 1, | |
G01E, 1, | |
G02E, 1, | |
GPE3, 1, | |
G04E, 1, | |
G05E, 1, | |
G06E, 1, | |
G07E, 1, | |
G08E, 1, | |
G09E, 1, | |
G0AE, 1, | |
G0BE, 1, | |
G0CE, 1, | |
G0DE, 1, | |
G0EE, 1, | |
G0FE, 1, | |
Offset (0x30), | |
, 4, | |
SLPE, 1, | |
APME, 1, | |
, 5, | |
MCSE, 1, | |
, 1, | |
TCOE, 1, | |
PERE, 1, | |
Offset (0x32), | |
Offset (0x34), | |
, 4, | |
SLPS, 1, | |
APMS, 1, | |
, 5, | |
MCSS, 1, | |
, 1, | |
TCOS, 1, | |
PERS, 1, | |
Offset (0x36), | |
Offset (0x42), | |
, 1, | |
GPEC, 1, | |
Offset (0x64), | |
, 9, | |
SCIS, 1, | |
Offset (0x66) | |
} | |
OperationRegion (GPIS, SystemIO, PMBS, 0x50) | |
Field (GPIS, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x22), | |
GS00, 16 | |
} | |
OperationRegion (GP01, SystemIO, GPBS, 0x64) | |
Field (GP01, ByteAcc, NoLock, Preserve) | |
{ | |
GU00, 8, | |
GU01, 8, | |
GU02, 8, | |
GU03, 8, | |
GIO0, 8, | |
GIO1, 8, | |
GIO2, 8, | |
GIO3, 8, | |
Offset (0x0C), | |
Offset (0x0D), | |
GL01, 8, | |
GL02, 8, | |
, 3, | |
GP27, 1, | |
GP28, 1, | |
Offset (0x10), | |
Offset (0x18), | |
Offset (0x19), | |
GB01, 8, | |
GB02, 8, | |
GB03, 8, | |
Offset (0x2C), | |
GIV0, 8, | |
GIV1, 8, | |
GIV2, 8, | |
GIV3, 8, | |
GU04, 8, | |
GU05, 8, | |
GU06, 8, | |
GU07, 8, | |
GIO4, 8, | |
GIO5, 8, | |
GIO6, 8, | |
GIO7, 8, | |
, 5, | |
, 1, | |
Offset (0x39), | |
GL05, 8, | |
GL06, 8, | |
GL07, 8, | |
Offset (0x40), | |
GU08, 8, | |
GU09, 8, | |
GU0A, 8, | |
GU0B, 8, | |
GIO8, 8, | |
GIO9, 8, | |
GIOA, 8, | |
GIOB, 8, | |
GL08, 8, | |
GL09, 8, | |
GL0A, 8, | |
GL0B, 8 | |
} | |
OperationRegion (GPIO, SystemIO, GPBS, 0x80) | |
Field (GPIO, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x0C), | |
GL00, 16, | |
GL10, 16, | |
Offset (0x18), | |
GB00, 32, | |
Offset (0x2C), | |
GP00, 16, | |
Offset (0x38), | |
GL20, 32, | |
Offset (0x48), | |
GL40, 32 | |
} | |
OperationRegion (RCBA, SystemMemory, 0xFED1C000, 0x4000) | |
Field (RCBA, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x3418), | |
FDRT, 32 | |
} | |
Method (RGPI, 2, Serialized) | |
{ | |
Store (Arg1, Local0) | |
Store (Zero, Local1) | |
While (Local0) | |
{ | |
ShiftLeft (Local1, One, Local1) | |
Or (Local1, One, Local1) | |
Decrement (Local0) | |
} | |
If (LLess (Arg0, 0x10)) | |
{ | |
ShiftLeft (Local1, Arg0, Local1) | |
Store (GP00, Local0) | |
And (Local0, Local1, Local0) | |
ShiftRight (Local0, Arg0, Local0) | |
} | |
Return (Local0) | |
} | |
Method (RGPL, 2, Serialized) | |
{ | |
Store (Arg1, Local0) | |
Store (Zero, Local1) | |
While (Local0) | |
{ | |
ShiftLeft (Local1, One, Local1) | |
Or (Local1, One, Local1) | |
Decrement (Local0) | |
} | |
If (LLess (Arg0, 0x10)) | |
{ | |
ShiftLeft (Local1, Arg0, Local1) | |
Store (GL00, Local0) | |
And (Local0, Local1, Local0) | |
ShiftRight (Local0, Arg0, Local0) | |
} | |
Else | |
{ | |
If (LLess (Arg0, 0x20)) | |
{ | |
Store (GL10, Local0) | |
Subtract (Arg0, 0x10, Local2) | |
} | |
Else | |
{ | |
If (LLess (Arg0, 0x40)) | |
{ | |
Store (GL20, Local0) | |
Subtract (Arg0, 0x20, Local2) | |
} | |
Else | |
{ | |
Store (GL40, Local0) | |
Subtract (Arg0, 0x40, Local2) | |
} | |
} | |
ShiftLeft (Local1, Local2, Local1) | |
And (Local0, Local1, Local0) | |
ShiftRight (Local0, Local2, Local0) | |
} | |
Return (Local0) | |
} | |
Method (SGPL, 3, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.GPLK, Local7) | |
Store (Zero, \_SB.PCI0.LPCB.GPLK) | |
Store (Arg1, Local0) | |
Store (Zero, Local1) | |
While (Local0) | |
{ | |
ShiftLeft (Local1, One, Local1) | |
Or (Local1, One, Local1) | |
Decrement (Local0) | |
} | |
If (LGreaterEqual (Arg0, 0x10)) | |
{ | |
If (LLess (Arg0, 0x20)) | |
{ | |
Store (GL10, Local0) | |
Subtract (Arg0, 0x10, Local2) | |
} | |
Else | |
{ | |
If (LLess (Arg0, 0x40)) | |
{ | |
Store (GL20, Local0) | |
Subtract (Arg0, 0x20, Local2) | |
} | |
Else | |
{ | |
Store (GL40, Local0) | |
Subtract (Arg0, 0x40, Local2) | |
} | |
} | |
ShiftLeft (Local1, Local2, Local1) | |
Not (Local1, Local3) | |
And (Local0, Local3, Local0) | |
ShiftLeft (Arg2, Local2, Local4) | |
Or (Local0, Local4, Local0) | |
If (LLess (Arg0, 0x20)) | |
{ | |
Store (Local0, GL10) /* \GL10 */ | |
} | |
Else | |
{ | |
If (LLess (Arg0, 0x40)) | |
{ | |
Store (Local0, GL20) /* \GL20 */ | |
} | |
Else | |
{ | |
Store (Local0, GL40) /* \GL40 */ | |
} | |
} | |
} | |
Else | |
{ | |
ShiftLeft (Local1, Arg0, Local1) | |
Not (Local1, Local3) | |
And (GL00, Local3, Local0) | |
ShiftLeft (Arg2, Arg0, Local4) | |
Or (Local0, Local4, Local0) | |
Store (Local0, GL00) /* \GL00 */ | |
} | |
Store (Local7, \_SB.PCI0.LPCB.GPLK) | |
} | |
Method (RGPP, 1, Serialized) | |
{ | |
ShiftRight (GP00, Arg0, Local0) | |
And (Local0, One, Local0) | |
Return (Local0) | |
} | |
Method (TGPP, 1, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.GPLK, Local7) | |
Store (Zero, \_SB.PCI0.LPCB.GPLK) | |
ShiftLeft (One, Arg0, Local0) | |
XOr (GP00, Local0, GP00) /* \GP00 */ | |
Store (Local7, \_SB.PCI0.LPCB.GPLK) | |
} | |
Method (SGPP, 2, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.GPLK, Local7) | |
Store (Zero, \_SB.PCI0.LPCB.GPLK) | |
ShiftLeft (One, Arg0, Local0) | |
If (Arg1) | |
{ | |
Or (GP00, Local0, GP00) /* \GP00 */ | |
} | |
Else | |
{ | |
Not (Local0, Local1) | |
And (GP00, Local1, GP00) /* \GP00 */ | |
} | |
Store (Local7, \_SB.PCI0.LPCB.GPLK) | |
} | |
Name (PMEW, Zero) | |
Method (SBRS, 1, NotSerialized) | |
{ | |
CPXS () | |
} | |
Method (SBRW, 1, NotSerialized) | |
{ | |
Store (SBPS, PMEW) /* \PMEW */ | |
} | |
Method (STRP, 1, NotSerialized) | |
{ | |
If (Arg0) | |
{ | |
Store (One, SLPS) /* \SLPS */ | |
Store (One, SLPE) /* \SLPE */ | |
} | |
Else | |
{ | |
Store (Zero, SLPE) /* \SLPE */ | |
Store (One, SLPS) /* \SLPS */ | |
} | |
} | |
Method (HKTH, 0, Serialized) | |
{ | |
If (THLS) | |
{ | |
Return (TTDT) /* \TTDT */ | |
} | |
Else | |
{ | |
Return (0xFFFF) | |
} | |
} | |
Method (CPXS, 0, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
Store (0x00010000, Local1) | |
Store (0x000E0060, Local2) | |
Store (0x000E00DC, Local3) | |
While (LLess (Local0, 0x04)) | |
{ | |
If (LNot (And (FDRT, Local1))) | |
{ | |
While (And (\_SB.RDPE (Local2), 0x00010000)) | |
{ | |
Or (\_SB.RDPE (Local2), 0x00010000, Local4) | |
\_SB.WDPE (Local2, Local4) | |
} | |
While (And (\_SB.RDPE (Local3), 0x80000000)) | |
{ | |
Or (\_SB.RDPE (Local3), 0x80000000, Local4) | |
\_SB.WDPE (Local3, Local4) | |
} | |
} | |
Add (Local2, 0x1000, Local2) | |
Add (Local3, 0x1000, Local3) | |
ShiftLeft (Local1, One, Local1) | |
Increment (Local0) | |
} | |
While (And (PEPS, One)) | |
{ | |
Or (PEPS, One, PEPS) /* \PEPS */ | |
} | |
} | |
} | |
Scope (_GPE) | |
{ | |
Method (_L01, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
} | |
Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
If (\_SB.PCI0.RP01.PMES) | |
{ | |
While (\_SB.PCI0.RP01.PMES) | |
{ | |
Store (One, \_SB.PCI0.RP01.PMES) | |
Store (One, \_SB.PCI0.RP01.PMCS) | |
} | |
Notify (\_SB.PCI0.RP01, 0x02) // Device Wake | |
} | |
If (\_SB.PCI0.RP02.PMES) | |
{ | |
While (\_SB.PCI0.RP02.PMES) | |
{ | |
Store (One, \_SB.PCI0.RP02.PMES) | |
Store (One, \_SB.PCI0.RP02.PMCS) | |
} | |
Notify (\_SB.PCI0.RP02, 0x02) // Device Wake | |
} | |
} | |
Method (_L06, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
If (LAnd (\_SB.PCI0.GFX0.GSSE, LNot (GSMI))) | |
{ | |
\_SB.PCI0.GFX0.GSCI () | |
} | |
} | |
} | |
Scope (_SB.PCI0.LPCB) | |
{ | |
OperationRegion (RX40, PCI_Config, 0x40, 0x10) | |
Field (RX40, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x0C), | |
GPLK, 1 | |
} | |
OperationRegion (RXA0, PCI_Config, 0xA0, 0x20) | |
Field (RXA0, ByteAcc, NoLock, Preserve) | |
{ | |
, 9, | |
PBLV, 1, | |
BCPE, 1, | |
Offset (0x10), | |
, 1, | |
PBMS, 1, | |
, 1, | |
PMCS, 1, | |
ECNS, 1, | |
Offset (0x11), | |
ECT1, 16, | |
ELEN, 1, | |
Offset (0x14) | |
} | |
} | |
Scope (\) | |
{ | |
OperationRegion (SMB0, SystemIO, \_SB.SMBB, 0x10) | |
Field (SMB0, 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, Buffer (0x20) {}) | |
Method (HBSY, 0, NotSerialized) | |
{ | |
Store (0x000FFFFF, Local0) | |
While (Local0) | |
{ | |
And (HSTS, One, Local1) | |
If (LNot (Local1)) | |
{ | |
Return (Zero) | |
} | |
Decrement (Local0) | |
} | |
Return (One) | |
} | |
Method (WTSB, 0, NotSerialized) | |
{ | |
Store (0x000FFFFF, Local0) | |
While (Local0) | |
{ | |
Decrement (Local0) | |
And (HSTS, 0x1E, Local1) | |
If (LEqual (Local1, 0x02)) | |
{ | |
Return (One) | |
} | |
If (Local1) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (Zero) | |
} | |
Mutex (P4SM, 0x00) | |
Method (SBYT, 2, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (AUXC, Local0) | |
Store (Zero, AUXC) /* \AUXC */ | |
Store (Arg0, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x44, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Store (Local0, AUXC) /* \AUXC */ | |
Release (P4SM) | |
Return (One) | |
} | |
Else | |
{ | |
Store (Local0, AUXC) /* \AUXC */ | |
Release (P4SM) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (WBYT, 3, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Store (Arg0, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (Arg2, HDT0) /* \HDT0 */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x48, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Release (P4SM) | |
Return (One) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (WWRD, 3, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Store (Arg0, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
And (Arg2, 0xFF, Local1) | |
ShiftRight (Arg2, 0x08, Local2) | |
And (Local2, 0xFF, Local2) | |
Store (Local2, HDT0) /* \HDT0 */ | |
Store (Local1, HDT1) /* \HDT1 */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x4C, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Release (P4SM) | |
Return (One) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (WBLK, 3, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Or (AUXC, 0x02, AUXC) /* \AUXC */ | |
Store (Arg0, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (HSTC, Local1) | |
Store (Arg2, Local2) | |
Store (Zero, Local1) | |
While (Local2) | |
{ | |
Store (DerefOf (Index (RBUF, Local1)), BLKD) /* \BLKD */ | |
Decrement (Local2) | |
Increment (Local1) | |
} | |
Store (Arg2, HDT0) /* \HDT0 */ | |
Store (HSTC, Local1) | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x54, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Release (P4SM) | |
Return (One) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (RSBT, 2, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Or (Arg0, One, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x44, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Release (P4SM) | |
Return (HDT0) /* \HDT0 */ | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (RBYT, 2, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Or (Arg0, One, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x48, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Release (P4SM) | |
Return (HDT0) /* \HDT0 */ | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (RWRD, 2, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Or (Arg0, One, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x4C, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Store (HDT0, Local1) | |
ShiftLeft (Local1, 0x08, Local1) | |
Store (HDT1, Local2) | |
Add (Local1, Local2, Local1) | |
Release (P4SM) | |
Return (Local1) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
Method (RBLK, 3, Serialized) | |
{ | |
Acquire (P4SM, 0xFFFF) | |
Store (0x05, Local0) | |
While (Local0) | |
{ | |
If (HBSY ()) | |
{ | |
Decrement (Local0) | |
} | |
Else | |
{ | |
Or (AUXC, 0x02, AUXC) /* \AUXC */ | |
Or (Arg0, One, HADR) /* \HADR */ | |
Store (Arg1, HCMD) /* \HCMD */ | |
Store (0xFF, HSTS) /* \HSTS */ | |
Store (0x54, HSTC) /* \HSTC */ | |
If (WTSB ()) | |
{ | |
Store (HSTC, Local1) | |
Store (HDT0, Local2) | |
Store (Local2, Local3) | |
Store (Zero, RBUF) /* \RBUF */ | |
Store (Zero, Local1) | |
While (Local2) | |
{ | |
Store (BLKD, Index (RBUF, Local1)) | |
Decrement (Local2) | |
Increment (Local1) | |
} | |
Release (P4SM) | |
Return (Local3) | |
} | |
Else | |
{ | |
Decrement (Local0) | |
} | |
} | |
} | |
Release (P4SM) | |
Return (Ones) | |
} | |
} | |
Scope (_GPE) | |
{ | |
Method (_L03, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB1, 0x02) // Device Wake | |
} | |
Method (_L04, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB2, 0x02) // Device Wake | |
} | |
Method (_L0C, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB3, 0x02) // Device Wake | |
} | |
Method (_L0E, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB4, 0x02) // Device Wake | |
} | |
Method (_L05, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB5, 0x02) // Device Wake | |
} | |
Method (_L20, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.USB6, 0x02) // Device Wake | |
Notify (\_SB.PCI0.USB7, 0x02) // Device Wake | |
} | |
Method (_L0D, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.EHC1, 0x02) // Device Wake | |
Notify (\_SB.PCI0.EHC2, 0x02) // Device Wake | |
Notify (\_SB.PCI0.HDEF, 0x02) // Device Wake | |
Notify (\_SB.PCI0.XHC1, 0x02) // Device Wake | |
If (LAnd (\_SB.PCI0.XHC.PMES, \_SB.PCI0.XHC.PMES)) | |
{ | |
Store (One, \_SB.PCI0.XHC.PMES) | |
} | |
} | |
Method (_L08, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.HDEF, 0x02) // Device Wake | |
} | |
Method (_L0B, 0, Serialized) // _Lxx: Level-Triggered GPE | |
{ | |
If (PMEW) | |
{ | |
Notify (\_SB.PCI0.RP06, 0x02) // Device Wake | |
Notify (\_SB.PCI0.RP02, 0x02) // Device Wake | |
Store (Zero, PMEW) /* \PMEW */ | |
} | |
Else | |
{ | |
} | |
} | |
} | |
Scope (_SB.PCI0.EHC1) | |
{ | |
Device (RHUB) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Device (PRT1) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities | |
{ | |
Zero, | |
0xFF, | |
Zero, | |
Zero | |
}) | |
Device (PRT1) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (Zero) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (Zero) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT2) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (One) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (One) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT3) | |
{ | |
Name (_ADR, 0x03) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x02) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x02) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT4) | |
{ | |
Name (_ADR, 0x04) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x03) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x03) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT5) | |
{ | |
Name (_ADR, 0x05) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x04) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x04) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT6) | |
{ | |
Name (_ADR, 0x06) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x05) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x05) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT7) | |
{ | |
Name (_ADR, 0x07) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x06) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x06) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT8) | |
{ | |
Name (_ADR, 0x08) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x07) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x07) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
} | |
} | |
} | |
Scope (_SB.PCI0.EHC2) | |
{ | |
Device (RHUB) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Device (PRT1) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Name (_UPC, Package (0x04) // _UPC: USB Port Capabilities | |
{ | |
Zero, | |
0xFF, | |
Zero, | |
Zero | |
}) | |
Device (PRT1) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x08) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x08) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT2) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x09) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x09) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT3) | |
{ | |
Name (_ADR, 0x03) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x0A) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x0A) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT4) | |
{ | |
Name (_ADR, 0x04) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x0B) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x0B) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT5) | |
{ | |
Name (_ADR, 0x05) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x0C) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x0C) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
Device (PRT6) | |
{ | |
Name (_ADR, 0x06) // _ADR: Address | |
Method (_UPC, 0, NotSerialized) // _UPC: USB Port Capabilities | |
{ | |
OUPC (0x0D) | |
Return (BUPC) /* \BUPC */ | |
} | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
OPLD (0x0D) | |
Return (BPLD) /* \BPLD */ | |
} | |
} | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Name (CNTB, Buffer (0x0E) | |
{ | |
/* 0000 */ 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00 /* ...... */ | |
}) | |
Name (VISB, Buffer (0x0E) | |
{ | |
/* 0000 */ 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 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) | |
{ | |
0x81, 0x00, 0x31, 0x00 /* ..1. */ | |
}) | |
Method (OUPC, 1, Serialized) | |
{ | |
Store (DerefOf (Index (CNTB, Arg0)), Local0) | |
Store (Local0, Index (BUPC, Zero)) | |
} | |
Method (OPLD, 1, Serialized) | |
{ | |
Store (DerefOf (Index (VISB, Arg0)), Local0) | |
Store (DerefOf (Index (BPLD, 0x08)), Local1) | |
And (Local1, 0xFE, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (BPLD, 0x08)) | |
Store (DerefOf (Index (SHPB, Arg0)), Local0) | |
Store (DerefOf (Index (BPLD, 0x09)), Local1) | |
And (Local1, 0xC3, Local1) | |
Or (Local1, Local0, Local1) | |
Store (Local1, Index (BPLD, 0x09)) | |
} | |
} | |
Scope (\) | |
{ | |
Method (LIMT, 0, NotSerialized) | |
{ | |
Subtract (\_SB.CPUP, \_SB.SLMT, Local0) | |
Return (Local0) | |
} | |
Method (NCPS, 1, Serialized) | |
{ | |
Notify (\_PR.CPU0, Arg0) | |
Notify (\_PR.CPU1, Arg0) | |
If (LGreaterEqual (\_SB.CPUN, 0x04)) | |
{ | |
Notify (\_PR.CPU2, Arg0) | |
Notify (\_PR.CPU3, Arg0) | |
} | |
If (LGreaterEqual (\_SB.CPUN, 0x08)) | |
{ | |
Notify (\_PR.CPU4, Arg0) | |
Notify (\_PR.CPU5, Arg0) | |
Notify (\_PR.CPU6, Arg0) | |
Notify (\_PR.CPU7, Arg0) | |
} | |
} | |
Name (LCDB, Zero) | |
Method (PPRJ, 1, Serialized) | |
{ | |
} | |
Method (PRJS, 1, Serialized) | |
{ | |
SGPL (0x0F, One, Zero) | |
\_SB.PCI0.LPCB.EC0.SPIN (0x95, Zero) | |
} | |
Method (PRJW, 1, Serialized) | |
{ | |
\_SB.PCI0.LPCB.EC0.SPIN (0x35, One) | |
If (LAnd (LEqual (Arg0, 0x03), \_SB.DP3S)) | |
{ | |
\_SB.PCI0.LPCB.EC0.SPIN (0x35, One) | |
} | |
\_SB.PCI0.LPCB.EC0.STBR () | |
} | |
Method (GLID, 0, Serialized) | |
{ | |
Return (\_SB.PCI0.LPCB.EC0.RPIN (0x46)) | |
} | |
Method (TLID, 0, Serialized) | |
{ | |
} | |
Method (TGAC, 0, Serialized) | |
{ | |
} | |
Method (TGDC, 1, Serialized) | |
{ | |
} | |
Method (FCTR, 3, Serialized) | |
{ | |
} | |
Method (OWGD, 1, Serialized) | |
{ | |
SGPL (0x0F, One, Arg0) | |
} | |
Method (OWGS, 0, Serialized) | |
{ | |
Store (RGPL (0x0F, One), Local0) | |
Return (Local0) | |
} | |
Method (OWLD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.WRST) | |
XOr (Arg0, One, Arg0) | |
If (LEqual (LAnd (\_SB.ATKD.WAPF, 0x05), Zero)) | |
{ | |
SGPL (0x1C, One, Arg0) | |
} | |
} | |
Method (OBTD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.BRST) | |
SGPL (0x39, One, Arg0) | |
SGPL (0x0F, One, Arg0) | |
} | |
Method (ODSP, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.DP3S) | |
} | |
Method (OUWD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.UWST) | |
Return (One) | |
} | |
Method (OWMD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.WMST) | |
Return (One) | |
} | |
Method (OGPD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.GPST) | |
Return (One) | |
} | |
Method (OTGD, 1, Serialized) | |
{ | |
Store (Arg0, \_SB.TGST) | |
If (Arg0) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ST87 (0x40, 0xFF), Local0) | |
} | |
Else | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.ST87 (0x20, 0xFF), Local0) | |
} | |
Return (One) | |
} | |
Method (OHWS, 0, Serialized) | |
{ | |
Return (Zero) | |
} | |
Method (OHWR, 0, Serialized) | |
{ | |
Store (Zero, Local0) | |
If (LEqual (OHWS (), Zero)) | |
{ | |
And (Local0, 0xFFFE, Local0) | |
} | |
Else | |
{ | |
Or (Local0, One, Local0) | |
} | |
If (\_SB.PCI0.RP02.WLAN.MPDP ()) | |
{ | |
Or (Local0, 0x80, Local0) | |
} | |
If (\_SB.BTDP) | |
{ | |
Or (Local0, 0x0100, Local0) | |
} | |
If (\_SB.UWDP) | |
{ | |
Or (Local0, 0x08, Local0) | |
} | |
If (\_SB.WMDP) | |
{ | |
Or (Local0, 0x10, Local0) | |
} | |
If (\_SB.GPDP) | |
{ | |
Or (Local0, 0x20, Local0) | |
} | |
If (\_SB.TGDP) | |
{ | |
Or (Local0, 0x40, Local0) | |
} | |
Return (Local0) | |
} | |
Method (ORST, 0, Serialized) | |
{ | |
Store (Zero, Local0) | |
If (\_SB.WRST) | |
{ | |
Or (Local0, One, Local0) | |
} | |
If (\_SB.BRST) | |
{ | |
Or (Local0, 0x02, Local0) | |
} | |
If (\_SB.UWST) | |
{ | |
Or (Local0, 0x04, Local0) | |
} | |
If (\_SB.WMST) | |
{ | |
Or (Local0, 0x08, Local0) | |
} | |
If (\_SB.GPST) | |
{ | |
Or (Local0, 0x10, Local0) | |
} | |
If (\_SB.TGST) | |
{ | |
Or (Local0, 0x20, Local0) | |
} | |
Return (Local0) | |
} | |
Method (GBTL, 0, Serialized) | |
{ | |
Return (\_SB.PCI0.LPCB.EC0.RPIN (0x84)) | |
} | |
Method (SBTL, 1, Serialized) | |
{ | |
\_SB.PCI0.LPCB.EC0.SPIN (0x84, Arg0) | |
} | |
Method (BL2C, 0, NotSerialized) | |
{ | |
Return (Zero) | |
} | |
Method (STCF, 1, Serialized) | |
{ | |
If (LEqual (Arg0, One)) | |
{ | |
\_SB.PCI0.LPCB.EC0.FNCT (0x84, Zero) | |
} | |
} | |
Method (OTGB, 0, Serialized) | |
{ | |
Store (One, Local0) | |
Return (Local0) | |
} | |
Method (DCPS, 1, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.RPIN (0x26), Local0) | |
XOr (Local0, One, Local0) | |
Return (Local0) | |
} | |
Method (ACPS, 0, Serialized) | |
{ | |
Store (\_SB.PCI0.LPCB.EC0.RPIN (0x24), Local0) | |
XOr (Local0, One, Local0) | |
Return (Local0) | |
} | |
Name (OPVK, Buffer (0xE2) | |
{ | |
/* 0000 */ 0x7C, 0x6E, 0xD9, 0xF2, 0x91, 0xA6, 0xD7, 0xF6, /* |n...... */ | |
/* 0008 */ 0x4B, 0x56, 0xE2, 0x00, 0x00, 0x00, 0x01, 0x00, /* KV...... */ | |
/* 0010 */ 0x32, 0x37, 0x34, 0x35, 0x39, 0x31, 0x32, 0x35, /* 27459125 */ | |
/* 0018 */ 0x33, 0x36, 0x38, 0x37, 0x47, 0x65, 0x6E, 0x75, /* 3687Genu */ | |
/* 0020 */ 0x69, 0x6E, 0x65, 0x20, 0x4E, 0x56, 0x49, 0x44, /* ine NVID */ | |
/* 0028 */ 0x49, 0x41, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, /* IA Certi */ | |
/* 0030 */ 0x66, 0x69, 0x65, 0x64, 0x20, 0x4F, 0x70, 0x74, /* fied Opt */ | |
/* 0038 */ 0x69, 0x6D, 0x75, 0x73, 0x20, 0x52, 0x65, 0x61, /* imus Rea */ | |
/* 0040 */ 0x64, 0x79, 0x20, 0x4D, 0x6F, 0x74, 0x68, 0x65, /* dy Mothe */ | |
/* 0048 */ 0x72, 0x62, 0x6F, 0x61, 0x72, 0x64, 0x20, 0x66, /* rboard f */ | |
/* 0050 */ 0x6F, 0x72, 0x20, 0x61, 0x73, 0x75, 0x73, 0x20, /* or asus */ | |
/* 0058 */ 0x75, 0x33, 0x30, 0x6A, 0x63, 0x20, 0x62, 0x75, /* u30jc bu */ | |
/* 0060 */ 0x67, 0x20, 0x36, 0x33, 0x30, 0x38, 0x35, 0x20, /* g 63085 */ | |
/* 0068 */ 0x2D, 0x20, 0x3D, 0x35, 0x58, 0x2E, 0x59, 0x29, /* - =5X.Y) */ | |
/* 0070 */ 0x5C, 0x20, 0x50, 0x21, 0x54, 0x27, 0x58, 0x26, /* \ P!T'X& */ | |
/* 0078 */ 0x3E, 0x26, 0x3B, 0x2B, 0x27, 0x26, 0x5A, 0x43, /* >&;+'&ZC */ | |
/* 0080 */ 0x5C, 0x38, 0x50, 0x57, 0x55, 0x3F, 0x5D, 0x33, /* \8PWU?]3 */ | |
/* 0088 */ 0x38, 0x39, 0x34, 0x45, 0x26, 0x4D, 0x5B, 0x4B, /* 894E&M[K */ | |
/* 0090 */ 0x5F, 0x36, 0x50, 0x4D, 0x2A, 0x33, 0x56, 0x21, /* _6PM*3V! */ | |
/* 0098 */ 0x36, 0x4E, 0x20, 0x2D, 0x20, 0x43, 0x6F, 0x70, /* 6N - Cop */ | |
/* 00A0 */ 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, /* yright 2 */ | |
/* 00A8 */ 0x30, 0x30, 0x39, 0x20, 0x4E, 0x56, 0x49, 0x44, /* 009 NVID */ | |
/* 00B0 */ 0x49, 0x41, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F, /* IA Corpo */ | |
/* 00B8 */ 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x41, /* ration A */ | |
/* 00C0 */ 0x6C, 0x6C, 0x20, 0x52, 0x69, 0x67, 0x68, 0x74, /* ll Right */ | |
/* 00C8 */ 0x73, 0x20, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, /* s Reserv */ | |
/* 00D0 */ 0x65, 0x64, 0x2D, 0x32, 0x37, 0x34, 0x35, 0x39, /* ed-27459 */ | |
/* 00D8 */ 0x31, 0x32, 0x35, 0x33, 0x36, 0x38, 0x37, 0x28, /* 1253687( */ | |
/* 00E0 */ 0x52, 0x29 /* R) */ | |
}) | |
} | |
Scope (_GPE) | |
{ | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
} | |
Scope (_SB.PCI0.EHC1.RHUB.PRT1.PRT5) | |
{ | |
Name (CAPD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x14, 0x00, 0x14, 0x00, /* ........ */ | |
/* 0008 */ 0x25, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* %....... */ | |
/* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF /* .... */ | |
} | |
}) | |
Device (DCAM) | |
{ | |
Name (_ADR, 0x05) // _ADR: Address | |
Method (_PLD, 0, NotSerialized) // _PLD: Physical Location of Device | |
{ | |
Return (CAPD) /* \_SB_.PCI0.EHC1.RHUB.PRT1.PRT5.CAPD */ | |
} | |
} | |
} | |
Name (OALR, Package (0x06) | |
{ | |
Package (0x02) | |
{ | |
0x30, | |
Zero | |
}, | |
Package (0x02) | |
{ | |
0x30, | |
0x32 | |
}, | |
Package (0x02) | |
{ | |
0x64, | |
0xC8 | |
}, | |
Package (0x02) | |
{ | |
0x7D, | |
0x0190 | |
}, | |
Package (0x02) | |
{ | |
0xA0, | |
0x0258 | |
}, | |
Package (0x02) | |
{ | |
0xD0, | |
0x0320 | |
} | |
}) | |
Scope (_SB.PCI0.PEG0) | |
{ | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (LNotEqual (SVID, 0xFFFFFFFF)) | |
{ | |
Store (Zero, NHDA) /* \_SB_.PCI0.PEG0.NHDA */ | |
Sleep (0x32) | |
} | |
Return (0x0F) | |
} | |
OperationRegion (PEGM, SystemMemory, 0xF8008000, 0x0FF0) | |
Field (PEGM, ByteAcc, NoLock, Preserve) | |
{ | |
REG0, 32, | |
REG1, 32, | |
REG2, 32, | |
Offset (0x19), | |
RE19, 8, | |
RE1A, 8, | |
Offset (0x3E), | |
RE3E, 8, | |
Offset (0x84), | |
PWST, 2, | |
Offset (0xB0), | |
ASPM, 2, | |
, 2, | |
LNKD, 1, | |
Offset (0xB3), | |
, 3, | |
LTST, 1, | |
RSCC, 1, | |
Offset (0xB4), | |
, 6, | |
HPCP, 1, | |
SPLV, 8, | |
SPLS, 2, | |
, 2, | |
PHSN, 13, | |
HPD, 8, | |
Offset (0x114), | |
T0V0, 1, | |
TV0M, 7, | |
Offset (0x1FC), | |
R1FC, 9, | |
Offset (0x201), | |
, 5, | |
CGEL, 2, | |
, 3, | |
LCRB, 1, | |
Offset (0x204), | |
RETO, 10, | |
Offset (0x214), | |
Offset (0x216), | |
LNKS, 4, | |
Offset (0x220), | |
R220, 32, | |
Offset (0x225), | |
DQDA, 1, | |
Offset (0x226), | |
R224, 32, | |
Offset (0xC20), | |
, 4, | |
AFE4, 1, | |
AFE5, 1, | |
Offset (0xC28), | |
RC28, 1, | |
Offset (0xC34), | |
RC34, 32, | |
, 26, | |
LDPS, 1, | |
Offset (0xDFC), | |
, 1, | |
RDFC, 3, | |
Offset (0xE08), | |
, 30, | |
RE08, 1, | |
Offset (0xE28), | |
, 30, | |
RE28, 1, | |
Offset (0xE48), | |
, 30, | |
RE48, 1, | |
Offset (0xE68), | |
, 30, | |
RE68, 1, | |
Offset (0xE88), | |
, 30, | |
RE88, 1, | |
Offset (0xEA8), | |
, 30, | |
REA8, 1, | |
Offset (0xEC8), | |
, 30, | |
REC8, 1, | |
Offset (0xEE8), | |
, 30, | |
REE8, 1, | |
Offset (0xF08), | |
, 30, | |
RF08, 1, | |
Offset (0xF28), | |
, 30, | |
RF28, 1, | |
Offset (0xF48), | |
, 30, | |
RF48, 1, | |
Offset (0xF68), | |
, 30, | |
RF68, 1, | |
Offset (0xF88), | |
, 30, | |
RF88, 1, | |
Offset (0xFA8), | |
, 30, | |
RFA8, 1, | |
Offset (0xFC8), | |
, 30, | |
RFC8, 1, | |
Offset (0xFE8), | |
, 30, | |
RFE8, 1 | |
} | |
OperationRegion (GFXM, SystemMemory, 0xF8100000, 0x0500) | |
Field (GFXM, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x2C), | |
SVID, 32, | |
Offset (0x488), | |
, 25, | |
NHDA, 1 | |
} | |
} | |
Scope (_SB.PCI0.PEG0.PEGP) | |
{ | |
Method (DON, 0, NotSerialized) | |
{ | |
_ON () | |
} | |
Method (_ON, 0, NotSerialized) // _ON_: Power On | |
{ | |
If (LNotEqual (SVID, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
SGPL (0x32, One, Zero) | |
Sleep (0x64) | |
SGPL (0x36, One, Zero) | |
Sleep (0x64) | |
Store (RGPL (0x11, One), Local0) | |
While (LNot (Local0)) | |
{ | |
Sleep (0x0A) | |
Store (RGPL (0x11, One), Local0) | |
} | |
SGPL (0x32, One, One) | |
Sleep (0x64) | |
Store (Zero, AFE4) /* \_SB_.PCI0.PEG0.AFE4 */ | |
Store (Zero, AFE5) /* \_SB_.PCI0.PEG0.AFE5 */ | |
Store (Zero, LDPS) /* \_SB_.PCI0.PEG0.LDPS */ | |
Store (Zero, LNKD) /* \_SB_.PCI0.PEG0.LNKD */ | |
While (LLess (LNKS, 0x07)) | |
{ | |
Sleep (One) | |
} | |
^^^GFX0.RSTO () | |
Store (Zero, NHDA) /* \_SB_.PCI0.PEG0.NHDA */ | |
Sleep (0x32) | |
Store (One, ^^^GFX0.HPWR) /* \_SB_.PCI0.GFX0.HPWR */ | |
^^^LPCB.EC0.WRAM (0x0520, 0x97) | |
Store (^^^LPCB.EC0.RRAM (0x0522), Local0) | |
And (Local0, 0xCF, Local0) | |
Or (Local0, 0x10, Local0) | |
^^^LPCB.EC0.WRAM (0x0522, Local0) | |
If (^^^GFX0.NTSA) {} | |
Else | |
{ | |
^^^LPCB.EC0.WRAM (0x052B, 0x9E) | |
Store (One, ^^^GFX0.NTSA) /* \_SB_.PCI0.GFX0.NTSA */ | |
} | |
} | |
Method (DOFF, 0, NotSerialized) | |
{ | |
If (LNotEqual (MFTM, One)) | |
{ | |
_OFF () | |
} | |
} | |
Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
{ | |
If (LEqual (SVID, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Store (^^^LPCB.EC0.RRAM (0x0522), Local0) | |
And (Local0, 0xCF, Local0) | |
^^^LPCB.EC0.WRAM (0x0522, Local0) | |
^^^LPCB.EC0.WRAM (0x0520, 0x95) | |
^^^LPCB.EC0.WRAM (0x03A4, Zero) | |
^^^LPCB.EC0.WRAM (0x03A5, Zero) | |
^^^GFX0.SAVO () | |
Store (One, LNKD) /* \_SB_.PCI0.PEG0.LNKD */ | |
While (LNotEqual (LNKS, Zero)) | |
{ | |
Sleep (One) | |
} | |
Store (Zero, AFE4) /* \_SB_.PCI0.PEG0.AFE4 */ | |
Store (One, AFE5) /* \_SB_.PCI0.PEG0.AFE5 */ | |
Store (One, LDPS) /* \_SB_.PCI0.PEG0.LDPS */ | |
SGPL (0x32, One, Zero) | |
Sleep (0x0A) | |
SGPL (0x36, One, One) | |
Store (Zero, ^^^GFX0.HPWR) /* \_SB_.PCI0.GFX0.HPWR */ | |
Return (Zero) | |
} | |
Method (MXDS, 1, NotSerialized) | |
{ | |
If (And (Arg0, Zero)) | |
{ | |
Return (^^^GFX0.HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
} | |
Else | |
{ | |
Store (One, ^^^GFX0.HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
Store (One, ^^^GFX0.HCMX) /* \_SB_.PCI0.GFX0.HCMX */ | |
Sleep (0x64) | |
} | |
} | |
Method (MXMX, 1, NotSerialized) | |
{ | |
Store (One, ^^^GFX0.HLMM) /* \_SB_.PCI0.GFX0.HLMM */ | |
Store (One, ^^^GFX0.HCMM) /* \_SB_.PCI0.GFX0.HCMM */ | |
Store (One, ^^^GFX0.HDMU) /* \_SB_.PCI0.GFX0.HDMU */ | |
Store (One, ^^^GFX0.HHMM) /* \_SB_.PCI0.GFX0.HHMM */ | |
Store (One, ^^^GFX0.HLMX) /* \_SB_.PCI0.GFX0.HLMX */ | |
Store (One, ^^^GFX0.HCMX) /* \_SB_.PCI0.GFX0.HCMX */ | |
Store (One, ^^^GFX0.HDMX) /* \_SB_.PCI0.GFX0.HDMX */ | |
Store (One, ^^^GFX0.HHMX) /* \_SB_.PCI0.GFX0.HHMX */ | |
Return (One) | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
Return (0x0F) | |
If (LNotEqual (SVID, 0xFFFFFFFF)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (DSTA, 0, Serialized) | |
{ | |
Return (_STA ()) | |
} | |
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
{ | |
Return (^^^GFX0._DSM (Arg0, Arg1, Arg2, Arg3)) | |
} | |
OperationRegion (VSID, PCI_Config, Zero, 0x0100) | |
Field (VSID, ByteAcc, NoLock, Preserve) | |
{ | |
REG0, 32, | |
REG1, 32, | |
REG2, 32, | |
REG3, 32, | |
REG4, 32, | |
REG5, 32, | |
REG6, 32, | |
REG7, 32, | |
REG8, 32, | |
REG9, 32, | |
REGA, 32, | |
REGB, 32, | |
REGC, 32, | |
REGD, 32, | |
REGE, 32, | |
REGF, 32, | |
REGG, 32 | |
} | |
Name (PCTG, Package (0x0B) {}) | |
Method (PRST, 0, NotSerialized) | |
{ | |
If (LEqual (REG0, 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
Name (UPDN, One) | |
Name (NXTD, One) | |
Name (LCDM, One) | |
Name (CRTM, 0x02) | |
Name (TVOM, 0x04) | |
Name (DVIM, 0x08) | |
Name (HDMM, 0x10) | |
Name (PACH, Zero) | |
Name (DONE, Zero) | |
Name (DOSF, One) | |
Name (BRNC, Zero) | |
Method (_INI, 0, NotSerialized) // _INI: Initialize | |
{ | |
If (LNotEqual (SVID, 0xFFFFFFFF)) | |
{ | |
Store (Zero, NHDA) /* \_SB_.PCI0.PEG0.NHDA */ | |
Sleep (0x32) | |
} | |
} | |
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
{ | |
And (Arg0, 0x03, DOSF) /* \_SB_.PCI0.PEG0.PEGP.DOSF */ | |
Store (ShiftRight (Arg0, 0x02), BRNC) /* \_SB_.PCI0.PEG0.PEGP.BRNC */ | |
And (BRNC, One, BRNC) /* \_SB_.PCI0.PEG0.PEGP.BRNC */ | |
} | |
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
{ | |
Return (Package (0x04) | |
{ | |
0x0110, | |
0x80000100, | |
0x80007330, | |
0x80006340 | |
}) | |
} | |
Device (CRTD) | |
{ | |
Name (_ADR, 0x80000100) // _ADR: Address | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
Store (AVLD, Local0) | |
If (Local0) | |
{ | |
If (And (Local0, CRTM)) | |
{ | |
Return (0x1F) | |
} | |
} | |
Return (0x1D) | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
And (NXTD, CRTM, Local0) | |
If (Local0) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (And (Arg0, 0x40000000)) | |
{ | |
If (And (Arg0, 0x80000000)) | |
{ | |
Store (One, DONE) /* \_SB_.PCI0.PEG0.PEGP.DONE */ | |
} | |
} | |
} | |
} | |
Device (HDMI) | |
{ | |
Name (_ADR, 0x80007330) // _ADR: Address | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
Store (AVLD, Local0) | |
If (Local0) | |
{ | |
If (And (Local0, HDMM)) | |
{ | |
Return (0x1F) | |
} | |
} | |
Return (0x1D) | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
And (NXTD, HDMM, Local0) | |
If (Local0) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (And (Arg0, 0x40000000)) | |
{ | |
If (And (Arg0, 0x80000000)) | |
{ | |
Store (One, DONE) /* \_SB_.PCI0.PEG0.PEGP.DONE */ | |
} | |
} | |
} | |
} | |
Device (LCDD) | |
{ | |
Name (_ADR, 0x0110) // _ADR: Address | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
Store (AVLD, Local0) | |
If (Local0) | |
{ | |
If (And (Local0, LCDM)) | |
{ | |
Return (0x1F) | |
} | |
} | |
Return (0x1D) | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
And (NXTD, LCDM, Local0) | |
If (Local0) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (And (Arg0, 0x40000000)) | |
{ | |
If (And (Arg0, 0x80000000)) | |
{ | |
Store (One, DONE) /* \_SB_.PCI0.PEG0.PEGP.DONE */ | |
} | |
} | |
Store (One, DONE) /* \_SB_.PCI0.PEG0.PEGP.DONE */ | |
} | |
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels | |
{ | |
Store (Zero, Local0) | |
Store (BRTI, Local4) | |
ShiftLeft (Local4, 0x04, Local4) | |
While (LLess (Local0, 0x0B)) | |
{ | |
Subtract (0x0B, Local0, Local3) | |
Subtract (Local3, One, Local3) | |
Store (Add (Local4, Local3), Local3) | |
Store (DerefOf (Index (^^^^LPCB.EC0.PWAC, Local3)), Local1) | |
Store (Divide (Multiply (Local1, 0x64), 0xFF, ), Local2) | |
Store (Local2, Index (PCTG, Local0)) | |
Increment (Local0) | |
} | |
Return (PCTG) /* \_SB_.PCI0.PEG0.PEGP.PCTG */ | |
} | |
Name (BCBH, Zero) | |
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method | |
{ | |
Store (GCBL (Arg0), Local0) | |
Subtract (0x0A, Local0, LBTN) /* \_SB_.LBTN */ | |
^^^^LPCB.EC0.STBR () | |
} | |
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current | |
{ | |
Return (LBTN) /* \_SB_.LBTN */ | |
} | |
} | |
Method (SWHD, 1, Serialized) | |
{ | |
^^^GFX0.HWHG (Arg0) | |
} | |
Method (GETD, 0, NotSerialized) | |
{ | |
ISMI (0x95) | |
Return (ACTD) /* \_SB_.ACTD */ | |
} | |
Method (GNDD, 0, NotSerialized) | |
{ | |
ISMI (0xA0) | |
Return (SETD) /* \_SB_.SETD */ | |
} | |
Method (ADVD, 0, NotSerialized) | |
{ | |
Return (^^^GFX0.HDVG ()) | |
} | |
Method (GCDS, 0, NotSerialized) | |
{ | |
Return (^^^GFX0.GCDS ()) | |
} | |
Method (UPBL, 0, NotSerialized) | |
{ | |
If (LEqual (^^^GFX0.HGAP, 0x02)) | |
{ | |
Notify (^^^GFX0.LCDD, 0x86) // Device-Specific | |
} | |
} | |
Method (DWBL, 0, NotSerialized) | |
{ | |
If (LEqual (^^^GFX0.HGAP, 0x02)) | |
{ | |
Notify (^^^GFX0.LCDD, 0x87) // Device-Specific | |
} | |
} | |
Method (NATK, 0, NotSerialized) | |
{ | |
Return (One) | |
} | |
Method (GCBL, 1, NotSerialized) | |
{ | |
Store (Zero, Local0) | |
And (Arg0, 0x7FFFFFFF, Arg0) | |
While (LLess (Local0, 0x0B)) | |
{ | |
Store (DerefOf (Index (PCTG, Local0)), Local1) | |
If (LLessEqual (Local1, Arg0)) | |
{ | |
Break | |
} | |
Increment (Local0) | |
} | |
If (LGreaterEqual (Local0, 0x0B)) | |
{ | |
Store (0x0A, Local2) | |
} | |
Else | |
{ | |
Store (Local0, Local2) | |
} | |
Return (Local2) | |
} | |
Method (_ROM, 2, NotSerialized) // _ROM: Read-Only Memory | |
{ | |
If (RBUF) | |
{ | |
Add (Arg0, RBUF, Local0) | |
Name (VBUF, Buffer (Arg1) {}) | |
OperationRegion (VROM, SystemMemory, Local0, 0x1000) | |
Field (VROM, ByteAcc, NoLock, Preserve) | |
{ | |
ROMI, 32768 | |
} | |
Store (ROMI, VBUF) /* \_SB_.PCI0.PEG0.PEGP._ROM.VBUF */ | |
Return (VBUF) /* \_SB_.PCI0.PEG0.PEGP._ROM.VBUF */ | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
Store (Zero, ^^^GFX0._PSC) /* \_SB_.PCI0.GFX0._PSC */ | |
If (LNotEqual (^^^GFX0.DGPS, Zero)) | |
{ | |
DON () | |
Store (Zero, ^^^GFX0.DGPS) /* \_SB_.PCI0.GFX0.DGPS */ | |
} | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If (LEqual (^^^GFX0.P3MO, 0x03)) | |
{ | |
DOFF () | |
Store (0x03, ^^^GFX0._PSC) /* \_SB_.PCI0.GFX0._PSC */ | |
Store (One, ^^^GFX0.DGPS) /* \_SB_.PCI0.GFX0.DGPS */ | |
Store (0x02, ^^^GFX0.P3MO) /* \_SB_.PCI0.GFX0.P3MO */ | |
} | |
} | |
} | |
Scope (_SB.PCI0.LPCB.EC0) | |
{ | |
Method (_QB5, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (^^^PEG0.PEGP, 0xD2) // Hardware-Specific | |
} | |
Method (_QB6, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (^^^PEG0.PEGP, 0xD1) // Hardware-Specific | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
OperationRegion (HOSG, PCI_Config, Zero, 0x0100) | |
Field (HOSG, ByteAcc, NoLock, Preserve) | |
{ | |
REG0, 32, | |
REG1, 32, | |
REG2, 32, | |
Offset (0x54), | |
, 1, | |
D1EN, 1 | |
} | |
OperationRegion (MCHB, SystemMemory, 0xFED10000, 0x4000) | |
Field (MCHB, DWordAcc, Lock, Preserve) | |
{ | |
Offset (0xC14), | |
CLKD, 6 | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Device (WMI1) | |
{ | |
Name (_HID, "pnp0c14") // _HID: Hardware ID | |
Name (_UID, "MXM2") // _UID: Unique ID | |
Name (_WDG, Buffer (0xA0) | |
{ | |
/* 0000 */ 0x3C, 0x5C, 0xCB, 0xF6, 0xAE, 0x9C, 0xBD, 0x4E, /* <\.....N */ | |
/* 0008 */ 0xB5, 0x77, 0x93, 0x1E, 0xA3, 0x2A, 0x2C, 0xC0, /* .w...*,. */ | |
/* 0010 */ 0x4D, 0x58, 0x01, 0x02, 0x40, 0x2F, 0x1A, 0x92, /* MX..@/.. */ | |
/* 0018 */ 0xC4, 0x0D, 0x2D, 0x40, 0xAC, 0x18, 0xB4, 0x84, /* ..-@.... */ | |
/* 0020 */ 0x44, 0xEF, 0x9E, 0xD2, 0xD0, 0x00, 0x01, 0x08, /* D....... */ | |
/* 0028 */ 0x61, 0xD3, 0x2A, 0xC1, 0xA9, 0x9F, 0x74, 0x4C, /* a.*...tL */ | |
/* 0030 */ 0x90, 0x1F, 0x95, 0xCB, 0x09, 0x45, 0xCF, 0x3E, /* .....E.> */ | |
/* 0038 */ 0xD9, 0x00, 0x01, 0x08, 0x64, 0x35, 0x4F, 0xEF, /* ....d5O. */ | |
/* 0040 */ 0xC8, 0x48, 0x94, 0x48, 0x85, 0xC8, 0xB4, 0x6C, /* .H.H...l */ | |
/* 0048 */ 0x26, 0xB8, 0x42, 0xC0, 0xDA, 0x00, 0x01, 0x08, /* &.B..... */ | |
/* 0050 */ 0x06, 0x80, 0x84, 0x42, 0x86, 0x88, 0x0E, 0x49, /* ...B...I */ | |
/* 0058 */ 0x8C, 0x72, 0x2B, 0xDC, 0xA9, 0x3A, 0x8A, 0x09, /* .r+..:.. */ | |
/* 0060 */ 0xDB, 0x00, 0x01, 0x08, 0x62, 0xDE, 0x6B, 0xE0, /* ....b.k. */ | |
/* 0068 */ 0x75, 0xEE, 0xF4, 0x48, 0xA5, 0x83, 0xB2, 0x3E, /* u..H...> */ | |
/* 0070 */ 0x69, 0xAB, 0xF8, 0x91, 0x80, 0x00, 0x01, 0x08, /* i....... */ | |
/* 0078 */ 0x0F, 0xBD, 0xDE, 0x3A, 0x5F, 0x0C, 0xED, 0x46, /* ...:_..F */ | |
/* 0080 */ 0xAB, 0x2E, 0x04, 0x96, 0x2B, 0x4F, 0xDC, 0xBC, /* ....+O.. */ | |
/* 0088 */ 0x81, 0x00, 0x01, 0x08, 0x21, 0x12, 0x90, 0x05, /* ....!... */ | |
/* 0090 */ 0x66, 0xD5, 0xD1, 0x11, 0xB2, 0xF0, 0x00, 0xA0, /* f....... */ | |
/* 0098 */ 0xC9, 0x06, 0x29, 0x10, 0x58, 0x4D, 0x01, 0x00 /* ..).XM.. */ | |
}) | |
Method (WMMX, 3, NotSerialized) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x04)) | |
{ | |
CreateDWordField (Arg2, Zero, FUNC) | |
CreateDWordField (Arg2, 0x04, ARGS) | |
CreateDWordField (Arg2, 0x08, XARG) | |
If (LEqual (FUNC, 0x444F445F)) | |
{ | |
If (LEqual (Arg1, 0x10)) | |
{ | |
Return (^^GFX0._DOD ()) | |
} | |
Else | |
{ | |
Return (^^PEG0.PEGP._DOD ()) | |
} | |
} | |
Else | |
{ | |
If (LEqual (FUNC, 0x5343445F)) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x08)) | |
{ | |
If (LEqual (ARGS, 0x0100)) | |
{ | |
If (LEqual (Arg1, 0x10)) {} | |
Else | |
{ | |
Return (^^PEG0.PEGP.CRTD._DCS ()) | |
} | |
} | |
Else | |
{ | |
If (LEqual (ARGS, 0x0110)) | |
{ | |
If (LEqual (Arg1, 0x10)) | |
{ | |
Return (^^GFX0.LCDD._DCS ()) | |
} | |
Else | |
{ | |
} | |
} | |
Else | |
{ | |
If (LEqual (ARGS, 0x7330)) | |
{ | |
If (LNotEqual (Arg1, 0x10)) {} | |
Else | |
{ | |
Return (^^PEG0.PEGP.HDMI._DCS ()) | |
} | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (FUNC, 0x534F525F)) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x08)) | |
{ | |
If (LNotEqual (Arg1, 0x10)) | |
{ | |
Return (^^PEG0.PEGP._ROM (ARGS, XARG)) | |
} | |
} | |
} | |
Else | |
{ | |
If (LEqual (FUNC, 0x4D53445F)) | |
{ | |
If (LGreaterEqual (SizeOf (Arg2), 0x18)) | |
{ | |
CreateField (Arg2, 0x20, 0x80, MUID) | |
CreateDWordField (Arg2, 0x14, REVI) | |
CreateDWordField (Arg2, 0x18, SFNC) | |
CreateField (Arg2, 0xE0, 0x20, SARG) | |
If (LNotEqual (Arg1, 0x10)) | |
{ | |
Return (^^GFX0._DSM (MUID, REVI, SFNC, SARG)) | |
} | |
} | |
} | |
} | |
} | |
} | |
If (LEqual (FUNC, 0x47504F4E)) | |
{ | |
Store (One, ^^GFX0.DGPS) /* \_SB_.PCI0.GFX0.DGPS */ | |
^^PEG0.PEGP._PS0 () | |
} | |
} | |
Return (Zero) | |
} | |
Name (WQXM, Buffer (0x029C) | |
{ | |
/* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, /* FOMB.... */ | |
/* 0008 */ 0x8B, 0x02, 0x00, 0x00, 0x0C, 0x08, 0x00, 0x00, /* ........ */ | |
/* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, /* DS...}.T */ | |
/* 0018 */ 0x18, 0xD2, 0x83, 0x00, 0x01, 0x06, 0x18, 0x42, /* .......B */ | |
/* 0020 */ 0x10, 0x05, 0x10, 0x8A, 0xE6, 0x80, 0x42, 0x04, /* ......B. */ | |
/* 0028 */ 0x92, 0x43, 0xA4, 0x30, 0x30, 0x28, 0x0B, 0x20, /* .C.00(. */ | |
/* 0030 */ 0x86, 0x90, 0x0B, 0x26, 0x26, 0x40, 0x04, 0x84, /* ...&&@.. */ | |
/* 0038 */ 0xBC, 0x0A, 0xB0, 0x29, 0xC0, 0x24, 0x88, 0xFA, /* ...).$.. */ | |
/* 0040 */ 0xF7, 0x87, 0x28, 0x09, 0x0E, 0x25, 0x04, 0x42, /* ..(..%.B */ | |
/* 0048 */ 0x12, 0x05, 0x98, 0x17, 0xA0, 0x5B, 0x80, 0x61, /* .....[.a */ | |
/* 0050 */ 0x01, 0xB6, 0x05, 0x98, 0x16, 0xE0, 0x18, 0x92, /* ........ */ | |
/* 0058 */ 0x4A, 0x03, 0xA7, 0x04, 0x96, 0x02, 0x21, 0xA1, /* J.....!. */ | |
/* 0060 */ 0x02, 0x94, 0x0B, 0xF0, 0x2D, 0x40, 0x3B, 0xA2, /* ....-@;. */ | |
/* 0068 */ 0x24, 0x0B, 0xB0, 0x0C, 0x23, 0x02, 0x8F, 0x82, /* $...#... */ | |
/* 0070 */ 0xA1, 0x71, 0x68, 0xEC, 0x30, 0x2C, 0x13, 0x4C, /* .qh.0,.L */ | |
/* 0078 */ 0x83, 0x38, 0x8C, 0xB2, 0x91, 0x45, 0x60, 0xDC, /* .8...E`. */ | |
/* 0080 */ 0x4E, 0x05, 0xC8, 0x15, 0x20, 0x4C, 0x80, 0x78, /* N... L.x */ | |
/* 0088 */ 0x54, 0x61, 0x34, 0x07, 0x45, 0xE0, 0x42, 0x63, /* Ta4.E.Bc */ | |
/* 0090 */ 0x64, 0x40, 0xC8, 0xA3, 0x00, 0xAB, 0xA3, 0xD0, /* d@...... */ | |
/* 0098 */ 0xA4, 0x12, 0xD8, 0xBD, 0x00, 0x8D, 0x02, 0xB4, /* ........ */ | |
/* 00A0 */ 0x09, 0x70, 0x28, 0x40, 0xA1, 0x00, 0x6B, 0x18, /* .p(@..k. */ | |
/* 00A8 */ 0x72, 0x06, 0x21, 0x5B, 0xD8, 0xC2, 0x68, 0x50, /* r.![..hP */ | |
/* 00B0 */ 0x80, 0x45, 0x14, 0x8D, 0xE0, 0x2C, 0x2A, 0x9E, /* .E...,*. */ | |
/* 00B8 */ 0x93, 0x50, 0x02, 0xDA, 0x1B, 0x82, 0xF0, 0x8C, /* .P...... */ | |
/* 00C0 */ 0xD9, 0x18, 0x9E, 0x10, 0x83, 0x54, 0x86, 0x21, /* .....T.! */ | |
/* 00C8 */ 0x88, 0xB8, 0x11, 0x8E, 0xA5, 0xFD, 0x41, 0x10, /* ......A. */ | |
/* 00D0 */ 0xF9, 0xAB, 0xD7, 0xB8, 0x1D, 0x69, 0x34, 0xA8, /* .....i4. */ | |
/* 00D8 */ 0xB1, 0x26, 0x38, 0x76, 0x8F, 0xE6, 0x84, 0x3B, /* .&8v...; */ | |
/* 00E0 */ 0x17, 0x20, 0x7D, 0x6E, 0x02, 0x39, 0xBA, 0xD3, /* . }n.9.. */ | |
/* 00E8 */ 0xA8, 0x73, 0xD0, 0x64, 0x78, 0x0C, 0x2B, 0xC1, /* .s.dx.+. */ | |
/* 00F0 */ 0x7F, 0x80, 0x4F, 0x01, 0x78, 0xD7, 0x80, 0x9A, /* ..O.x... */ | |
/* 00F8 */ 0xFE, 0xC1, 0x33, 0x41, 0x70, 0xA8, 0x21, 0x7A, /* ..3Ap.!z */ | |
/* 0100 */ 0xD4, 0xE1, 0x4E, 0xE0, 0xBC, 0x8E, 0x84, 0x41, /* ..N....A */ | |
/* 0108 */ 0x1C, 0xD1, 0x71, 0x63, 0x67, 0x75, 0x32, 0x07, /* ..qcgu2. */ | |
/* 0110 */ 0x5D, 0xAA, 0x00, 0xB3, 0x07, 0x00, 0x0D, 0x2E, /* ]....... */ | |
/* 0118 */ 0xC1, 0x69, 0x9F, 0x49, 0xE8, 0xF7, 0x80, 0xF3, /* .i.I.... */ | |
/* 0120 */ 0xE9, 0x79, 0x6C, 0x6C, 0x10, 0xA8, 0x91, 0xF9, /* .yll.... */ | |
/* 0128 */ 0xFF, 0x0F, 0xED, 0x41, 0x9E, 0x56, 0xCC, 0x90, /* ...A.V.. */ | |
/* 0130 */ 0xCF, 0x02, 0x87, 0xC5, 0xC4, 0x1E, 0x19, 0xE8, /* ........ */ | |
/* 0138 */ 0x78, 0xC0, 0x7F, 0x00, 0x78, 0x34, 0x88, 0xF0, /* x...x4.. */ | |
/* 0140 */ 0x66, 0xE0, 0xF9, 0x9A, 0x60, 0x50, 0x08, 0x39, /* f...`P.9 */ | |
/* 0148 */ 0x19, 0x0F, 0x4A, 0xCC, 0xF9, 0x80, 0xCC, 0x25, /* ..J....% */ | |
/* 0150 */ 0xC4, 0x43, 0xC0, 0x31, 0xC4, 0x08, 0x7A, 0x46, /* .C.1..zF */ | |
/* 0158 */ 0x45, 0x23, 0x6B, 0x22, 0x3E, 0x03, 0x78, 0xDC, /* E#k">.x. */ | |
/* 0160 */ 0x96, 0x05, 0x42, 0x09, 0x0C, 0xEC, 0x73, 0xC3, /* ..B...s. */ | |
/* 0168 */ 0x3B, 0x84, 0x61, 0x71, 0xA3, 0x09, 0xEC, 0xF3, /* ;.aq.... */ | |
/* 0170 */ 0x85, 0x05, 0x0E, 0x0A, 0x05, 0xEB, 0xBB, 0x42, /* .......B */ | |
/* 0178 */ 0xCC, 0xE7, 0x81, 0xE3, 0x3C, 0x60, 0x0B, 0x9F, /* ....<`.. */ | |
/* 0180 */ 0x28, 0x01, 0x3E, 0x24, 0x8F, 0x06, 0xDE, 0x20, /* (.>$... */ | |
/* 0188 */ 0xE1, 0x5B, 0x3F, 0x02, 0x10, 0xE0, 0x27, 0x06, /* .[?...'. */ | |
/* 0190 */ 0x13, 0x58, 0x1E, 0x30, 0x7A, 0x94, 0xF6, 0x2B, /* .X.0z..+ */ | |
/* 0198 */ 0x00, 0x21, 0xF8, 0x8B, 0xC5, 0x53, 0xC0, 0xEB, /* .!...S.. */ | |
/* 01A0 */ 0x40, 0x84, 0x63, 0x81, 0x29, 0x72, 0x6C, 0x68, /* @.c.)rlh */ | |
/* 01A8 */ 0x78, 0x7E, 0x70, 0x88, 0x1E, 0xF5, 0x5C, 0xC2, /* x~p...\. */ | |
/* 01B0 */ 0x1F, 0x4D, 0x94, 0x53, 0x38, 0x1C, 0x1F, 0x39, /* .M.S8..9 */ | |
/* 01B8 */ 0x8C, 0x10, 0xFE, 0x49, 0xE3, 0xC9, 0xC3, 0x9A, /* ...I.... */ | |
/* 01C0 */ 0xEF, 0x00, 0x9A, 0xD2, 0x5B, 0xC0, 0xFB, 0x83, /* ....[... */ | |
/* 01C8 */ 0x47, 0x80, 0x11, 0x20, 0xE1, 0x68, 0x82, 0x89, /* G.. .h.. */ | |
/* 01D0 */ 0x7C, 0x3A, 0x01, 0xD5, 0xFF, 0xFF, 0x74, 0x02, /* |:....t. */ | |
/* 01D8 */ 0xB8, 0xBA, 0x01, 0x14, 0x37, 0x6A, 0x9D, 0x49, /* ....7j.I */ | |
/* 01E0 */ 0x7C, 0x2C, 0xF1, 0xAD, 0xE4, 0xBC, 0x43, 0xC5, /* |,....C. */ | |
/* 01E8 */ 0x7F, 0x93, 0x78, 0x3A, 0xF1, 0x34, 0x1E, 0x4C, /* ..x:.4.L */ | |
/* 01F0 */ 0x42, 0x44, 0x89, 0x18, 0x21, 0xA2, 0xEF, 0x27, /* BD..!..' */ | |
/* 01F8 */ 0x46, 0x08, 0x15, 0x31, 0x6C, 0xA4, 0x37, 0x80, /* F..1l.7. */ | |
/* 0200 */ 0xE7, 0x13, 0xE3, 0x84, 0x08, 0xF4, 0x74, 0xC2, /* ......t. */ | |
/* 0208 */ 0x42, 0x3E, 0x34, 0xA4, 0xE1, 0x74, 0x02, 0x50, /* B>4..t.P */ | |
/* 0210 */ 0xE0, 0xFF, 0x7F, 0x3A, 0x81, 0x1F, 0xF5, 0x74, /* ...:...t */ | |
/* 0218 */ 0x82, 0x1E, 0xAE, 0x4F, 0x19, 0x18, 0xE4, 0x03, /* ...O.... */ | |
/* 0220 */ 0xF2, 0xA9, 0xC3, 0xF7, 0x1F, 0x13, 0xF8, 0x78, /* .......x */ | |
/* 0228 */ 0xC2, 0x45, 0x1D, 0x4F, 0x50, 0xA7, 0x07, 0x1F, /* .E.OP... */ | |
/* 0230 */ 0x4F, 0xD8, 0x19, 0xE1, 0x2C, 0x1E, 0x03, 0x7C, /* O...,..| */ | |
/* 0238 */ 0x3A, 0xC1, 0xDC, 0x13, 0x7C, 0x3A, 0x01, 0xDB, /* :...|:.. */ | |
/* 0240 */ 0x68, 0x60, 0x1C, 0x4F, 0xC0, 0x77, 0x74, 0xC1, /* h`.O.wt. */ | |
/* 0248 */ 0x1D, 0x4F, 0xC0, 0x30, 0x18, 0x18, 0xE7, 0x13, /* .O.0.... */ | |
/* 0250 */ 0xE0, 0x31, 0x5E, 0xDC, 0x31, 0xC0, 0x43, 0xE0, /* .1^.1.C. */ | |
/* 0258 */ 0x03, 0x78, 0xDC, 0x38, 0x3D, 0x2B, 0x9D, 0x14, /* .x.8=+.. */ | |
/* 0260 */ 0xF2, 0x24, 0xC2, 0x07, 0x85, 0x39, 0xB0, 0xE0, /* .$...9.. */ | |
/* 0268 */ 0x14, 0xDA, 0xF4, 0xA9, 0xD1, 0xA8, 0x55, 0x83, /* ......U. */ | |
/* 0270 */ 0x32, 0x35, 0xCA, 0x34, 0xA8, 0xD5, 0xA7, 0x52, /* 25.4...R */ | |
/* 0278 */ 0x63, 0xC6, 0xCE, 0x19, 0x0E, 0xF8, 0x10, 0xD0, /* c....... */ | |
/* 0280 */ 0x89, 0xC0, 0xF2, 0x9E, 0x0D, 0x02, 0xB1, 0x0C, /* ........ */ | |
/* 0288 */ 0x0A, 0x81, 0x58, 0xFA, 0xAB, 0x45, 0x20, 0x0E, /* ..X..E . */ | |
/* 0290 */ 0x0E, 0xA2, 0xFF, 0x3F, 0x88, 0x23, 0xD2, 0x0A, /* ...?.#.. */ | |
/* 0298 */ 0xC4, 0xFF, 0x7F, 0x7F /* .... */ | |
}) | |
} | |
} | |
Name (_S0, Package (0x04) // _S0_: S0 System State | |
{ | |
Zero, | |
Zero, | |
Zero, | |
Zero | |
}) | |
If (SS3) | |
{ | |
Name (_S3, Package (0x04) // _S3_: S3 System State | |
{ | |
0x05, | |
Zero, | |
Zero, | |
Zero | |
}) | |
} | |
If (SS4) | |
{ | |
Name (_S4, Package (0x04) // _S4_: S4 System State | |
{ | |
0x06, | |
Zero, | |
Zero, | |
Zero | |
}) | |
} | |
Name (_S5, Package (0x04) // _S5_: S5 System State | |
{ | |
0x07, | |
Zero, | |
Zero, | |
Zero | |
}) | |
Method (PTS, 1, NotSerialized) | |
{ | |
If (Arg0) | |
{ | |
\_SB.PCI0.NPTS (Arg0) | |
\_SB.PCI0.GFX0.OPTS (Arg0) | |
OEMS (Arg0) | |
} | |
} | |
Method (WAK, 1, NotSerialized) | |
{ | |
\_SB.PCI0.XHC.XWAK (Arg0) | |
\_SB.PCI0.NWAK (Arg0) | |
\_SB.ATKD.GENW (Arg0) | |
\_SB.PCI0.GFX0.OWAK (Arg0) | |
OEMW (Arg0) | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment