Last active
September 10, 2015 20:13
-
-
Save jprvita/a15e69858b0193e2f6e4 to your computer and use it in GitHub Desktop.
DSDT ASUS-E202SA
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/ASL+ Disassembler version 20141107-64 [Dec 17 2014] | |
* Copyright (c) 2000 - 2014 Intel Corporation | |
* | |
* Disassembling to symbolic ASL+ operators | |
* | |
* Disassembly of dsdt.dat, Tue Jul 21 11:27:17 2015 | |
* | |
* Original Table Header: | |
* Signature "DSDT" | |
* Length 0x00011B62 (72546) | |
* Revision 0x02 | |
* Checksum 0x59 | |
* OEM ID "_ASUS_" | |
* OEM Table ID "Notebook" | |
* OEM Revision 0x01072009 (17244169) | |
* Compiler ID "INTL" | |
* Compiler Version 0x20150408 (538248200) | |
*/ | |
DefinitionBlock ("dsdt.aml", "DSDT", 2, "_ASUS_", "Notebook", 0x01072009) | |
{ | |
/* | |
* iASL Warning: There were 1 external control methods found during | |
* disassembly, but additional ACPI tables to resolve these externals | |
* were not specified. This resulting disassembler output file may not | |
* compile because the disassembler did not know how many arguments | |
* to assign to these methods. To specify the tables needed to resolve | |
* external control method references, the -e option can be used to | |
* specify the filenames. Example iASL invocations: | |
* iasl -e ssdt1.aml ssdt2.aml ssdt3.aml -d dsdt.aml | |
* iasl -e dsdt.aml ssdt2.aml -d ssdt1.aml | |
* iasl -e ssdt*.aml -d dsdt.aml | |
* | |
* In addition, the -fe option can be used to specify a file containing | |
* control method external declarations with the associated method | |
* argument counts. Each line of the file must be of the form: | |
* External (<method pathname>, MethodObj, <argument count>) | |
* Invocation: | |
* iasl -fe refs.txt -d dsdt.aml | |
* | |
* The following methods were unresolved and many not compile properly | |
* because the disassembler had to guess at the number of arguments | |
* required for each: | |
*/ | |
External (_SB_.PCI0.SBRG.TPM_.PTS_, MethodObj) // Warning: Unresolved method, guessing 1 arguments | |
External (_PR_.CPU0._PPC, UnknownObj) | |
External (CFGD, UnknownObj) | |
External (PDC0, UnknownObj) | |
External (PDC1, UnknownObj) | |
External (PDC2, UnknownObj) | |
External (PDC3, UnknownObj) | |
Name (LAPB, 0xFEE00000) | |
Name (CPVD, Zero) | |
Name (GBA0, 0xFED80000) | |
Name (GBA1, 0xFED88000) | |
Name (GBA2, 0xFED90000) | |
Name (GBA3, 0xFED98000) | |
Name (ABTR, 0xFEB00000) | |
Name (SMBS, 0xEFA0) | |
Name (SMBL, 0x20) | |
Name (SRCB, 0xFED1C000) | |
Name (SRCL, 0x4000) | |
Name (PMBS, 0x0400) | |
Name (PMLN, 0x80) | |
Name (SMIP, 0xB2) | |
Name (GPBS, 0x0500) | |
Name (GPLN, 0x40) | |
Name (APCB, 0xFEC00000) | |
Name (APCL, 0x1000) | |
Name (RCRB, 0xFED1C000) | |
Name (RCRL, 0x4000) | |
Name (SSEN, Zero) | |
Name (SPM1, Zero) | |
Name (ASSB, Zero) | |
Name (AOTB, Zero) | |
Name (AAXB, Zero) | |
Name (PEHP, One) | |
Name (SHPC, Zero) | |
Name (PEPM, One) | |
Name (PEER, One) | |
Name (PECS, One) | |
Name (ITKE, Zero) | |
Name (MBEC, 0xFFFF) | |
Name (PEBS, 0xE0000000) | |
Name (PELN, 0x10000000) | |
Name (SRSI, 0xB2) | |
Name (CSMI, 0x61) | |
Name (DSSP, Zero) | |
Name (FHPP, One) | |
Name (SMIA, 0xB2) | |
Name (SMIB, 0xB3) | |
Name (OFST, 0x35) | |
Name (TRST, 0x02) | |
Name (TCMF, Zero) | |
Name (TMF1, Zero) | |
Name (TMF2, Zero) | |
Name (TMF3, Zero) | |
Name (TTPF, Zero) | |
Name (DTPT, Zero) | |
Name (TTDP, One) | |
Name (TPMB, 0xFFFFFFFF) | |
Name (TPMC, 0xFFFFFFFF) | |
Name (TPMM, 0xFED40000) | |
Name (FTPM, 0xFFFFFFFF) | |
Name (AMDT, Zero) | |
Name (TPMF, Zero) | |
Name (HIDK, "MSFT0001") | |
Name (HIDM, "MSFT0003") | |
Name (CIDK, 0x0303D041) | |
Name (CIDM, 0x130FD041) | |
Name (MBLF, 0x0A) | |
Name (SP3O, 0x2E) | |
Name (IO4B, 0x0A20) | |
Name (IO4L, 0x20) | |
Name (PMCB, 0xFED03000) | |
Name (PUNB, 0xFED06000) | |
Name (IBAS, 0xFED08000) | |
Name (FMBL, One) | |
Name (FDTP, 0x02) | |
Name (GCDD, One) | |
Name (DSTA, 0x0A) | |
Name (DSLO, 0x02) | |
Name (DSLC, 0x03) | |
Name (PITS, 0x10) | |
Name (SBCS, 0x12) | |
Name (SALS, 0x13) | |
Name (LSSS, 0x2A) | |
Name (PSSS, 0x2B) | |
Name (SOOT, 0x35) | |
Name (ESCS, 0x48) | |
Name (SDGV, 0x1C) | |
Name (ACPH, 0xDE) | |
Name (FTBL, 0x04) | |
Name (CHRB, 0x80) | |
Name (CIRB, 0x82) | |
Name (CRRB, 0x55) | |
Scope (\) | |
{ | |
Method (UXDV, 1, Serialized) | |
{ | |
} | |
Method (RRIO, 4, Serialized) | |
{ | |
} | |
Method (RDMA, 3, NotSerialized) | |
{ | |
} | |
} | |
OperationRegion (GNVS, SystemMemory, 0x5B016A98, 0x0348) | |
Field (GNVS, AnyAcc, Lock, Preserve) | |
{ | |
OSYS, 16, | |
SMIF, 8, | |
P80D, 32, | |
REVS, 8, | |
OSID, 8, | |
ADED, 8, | |
BDID, 8, | |
FBID, 8, | |
STEP, 8, | |
SOCS, 8, | |
Offset (0x18), | |
APIC, 8, | |
MPEN, 8, | |
PPMF, 32, | |
PWRS, 8, | |
Offset (0x29), | |
IGDS, 8, | |
TLST, 8, | |
CADL, 8, | |
PADL, 8, | |
CSTE, 16, | |
NSTE, 16, | |
NDID, 8, | |
DID1, 32, | |
DID2, 32, | |
DID3, 32, | |
DID4, 32, | |
DID5, 32, | |
DID6, 32, | |
DID7, 32, | |
DID8, 32, | |
ASLB, 32, | |
IBTT, 8, | |
IPAT, 8, | |
ITVF, 8, | |
ITVM, 8, | |
IPSC, 8, | |
IBLC, 8, | |
IBIA, 8, | |
ISSC, 8, | |
IDMM, 8, | |
IDMS, 8, | |
IF1E, 8, | |
GSMI, 8, | |
PAVP, 8, | |
PVDR, 8, | |
BLCS, 8, | |
BRTL, 8, | |
ALSE, 8, | |
ALAF, 8, | |
LLOW, 8, | |
LHIH, 8, | |
ISPA, 32, | |
ISPD, 8, | |
RCAM, 8, | |
ECAM, 8, | |
NVGA, 32, | |
NVHA, 32, | |
AMDA, 32, | |
HGMD, 8, | |
GBAS, 32, | |
XBAS, 32, | |
HGGP, 8, | |
DLPW, 16, | |
DLHR, 16, | |
HRCO, 32, | |
HRPO, 32, | |
HRAI, 8, | |
PECO, 32, | |
PEPO, 32, | |
PEAI, 8, | |
CPSP, 32, | |
EECP, 8, | |
EVCP, 16, | |
RPBA, 32, | |
DIDX, 32, | |
EDPV, 8, | |
Offset (0xB6), | |
TPMP, 8, | |
TM2E, 8, | |
TM2A, 32, | |
TM2L, 32, | |
DTPM, 8, | |
MORD, 8, | |
PPRP, 32, | |
PPRQ, 8, | |
LPPR, 8, | |
I0D3, 8, | |
I1D3, 8, | |
I2D3, 8, | |
I3D3, 8, | |
I4D3, 8, | |
I5D3, 8, | |
I6D3, 8, | |
Offset (0xD2), | |
LPES, 8, | |
Offset (0xDC), | |
OTG0, 32, | |
OTG1, 32, | |
OTGM, 8, | |
LPE0, 32, | |
LPE1, 32, | |
LPE2, 32, | |
PFLV, 8, | |
XHCI, 8, | |
PMEN, 8, | |
USEL, 8, | |
BTHS, 8, | |
EMVR, 8, | |
GOAE, 8, | |
D10A, 32, | |
D10L, 32, | |
D11A, 32, | |
D11L, 32, | |
P10A, 32, | |
P10L, 32, | |
P11A, 32, | |
P11L, 32, | |
P20A, 32, | |
P20L, 32, | |
P21A, 32, | |
P21L, 32, | |
U10A, 32, | |
U10L, 32, | |
U11A, 32, | |
U11L, 32, | |
U20A, 32, | |
U20L, 32, | |
U21A, 32, | |
U21L, 32, | |
SP0A, 32, | |
SP0L, 32, | |
SP1A, 32, | |
SP1L, 32, | |
S20A, 32, | |
S20L, 32, | |
S21A, 32, | |
S21L, 32, | |
S30A, 32, | |
S30L, 32, | |
S31A, 32, | |
S31L, 32, | |
D20A, 32, | |
D20L, 32, | |
D21A, 32, | |
D21L, 32, | |
I10A, 32, | |
I10L, 32, | |
I11A, 32, | |
I11L, 32, | |
I20A, 32, | |
I20L, 32, | |
I21A, 32, | |
I21L, 32, | |
I30A, 32, | |
I30L, 32, | |
I31A, 32, | |
I31L, 32, | |
I40A, 32, | |
I40L, 32, | |
I41A, 32, | |
I41L, 32, | |
I50A, 32, | |
I50L, 32, | |
I51A, 32, | |
I51L, 32, | |
I60A, 32, | |
I60L, 32, | |
I61A, 32, | |
I61L, 32, | |
I70A, 32, | |
I70L, 32, | |
I71A, 32, | |
I71L, 32, | |
EM0A, 32, | |
EM0L, 32, | |
EM1A, 32, | |
EM1L, 32, | |
SI0A, 32, | |
SI0L, 32, | |
SI1A, 32, | |
SI1L, 32, | |
SD0A, 32, | |
SD0L, 32, | |
SD1A, 32, | |
SD1L, 32, | |
ISH0, 32, | |
ISH1, 32, | |
VS18, 16, | |
VD33, 16, | |
Offset (0x236), | |
Offset (0x238), | |
ITSA, 8, | |
S0IX, 8, | |
SDMD, 8, | |
ELLN, 8, | |
AUCD, 8, | |
BTMS, 8, | |
PMCT, 8, | |
PSSD, 8, | |
Offset (0x249), | |
OSCC, 8, | |
NEXP, 8, | |
GPIC, 8, | |
L01C, 8, | |
MODS, 8, | |
PB1E, 8, | |
PSDE, 8, | |
ISCT, 8, | |
LIDS, 8, | |
DSEN, 8, | |
ECON, 8, | |
ACT1, 8, | |
ACTT, 8, | |
PSVT, 8, | |
TC1V, 8, | |
TC2V, 8, | |
TSPV, 8, | |
CRTT, 8, | |
DTSE, 8, | |
DTS1, 8, | |
DTS2, 8, | |
DTSF, 8, | |
CTYP, 8, | |
VFN0, 8, | |
STTV, 16, | |
BNUM, 8, | |
B0SC, 8, | |
B1SC, 8, | |
B0SS, 8, | |
B1SS, 8, | |
BCSL, 8, | |
DBAT, 8, | |
NATP, 8, | |
CMCP, 8, | |
CIRP, 8, | |
W381, 8, | |
DPTE, 8, | |
THM0, 8, | |
THM1, 8, | |
THM2, 8, | |
THM3, 8, | |
THM4, 8, | |
CHGR, 8, | |
DDSP, 8, | |
DSOC, 8, | |
DPSR, 8, | |
DPCT, 32, | |
DPPT, 32, | |
DGC0, 32, | |
DGP0, 32, | |
DGC1, 32, | |
DGP1, 32, | |
DGC2, 32, | |
DGP2, 32, | |
DGC3, 32, | |
DGP3, 32, | |
DGC4, 32, | |
DGP4, 32, | |
DLPM, 8, | |
DSC0, 32, | |
DSC1, 32, | |
DSC2, 32, | |
DSC3, 32, | |
DSC4, 32, | |
DDBG, 8, | |
LPOE, 32, | |
LPPS, 32, | |
LPST, 32, | |
LPPC, 32, | |
LPPF, 32, | |
DPME, 8, | |
WWEN, 8, | |
WWCR, 32, | |
WWPS, 32, | |
RSVD, 8, | |
ABS0, 8, | |
ABS1, 8, | |
ABS2, 8, | |
ABS3, 8, | |
ABS4, 8, | |
ABS5, 8, | |
AMTE, 8, | |
ABC0, 8, | |
ABC1, 8, | |
ABC2, 8, | |
ABC3, 8, | |
ABC4, 8, | |
ABC5, 8, | |
DPHL, 8, | |
DPLL, 8, | |
NFCS, 8, | |
BMBD, 32, | |
FSAS, 8, | |
WIFD, 8, | |
DPPP, 8, | |
DPCP, 8, | |
DPAP, 8, | |
DGA0, 32, | |
DGS0, 32, | |
DGH0, 32, | |
DGA1, 32, | |
DGS1, 32, | |
DGH1, 32, | |
DGA2, 32, | |
DGS2, 32, | |
DGH2, 32, | |
SAAT, 32, | |
SACT, 32, | |
SAST, 32, | |
SAHT, 32, | |
SAPT, 32, | |
SCDD, 8, | |
ISPE, 8, | |
PAVB, 32, | |
PAVL, 32, | |
DRMB, 64, | |
EPBA, 32, | |
HYSS, 32 | |
} | |
Name (SS1, One) | |
Name (SS2, Zero) | |
Name (SS3, One) | |
Name (SS4, One) | |
Name (IOST, 0xFFFF) | |
Name (TOPM, 0x00000000) | |
Name (ROMS, 0xFFE00000) | |
Name (VGAF, One) | |
Method (ADBG, 1, Serialized) | |
{ | |
Return (Zero) | |
} | |
Name (WAKP, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
Method (PMED, 0, NotSerialized) | |
{ | |
\_SB.PCI0.XHC1.PMES = One | |
\_SB.PCI0.XHC1.PMEE = Zero | |
} | |
Name (PRWP, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
Method (GPRW, 2, NotSerialized) | |
{ | |
Index (PRWP, Zero) = Arg0 | |
Local0 = (SS1 << One) | |
Local0 |= (SS2 << 0x02) | |
Local0 |= (SS3 << 0x03) | |
Local0 |= (SS4 << 0x04) | |
If (((One << Arg1) & Local0)) | |
{ | |
Index (PRWP, One) = Arg1 | |
} | |
Else | |
{ | |
Local0 >>= One | |
FindSetRightBit (Local0, Index (PRWP, One)) | |
} | |
Return (PRWP) /* \PRWP */ | |
} | |
Scope (_SB) | |
{ | |
Device (RTC0) | |
{ | |
Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID | |
Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
{ | |
IO (Decode16, | |
0x0070, // Range Minimum | |
0x0070, // Range Maximum | |
0x01, // Alignment | |
0x08, // Length | |
) | |
}) | |
} | |
} | |
Scope (_SB) | |
{ | |
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) | |
Name (PR00, Package (0x1A) | |
{ | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
Zero, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x000AFFFF, | |
Zero, | |
LNKE, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x000BFFFF, | |
Zero, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0010FFFF, | |
Zero, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0011FFFF, | |
Zero, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0012FFFF, | |
Zero, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0014FFFF, | |
Zero, | |
LNKE, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0015FFFF, | |
Zero, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
Zero, | |
LNKH, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
Zero, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
0x02, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
0x03, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
One, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
Zero, | |
LNKF, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001BFFFF, | |
Zero, | |
LNKG, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
Zero, | |
LNKD, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
0x03, | |
LNKA, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
One, | |
LNKB, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
0x02, | |
LNKC, | |
Zero | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
One, | |
LNKC, | |
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) | |
{ | |
0x0013FFFF, | |
Zero, | |
LNKD, | |
Zero | |
} | |
}) | |
Name (AR00, Package (0x1A) | |
{ | |
Package (0x04) | |
{ | |
0x0002FFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0003FFFF, | |
Zero, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x000AFFFF, | |
Zero, | |
Zero, | |
0x14 | |
}, | |
Package (0x04) | |
{ | |
0x000BFFFF, | |
Zero, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x0010FFFF, | |
Zero, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x0011FFFF, | |
Zero, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x0012FFFF, | |
Zero, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0014FFFF, | |
Zero, | |
Zero, | |
0x14 | |
}, | |
Package (0x04) | |
{ | |
0x0015FFFF, | |
Zero, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x0016FFFF, | |
Zero, | |
Zero, | |
0x17 | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
Zero, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
0x02, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
0x03, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x0018FFFF, | |
One, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x001AFFFF, | |
Zero, | |
Zero, | |
0x15 | |
}, | |
Package (0x04) | |
{ | |
0x001BFFFF, | |
Zero, | |
Zero, | |
0x16 | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
Zero, | |
Zero, | |
0x13 | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
0x03, | |
Zero, | |
0x10 | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
One, | |
Zero, | |
0x11 | |
}, | |
Package (0x04) | |
{ | |
0x001EFFFF, | |
0x02, | |
Zero, | |
0x12 | |
}, | |
Package (0x04) | |
{ | |
0x001FFFFF, | |
One, | |
Zero, | |
0x12 | |
}, | |
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) | |
{ | |
0x0013FFFF, | |
Zero, | |
Zero, | |
0x13 | |
} | |
}) | |
Name (PR01, 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 (AR01, 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 (PR02, 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 (AR02, 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 (PR03, 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 (AR03, 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 (PR04, 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 (AR04, 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 | |
} | |
}) | |
} | |
Scope (_SB) | |
{ | |
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) /* \_SB_.AR00 */ | |
} | |
Return (PR00) /* \_SB_.PR00 */ | |
} | |
Device (CHVC) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
OperationRegion (HBUS, PCI_Config, Zero, 0xFF) | |
Field (HBUS, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0xD0), | |
SMCR, 32, | |
SMDR, 32, | |
MCRX, 32, | |
MCXX, 32 | |
} | |
Method (RMBR, 2, Serialized) | |
{ | |
Local0 = ((Arg0 << 0x10) | (Arg1 << 0x08)) | |
SMCR = (0x100000F0 | Local0) | |
Return (SMDR) /* \_SB_.PCI0.CHVC.SMDR */ | |
} | |
Method (WMBR, 3, Serialized) | |
{ | |
SMDR = Arg2 | |
Local0 = ((Arg0 << 0x10) | (Arg1 << 0x08)) | |
SMCR = (0x110000F0 | Local0) | |
} | |
Method (RMBX, 6, Serialized) | |
{ | |
Local4 = (Arg3 & 0x07) | |
Local4 = (Local4 << 0x08) | |
Local5 = ((Arg4 << 0x03) | Arg5) | |
Local5 &= 0xFF | |
MCXX = (Local4 | Local5) | |
Local3 = (Arg1 & 0xFFFFFF00) | |
MCRX = Local3 | |
Local0 = (Arg1 & 0xFF) | |
Local1 = ((Arg2 << 0x18) | (Arg0 << 0x10)) | |
Local1 &= 0xFFFF0000 | |
Local2 = ((Local0 << 0x08) | 0xF0) | |
Local2 &= 0xFFFF | |
SMCR = (Local1 | Local2) | |
Return (SMDR) /* \_SB_.PCI0.CHVC.SMDR */ | |
} | |
Method (WMBX, 7, Serialized) | |
{ | |
Local4 = (Arg4 & 0x07) | |
Local4 = (Local4 << 0x08) | |
Local5 = ((Arg5 << 0x03) | Arg6) | |
Local5 &= 0xFF | |
MCXX = (Local4 | Local5) | |
Local3 = (Arg1 & 0xFFFFFF00) | |
MCRX = Local3 | |
SMDR = Arg2 | |
Local0 = (Arg1 & 0xFF) | |
Local1 = ((Arg3 << 0x18) | (Arg0 << 0x10)) | |
Local1 &= 0xFFFF0000 | |
Local2 = ((Local0 << 0x08) | 0xF0) | |
Local2 &= 0xFFFF | |
SMCR = (Local1 | Local2) | |
} | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (FTSZ, 0x00100000) | |
CreateDWordField (RES0, \_SB.PCI0._Y00._MIN, LPMN) // _MIN: Minimum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y00._MAX, LPMX) // _MAX: Maximum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y00._LEN, LPLN) // _LEN: Length | |
If (((LPE2 != Zero) && (LPED == Zero))) | |
{ | |
LPMN = LPE2 /* \LPE2 */ | |
LPMX = (LPMN + LPLN) /* \_SB_.PCI0._CRS.LPLN */ | |
LPMX -= One | |
} | |
Else | |
{ | |
LPMN = Zero | |
LPMX = Zero | |
LPLN = Zero | |
} | |
CreateDWordField (RES0, \_SB.PCI0._Y01._MIN, ISMN) // _MIN: Minimum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y01._MAX, ISMX) // _MAX: Maximum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y01._LEN, ISLN) // _LEN: Length | |
If ((ISPD == One)) | |
{ | |
ISMN = ISPA /* \ISPA */ | |
ISMX = (ISMN + ISLN) /* \_SB_.PCI0._CRS.ISLN */ | |
ISMX -= One | |
} | |
Else | |
{ | |
ISMN = Zero | |
ISMX = Zero | |
ISLN = Zero | |
} | |
CreateDWordField (RES0, \_SB.PCI0._Y02._MIN, M1MN) // _MIN: Minimum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y02._MAX, M1MX) // _MAX: Maximum Base Address | |
CreateDWordField (RES0, \_SB.PCI0._Y02._LEN, M1LN) // _LEN: Length | |
M1MN = (BMBD & 0xFF000000) | |
M1LN = ((M1MX - M1MN) + One) | |
Return (RES0) /* \_SB_.PCI0.RES0 */ | |
} | |
Name (RES0, ResourceTemplate () | |
{ | |
WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, | |
0x0000, // Granularity | |
0x0000, // Range Minimum | |
0x00FF, // Range Maximum | |
0x0000, // Translation Offset | |
0x0100, // Length | |
,, ) | |
IO (Decode16, | |
0x0070, // Range Minimum | |
0x0077, // Range Maximum | |
0x01, // Alignment | |
0x08, // Length | |
) | |
IO (Decode16, | |
0x0CF8, // Range Minimum | |
0x0CF8, // Range Maximum | |
0x01, // Alignment | |
0x08, // Length | |
) | |
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
0x0000, // Granularity | |
0x0000, // Range Minimum | |
0x006F, // Range Maximum | |
0x0000, // Translation Offset | |
0x0070, // Length | |
,, , TypeStatic) | |
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
0x0000, // Granularity | |
0x0078, // Range Minimum | |
0x0CF7, // Range Maximum | |
0x0000, // Translation Offset | |
0x0C80, // Length | |
,, , TypeStatic) | |
WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
0x0000, // Granularity | |
0x0D00, // Range Minimum | |
0xFFFF, // Range Maximum | |
0x0000, // Translation Offset | |
0xF300, // 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 | |
0x000DFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00020000, // Length | |
,, , AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x000E0000, // Range Minimum | |
0x000FFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00020000, // Length | |
,, , AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x20000000, // Range Minimum | |
0x201FFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00200000, // Length | |
,, _Y00, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x7A000000, // Range Minimum | |
0x7A3FFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x00400000, // Length | |
,, _Y01, AddressRangeMemory, TypeStatic) | |
DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
0x00000000, // Granularity | |
0x80000000, // Range Minimum | |
0xDFFFFFFF, // Range Maximum | |
0x00000000, // Translation Offset | |
0x60000000, // Length | |
,, _Y02, AddressRangeMemory, TypeStatic) | |
}) | |
Name (GUID, ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */) | |
Name (SUPP, Zero) | |
Name (CTRL, Zero) | |
Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities | |
{ | |
Local0 = Arg3 | |
CreateDWordField (Local0, Zero, CDW1) | |
CreateDWordField (Local0, 0x04, CDW2) | |
CreateDWordField (Local0, 0x08, CDW3) | |
If (((Arg0 == GUID) && NEXP)) | |
{ | |
SUPP = CDW2 /* \_SB_.PCI0._OSC.CDW2 */ | |
CTRL = CDW3 /* \_SB_.PCI0._OSC.CDW3 */ | |
If (~(CDW1 & One)) | |
{ | |
If ((CTRL & 0x02)) | |
{ | |
NHPG () | |
} | |
If ((CTRL & 0x04)) | |
{ | |
NPME () | |
} | |
} | |
If ((Arg1 != One)) | |
{ | |
CDW1 |= 0x08 | |
} | |
If ((CDW3 != CTRL)) | |
{ | |
CDW1 |= 0x10 | |
} | |
CDW3 = CTRL /* \_SB_.PCI0.CTRL */ | |
OSCC = CTRL /* \_SB_.PCI0.CTRL */ | |
Return (Local0) | |
} | |
Else | |
{ | |
CDW1 |= 0x04 | |
Return (Local0) | |
} | |
} | |
Device (GFX0) | |
{ | |
Name (_ADR, 0x00020000) // _ADR: Address | |
Name (_S0W, 0x03) // _S0W: S0 Device Wake State | |
Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
{ | |
DSEN = (Arg0 & 0x07) | |
If (DRDY) | |
{ | |
DOSF = (Arg0 & 0x03) | |
BRNC = (Arg0 >> 0x02) | |
BRNC &= One | |
} | |
} | |
Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
{ | |
If ((ISPE == One)) | |
{ | |
NDID = One | |
} | |
Else | |
{ | |
NDID = Zero | |
} | |
If ((DIDL != Zero)) | |
{ | |
DID1 = SDDL (DIDL) | |
} | |
If ((DDL2 != Zero)) | |
{ | |
DID2 = SDDL (DDL2) | |
} | |
If ((DDL3 != Zero)) | |
{ | |
DID3 = SDDL (DDL3) | |
} | |
If ((DDL4 != Zero)) | |
{ | |
DID4 = SDDL (DDL4) | |
} | |
If ((DDL5 != Zero)) | |
{ | |
DID5 = SDDL (DDL5) | |
} | |
If ((DDL6 != Zero)) | |
{ | |
DID6 = SDDL (DDL6) | |
} | |
If ((DDL7 != Zero)) | |
{ | |
DID7 = SDDL (DDL7) | |
} | |
If ((DDL8 != Zero)) | |
{ | |
DID8 = SDDL (DDL8) | |
} | |
If ((NDID == One)) | |
{ | |
Name (TMP1, Package (0x01) | |
{ | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP1, Zero) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP1, Zero) = (0x00010000 | DID1) | |
} | |
Return (TMP1) /* \_SB_.PCI0.GFX0._DOD.TMP1 */ | |
} | |
If ((NDID == 0x02)) | |
{ | |
Name (TMP2, Package (0x02) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP2, Zero) = (0x00010000 | DID1) | |
Index (TMP2, One) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP2, Zero) = (0x00010000 | DID1) | |
Index (TMP2, One) = (0x00010000 | DID2) | |
} | |
Return (TMP2) /* \_SB_.PCI0.GFX0._DOD.TMP2 */ | |
} | |
If ((NDID == 0x03)) | |
{ | |
Name (TMP3, Package (0x03) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP3, Zero) = (0x00010000 | DID1) | |
Index (TMP3, One) = (0x00010000 | DID2) | |
Index (TMP3, 0x02) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP3, Zero) = (0x00010000 | DID1) | |
Index (TMP3, One) = (0x00010000 | DID2) | |
Index (TMP3, 0x02) = (0x00010000 | DID3) | |
} | |
Return (TMP3) /* \_SB_.PCI0.GFX0._DOD.TMP3 */ | |
} | |
If ((NDID == 0x04)) | |
{ | |
Name (TMP4, Package (0x04) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP4, Zero) = (0x00010000 | DID1) | |
Index (TMP4, One) = (0x00010000 | DID2) | |
Index (TMP4, 0x02) = (0x00010000 | DID3) | |
Index (TMP4, 0x03) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP4, Zero) = (0x00010000 | DID1) | |
Index (TMP4, One) = (0x00010000 | DID2) | |
Index (TMP4, 0x02) = (0x00010000 | DID3) | |
Index (TMP4, 0x03) = (0x00010000 | DID4) | |
} | |
Return (TMP4) /* \_SB_.PCI0.GFX0._DOD.TMP4 */ | |
} | |
If ((NDID == 0x05)) | |
{ | |
Name (TMP5, Package (0x05) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP5, Zero) = (0x00010000 | DID1) | |
Index (TMP5, One) = (0x00010000 | DID2) | |
Index (TMP5, 0x02) = (0x00010000 | DID3) | |
Index (TMP5, 0x03) = (0x00010000 | DID4) | |
Index (TMP5, 0x04) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP5, Zero) = (0x00010000 | DID1) | |
Index (TMP5, One) = (0x00010000 | DID2) | |
Index (TMP5, 0x02) = (0x00010000 | DID3) | |
Index (TMP5, 0x03) = (0x00010000 | DID4) | |
Index (TMP5, 0x04) = (0x00010000 | DID5) | |
} | |
Return (TMP5) /* \_SB_.PCI0.GFX0._DOD.TMP5 */ | |
} | |
If ((NDID == 0x06)) | |
{ | |
Name (TMP6, Package (0x06) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP6, Zero) = (0x00010000 | DID1) | |
Index (TMP6, One) = (0x00010000 | DID2) | |
Index (TMP6, 0x02) = (0x00010000 | DID3) | |
Index (TMP6, 0x03) = (0x00010000 | DID4) | |
Index (TMP6, 0x04) = (0x00010000 | DID5) | |
Index (TMP6, 0x05) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP6, Zero) = (0x00010000 | DID1) | |
Index (TMP6, One) = (0x00010000 | DID2) | |
Index (TMP6, 0x02) = (0x00010000 | DID3) | |
Index (TMP6, 0x03) = (0x00010000 | DID4) | |
Index (TMP6, 0x04) = (0x00010000 | DID5) | |
Index (TMP6, 0x05) = (0x00010000 | DID6) | |
} | |
Return (TMP6) /* \_SB_.PCI0.GFX0._DOD.TMP6 */ | |
} | |
If ((NDID == 0x07)) | |
{ | |
Name (TMP7, Package (0x07) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP7, Zero) = (0x00010000 | DID1) | |
Index (TMP7, One) = (0x00010000 | DID2) | |
Index (TMP7, 0x02) = (0x00010000 | DID3) | |
Index (TMP7, 0x03) = (0x00010000 | DID4) | |
Index (TMP7, 0x04) = (0x00010000 | DID5) | |
Index (TMP7, 0x05) = (0x00010000 | DID6) | |
Index (TMP7, 0x06) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP7, Zero) = (0x00010000 | DID1) | |
Index (TMP7, One) = (0x00010000 | DID2) | |
Index (TMP7, 0x02) = (0x00010000 | DID3) | |
Index (TMP7, 0x03) = (0x00010000 | DID4) | |
Index (TMP7, 0x04) = (0x00010000 | DID5) | |
Index (TMP7, 0x05) = (0x00010000 | DID6) | |
Index (TMP7, 0x06) = (0x00010000 | DID7) | |
} | |
Return (TMP7) /* \_SB_.PCI0.GFX0._DOD.TMP7 */ | |
} | |
If ((NDID > 0x07)) | |
{ | |
Name (TMP8, Package (0x08) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
If ((ISPE == One)) | |
{ | |
Index (TMP8, Zero) = (0x00010000 | DID1) | |
Index (TMP8, One) = (0x00010000 | DID2) | |
Index (TMP8, 0x02) = (0x00010000 | DID3) | |
Index (TMP8, 0x03) = (0x00010000 | DID4) | |
Index (TMP8, 0x04) = (0x00010000 | DID5) | |
Index (TMP8, 0x05) = (0x00010000 | DID6) | |
Index (TMP8, 0x06) = (0x00010000 | DID7) | |
Index (TMP8, 0x07) = 0x000222B8 | |
} | |
Else | |
{ | |
Index (TMP8, Zero) = (0x00010000 | DID1) | |
Index (TMP8, One) = (0x00010000 | DID2) | |
Index (TMP8, 0x02) = (0x00010000 | DID3) | |
Index (TMP8, 0x03) = (0x00010000 | DID4) | |
Index (TMP8, 0x04) = (0x00010000 | DID5) | |
Index (TMP8, 0x05) = (0x00010000 | DID6) | |
Index (TMP8, 0x06) = (0x00010000 | DID7) | |
Index (TMP8, 0x07) = (0x00010000 | DID8) | |
} | |
Return (TMP8) /* \_SB_.PCI0.GFX0._DOD.TMP8 */ | |
} | |
Return (Package (0x02) | |
{ | |
0x0400, | |
0x000222B8 | |
}) | |
} | |
Device (DD01) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID1) == 0x0400)) | |
{ | |
EDPV = One | |
DIDX = DID1 /* \DID1 */ | |
Return ((0xFFFF & DID1)) | |
} | |
If ((DID1 == Zero)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
Method (MINB, 0, NotSerialized) | |
{ | |
If (ARDY) | |
{ | |
Local1 = BRTI /* \_SB_.BRTI */ | |
Local1 <<= 0x04 | |
Local0 = DerefOf (Index (^^^SBRG.EC0.PWAC, Local1)) | |
TCHE |= 0x08 | |
ASLC |= 0x08 | |
PFMB = Local0 | |
PFMB |= 0x0100 | |
ASLE = One | |
} | |
} | |
Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
Local0 = 0x65 | |
Local0 += 0x02 | |
Name (BRPP, Package (0x67) {}) | |
Index (BRPP, Zero) = 0x64 | |
Index (BRPP, One) = 0x28 | |
Local1 = 0x02 | |
Local2 = 0x64 | |
While ((Local1 < Local0)) | |
{ | |
Index (BRPP, Local1) = Local2 | |
Local1++ | |
Local2-- | |
} | |
Local0 = Zero | |
While ((Local0 <= 0x0A)) | |
{ | |
Index (PCTG, (0x0A - Local0)) = (Local0 * 0x0A) | |
Local0++ | |
} | |
MINB () | |
Return (BRPP) /* \_SB_.PCI0.GFX0.DD01._BCL.BRPP */ | |
} | |
Else | |
{ | |
Local0 = Zero | |
Local4 = BRTI /* \_SB_.BRTI */ | |
Local4 <<= 0x04 | |
While ((Local0 < 0x0B)) | |
{ | |
Local3 = (0x0B - Local0) | |
Local3 -= One | |
Local3 = (Local4 + Local3) | |
Local1 = DerefOf (Index (^^^SBRG.EC0.PWAC, Local3)) | |
Local2 = ((Local1 * 0x64) / 0xFF) | |
Index (PCTG, Local0) = Local2 | |
Local0++ | |
} | |
MINB () | |
Return (PCTG) /* \_SB_.PCI0.GFX0.PCTG */ | |
} | |
} | |
Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method | |
{ | |
BCMD = One | |
Local0 = GCBL (Arg0) | |
LBTN = (0x0A - Local0) | |
^^^SBRG.EC0.STBR () | |
} | |
Method (_BQC, 0, NotSerialized) // _BQC: Brightness Query Current | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
Local0 = (CBLV & 0x7FFFFFFF) | |
Return (Local0) | |
} | |
Else | |
{ | |
Local1 = BRTI /* \_SB_.BRTI */ | |
Local1 <<= 0x04 | |
Local2 = LBTN /* \_SB_.LBTN */ | |
Local2 = (Local1 + Local2) | |
Local3 = (DerefOf (Index (^^^SBRG.EC0.PWAC, Local2)) * 0x64) | |
Local3 = (Local3 / 0xFF) | |
Return (Local3) | |
} | |
} | |
} | |
Device (DD02) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID2) == 0x0400)) | |
{ | |
EDPV = 0x02 | |
DIDX = DID2 /* \DID2 */ | |
Return ((0xFFFF & DID2)) | |
} | |
If ((DID2 == Zero)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
Return ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD03) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID3) == 0x0400)) | |
{ | |
EDPV = 0x03 | |
DIDX = DID3 /* \DID3 */ | |
Return ((0xFFFF & DID3)) | |
} | |
If ((DID3 == Zero)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID3)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD04) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID4) == 0x0400)) | |
{ | |
EDPV = 0x04 | |
DIDX = DID4 /* \DID4 */ | |
Return ((0xFFFF & DID4)) | |
} | |
If ((DID4 == Zero)) | |
{ | |
Return (0x04) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID4)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD05) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID5) == 0x0400)) | |
{ | |
EDPV = 0x05 | |
DIDX = DID5 /* \DID5 */ | |
Return ((0xFFFF & DID5)) | |
} | |
If ((DID5 == Zero)) | |
{ | |
Return (0x05) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID5)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD06) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID6) == 0x0400)) | |
{ | |
EDPV = 0x06 | |
DIDX = DID6 /* \DID6 */ | |
Return ((0xFFFF & DID6)) | |
} | |
If ((DID6 == Zero)) | |
{ | |
Return (0x06) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID6)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD07) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID7) == 0x0400)) | |
{ | |
EDPV = 0x07 | |
DIDX = DID7 /* \DID7 */ | |
Return ((0xFFFF & DID7)) | |
} | |
If ((DID7 == Zero)) | |
{ | |
Return (0x07) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID7)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD08) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If (((0x0F00 & DID8) == 0x0400)) | |
{ | |
EDPV = 0x08 | |
DIDX = DID8 /* \DID8 */ | |
Return ((0xFFFF & DID8)) | |
} | |
If ((DID8 == Zero)) | |
{ | |
Return (0x08) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DID8)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((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 (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Device (DD1F) | |
{ | |
Method (_ADR, 0, Serialized) // _ADR: Address | |
{ | |
If ((EDPV == Zero)) | |
{ | |
Return (0x1F) | |
} | |
Else | |
{ | |
Return ((0xFFFF & DIDX)) | |
} | |
} | |
Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
{ | |
If ((EDPV == Zero)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (CDDS (DIDX)) | |
} | |
} | |
Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
{ | |
Return (NDDS (DIDX)) | |
} | |
Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
{ | |
If (((Arg0 & 0xC0000000) == 0xC0000000)) | |
{ | |
CSTE = NSTE /* \_SB_.NSTE */ | |
} | |
} | |
} | |
Method (SDDL, 1, NotSerialized) | |
{ | |
NDID++ | |
Local0 = (Arg0 & 0x0F0F) | |
Local1 = (0x80000000 | Local0) | |
If ((DIDL == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL2 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL3 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL4 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL5 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL6 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL7 == Local0)) | |
{ | |
Return (Local1) | |
} | |
If ((DDL8 == Local0)) | |
{ | |
Return (Local1) | |
} | |
Return (Zero) | |
} | |
Method (CDDS, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 & 0x0F0F) | |
If ((Zero == Local0)) | |
{ | |
Return (0x1D) | |
} | |
If ((CADL == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL2 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL3 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL4 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL5 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL6 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL7 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
If ((CAL8 == Local0)) | |
{ | |
Return (0x1F) | |
} | |
Return (0x1D) | |
} | |
Method (NDDS, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 & 0x0F0F) | |
If ((Zero == Local0)) | |
{ | |
Return (Zero) | |
} | |
If ((NADL == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL2 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL3 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL4 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL5 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL6 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL7 == Local0)) | |
{ | |
Return (One) | |
} | |
If ((NDL8 == Local0)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
OperationRegion (IGDP, PCI_Config, Zero, 0x0100) | |
Field (IGDP, AnyAcc, NoLock, Preserve) | |
{ | |
GVID, 32, | |
Offset (0x10), | |
MADR, 32, | |
Offset (0x50), | |
, 1, | |
GIVD, 1, | |
, 1, | |
GUMA, 5, | |
Offset (0x52), | |
Offset (0x54), | |
, 4, | |
GMFN, 1, | |
Offset (0x58), | |
Offset (0x5C), | |
GSTM, 32, | |
Offset (0xE0), | |
GSSE, 1, | |
GSSB, 14, | |
GSES, 1, | |
Offset (0xE4), | |
ASLE, 8, | |
Offset (0xE8), | |
Offset (0xFC), | |
ASLS, 32 | |
} | |
Method (GTTM, 0, Serialized) | |
{ | |
If ((GVID == 0xFFFFFFFF)) | |
{ | |
Return (ABTR) /* \ABTR */ | |
} | |
Else | |
{ | |
Return (MADR) /* \_SB_.PCI0.GFX0.MADR */ | |
} | |
} | |
OperationRegion (IGMM, SystemMemory, GTTM (), 0x3000) | |
Field (IGMM, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x20C8), | |
, 4, | |
DCFE, 4 | |
} | |
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 (0x06) | |
{ | |
Package (0x01) | |
{ | |
0xA0 | |
}, | |
Package (0x01) | |
{ | |
0xC8 | |
}, | |
Package (0x01) | |
{ | |
0x010B | |
}, | |
Package (0x01) | |
{ | |
0x0140 | |
}, | |
Package (0x01) | |
{ | |
0x0164 | |
}, | |
Package (0x01) | |
{ | |
0x0190 | |
} | |
}) | |
Name (SUCC, One) | |
Name (NVLD, 0x02) | |
Name (CRIT, 0x04) | |
Name (NCRT, 0x06) | |
Method (GSCI, 0, Serialized) | |
{ | |
Method (GBDA, 0, Serialized) | |
{ | |
If ((GESF == Zero)) | |
{ | |
PARM = 0x0279 | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == One)) | |
{ | |
PARM = 0x0240 | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x04)) | |
{ | |
PARM &= 0xEFFF0000 | |
PARM &= (DerefOf (Index (DBTB, IBTT)) << 0x10) | |
PARM |= IBTT /* \_SB_.PCI0.GFX0.PARM */ | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x05)) | |
{ | |
PARM = IPSC /* \IPSC */ | |
PARM |= (IPAT << 0x08) | |
PARM += 0x0100 | |
PARM |= (LIDS << 0x10) | |
PARM += 0x00010000 | |
PARM |= (IBLC << 0x12) | |
PARM |= (IBIA << 0x14) | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x06)) | |
{ | |
PARM = ITVF /* \ITVF */ | |
PARM |= (ITVM << 0x04) | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x07)) | |
{ | |
PARM = GIVD /* \_SB_.PCI0.GFX0.GIVD */ | |
PARM ^= One | |
PARM |= (GMFN << One) | |
PARM |= 0x1800 | |
PARM |= (IDMS << 0x11) | |
PARM |= (DerefOf (Index (CDCT, DCFE)) << 0x15) /* \_SB_.PCI0.GFX0.PARM */ | |
GESF = One | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x0A)) | |
{ | |
PARM = Zero | |
If (ISSC) | |
{ | |
PARM |= 0x03 | |
} | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
GESF = Zero | |
Return (CRIT) /* \_SB_.PCI0.GFX0.CRIT */ | |
} | |
Method (SBCB, 0, Serialized) | |
{ | |
If ((GESF == Zero)) | |
{ | |
PARM = Zero | |
If ((PFLV == FMBL)) | |
{ | |
PARM = 0x000F87FD | |
} | |
If ((PFLV == FDTP)) | |
{ | |
PARM = 0x000F87BD | |
} | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == One)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x03)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x04)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x05)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x06)) | |
{ | |
ITVF = (PARM & 0x0F) | |
ITVM = ((PARM & 0xF0) >> 0x04) | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x07)) | |
{ | |
If ((PARM == Zero)) | |
{ | |
Local0 = CLID /* \_SB_.PCI0.GFX0.CLID */ | |
If ((0x80000000 & Local0)) | |
{ | |
CLID &= 0x0F | |
GLID (CLID) | |
} | |
} | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x08)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x09)) | |
{ | |
IBTT = (PARM & 0xFF) | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x0A)) | |
{ | |
IPSC = (PARM & 0xFF) | |
If (((PARM >> 0x08) & 0xFF)) | |
{ | |
IPAT = ((PARM >> 0x08) & 0xFF) | |
IPAT-- | |
} | |
IBLC = ((PARM >> 0x12) & 0x03) | |
IBIA = ((PARM >> 0x14) & 0x07) | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x0B)) | |
{ | |
IF1E = ((PARM >> One) & One) | |
IDMS = ((PARM >> 0x11) & 0x0F) | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x10)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x11)) | |
{ | |
PARM = (LIDS << 0x08) | |
PARM += 0x0100 | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x12)) | |
{ | |
If ((PARM & One)) | |
{ | |
If (((PARM >> One) == One)) | |
{ | |
ISSC = One | |
} | |
Else | |
{ | |
GESF = Zero | |
Return (CRIT) /* \_SB_.PCI0.GFX0.CRIT */ | |
} | |
} | |
Else | |
{ | |
ISSC = Zero | |
} | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x13)) | |
{ | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GESF == 0x14)) | |
{ | |
PAVP = (PARM & 0x0F) | |
GESF = Zero | |
PARM = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
GESF = Zero | |
Return (SUCC) /* \_SB_.PCI0.GFX0.SUCC */ | |
} | |
If ((GVID != 0xFFFFFFFF)) | |
{ | |
If ((GEFC == 0x04)) | |
{ | |
GXFC = GBDA () | |
} | |
If ((GEFC == 0x06)) | |
{ | |
GXFC = SBCB () | |
} | |
GEFC = Zero | |
GSSE = Zero | |
SCIE = Zero | |
} | |
SCIS = One | |
Return (Zero) | |
} | |
Method (PDRD, 0, NotSerialized) | |
{ | |
If (!DRDY) | |
{ | |
Sleep (ASLP) | |
} | |
Return (!DRDY) | |
} | |
Method (PSTS, 0, NotSerialized) | |
{ | |
If ((CSTS > 0x02)) | |
{ | |
Sleep (ASLP) | |
} | |
Return ((CSTS == 0x03)) | |
} | |
Method (GNOT, 2, NotSerialized) | |
{ | |
If (PDRD ()) | |
{ | |
Return (One) | |
} | |
CEVT = Arg0 | |
CSTS = 0x03 | |
If (((CHPD == Zero) && (Arg1 == Zero))) | |
{ | |
If (((OSYS > 0x07D0) || (OSYS < 0x07D6))) | |
{ | |
Notify (PCI0, Arg1) | |
} | |
Else | |
{ | |
Notify (GFX0, Arg1) | |
} | |
} | |
Notify (GFX0, 0x80) // Status Change | |
Return (Zero) | |
} | |
Method (GHDS, 1, NotSerialized) | |
{ | |
TIDX = Arg0 | |
Return (GNOT (One, Zero)) | |
} | |
Method (GLID, 1, NotSerialized) | |
{ | |
CLID = Arg0 | |
Return (GNOT (0x02, Zero)) | |
} | |
Method (GDCK, 1, NotSerialized) | |
{ | |
CDCK = Arg0 | |
Return (GNOT (0x04, Zero)) | |
} | |
Method (PARD, 0, NotSerialized) | |
{ | |
If (!ARDY) | |
{ | |
Sleep (ASLP) | |
} | |
Return (!ARDY) | |
} | |
Method (AINT, 2, NotSerialized) | |
{ | |
If (!(TCHE & (One << Arg0))) | |
{ | |
Return (One) | |
} | |
If (PARD ()) | |
{ | |
Return (One) | |
} | |
If ((Arg0 == 0x02)) | |
{ | |
If (CPFM) | |
{ | |
Local0 = (CPFM & 0x0F) | |
Local1 = (EPFM & 0x0F) | |
If ((Local0 == One)) | |
{ | |
If ((Local1 & 0x06)) | |
{ | |
PFIT = 0x06 | |
} | |
Else | |
{ | |
If ((Local1 & 0x08)) | |
{ | |
PFIT = 0x08 | |
} | |
Else | |
{ | |
PFIT = One | |
} | |
} | |
} | |
If ((Local0 == 0x06)) | |
{ | |
If ((Local1 & 0x08)) | |
{ | |
PFIT = 0x08 | |
} | |
Else | |
{ | |
If ((Local1 & One)) | |
{ | |
PFIT = One | |
} | |
Else | |
{ | |
PFIT = 0x06 | |
} | |
} | |
} | |
If ((Local0 == 0x08)) | |
{ | |
If ((Local1 & One)) | |
{ | |
PFIT = One | |
} | |
Else | |
{ | |
If ((Local1 & 0x06)) | |
{ | |
PFIT = 0x06 | |
} | |
Else | |
{ | |
PFIT = 0x08 | |
} | |
} | |
} | |
} | |
Else | |
{ | |
PFIT ^= 0x07 | |
} | |
PFIT |= 0x80000000 | |
ASLC = 0x04 | |
} | |
Else | |
{ | |
If ((Arg0 == One)) | |
{ | |
BCLP = ((Arg1 * 0xFF) / 0x64) | |
BCLP |= 0x80000000 | |
ASLC = 0x02 | |
} | |
Else | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
ALSI = Arg1 | |
ASLC = One | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
} | |
ASLE = One | |
Return (Zero) | |
} | |
Method (SCIP, 0, NotSerialized) | |
{ | |
If ((OVER != Zero)) | |
{ | |
Return (!GSMI) | |
} | |
Return (Zero) | |
} | |
Name (OPBS, 0xFFFFFF00) | |
Method (OPTS, 1, NotSerialized) | |
{ | |
If ((VGAF & One)) | |
{ | |
If ((Arg0 == 0x03)) | |
{ | |
OPBS = ASLS /* \_SB_.PCI0.GFX0.ASLS */ | |
} | |
} | |
} | |
Method (OWAK, 1, NotSerialized) | |
{ | |
If ((VGAF & One)) | |
{ | |
If ((Arg0 == 0x03)) | |
{ | |
ASLS = OPBS /* \_SB_.PCI0.GFX0.OPBS */ | |
GSES = One | |
} | |
CLID = One | |
} | |
} | |
Method (OGCD, 0, NotSerialized) | |
{ | |
If ((CADL == Zero)) | |
{ | |
CSTE = LCDM /* \_SB_.PCI0.GFX0.LCDM */ | |
Return (Zero) | |
} | |
CSTE = OA2D (CADL) | |
If ((CAL2 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL2) /* \_SB_.CSTE */ | |
If ((CAL3 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL3) /* \_SB_.CSTE */ | |
If ((CAL4 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL4) /* \_SB_.CSTE */ | |
If ((CAL5 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL5) /* \_SB_.CSTE */ | |
If ((CAL6 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL6) /* \_SB_.CSTE */ | |
If ((CAL7 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL7) /* \_SB_.CSTE */ | |
If ((CAL8 == Zero)) | |
{ | |
Return (Zero) | |
} | |
CSTE |= OA2D (CAL8) /* \_SB_.CSTE */ | |
Return (Zero) | |
} | |
Method (OGND, 0, NotSerialized) | |
{ | |
If ((NADL == Zero)) | |
{ | |
NSTE = LCDM /* \_SB_.PCI0.GFX0.LCDM */ | |
Return (Zero) | |
} | |
NSTE = OA2D (NADL) | |
If ((NDL2 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL2) /* \_SB_.NSTE */ | |
If ((NDL3 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL3) /* \_SB_.NSTE */ | |
If ((NDL4 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL4) /* \_SB_.NSTE */ | |
If ((NDL5 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL5) /* \_SB_.NSTE */ | |
If ((NDL6 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL6) /* \_SB_.NSTE */ | |
If ((NDL7 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL7) /* \_SB_.NSTE */ | |
If ((NDL8 == Zero)) | |
{ | |
Return (Zero) | |
} | |
NSTE |= OA2D (NDL8) /* \_SB_.NSTE */ | |
Return (Zero) | |
} | |
Method (OGCA, 0, NotSerialized) | |
{ | |
SOID () | |
If ((CPDL == Zero)) | |
{ | |
OCAD = LCDM /* \_SB_.PCI0.GFX0.LCDM */ | |
Return (Zero) | |
} | |
OCAD = OA2D (CPDL) | |
If ((CPL2 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL2) /* \_SB_.OCAD */ | |
If ((CPL3 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL3) /* \_SB_.OCAD */ | |
If ((CPL4 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL4) /* \_SB_.OCAD */ | |
If ((CPL5 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL5) /* \_SB_.OCAD */ | |
If ((CPL6 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL6) /* \_SB_.OCAD */ | |
If ((CPL7 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL7) /* \_SB_.OCAD */ | |
If ((CPL8 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OCAD |= OA2D (CPL8) /* \_SB_.OCAD */ | |
Return (Zero) | |
} | |
Method (OA2D, 1, NotSerialized) | |
{ | |
Local0 = Zero | |
If ((Arg0 == LFID)) | |
{ | |
Local0 |= LCDM /* \_SB_.PCI0.GFX0.LCDM */ | |
} | |
If ((Arg0 == CRID)) | |
{ | |
Local0 |= CRTM /* \_SB_.PCI0.GFX0.CRTM */ | |
} | |
If ((Arg0 == TVID)) | |
{ | |
Local0 |= TVOM /* \_SB_.PCI0.GFX0.TVOM */ | |
} | |
If ((Arg0 == HDID)) | |
{ | |
Local0 |= HDMM /* \_SB_.PCI0.GFX0.HDMM */ | |
} | |
If ((Arg0 == DVID)) | |
{ | |
Local0 |= DVIM /* \_SB_.PCI0.GFX0.DVIM */ | |
} | |
If ((Arg0 == DPID)) | |
{ | |
Local0 |= DPOM /* \_SB_.PCI0.GFX0.DPOM */ | |
} | |
Return (Local0) | |
} | |
Method (D2OA, 1, NotSerialized) | |
{ | |
Local0 = Zero | |
If ((Arg0 & LCDM)) | |
{ | |
Return (LFID) /* \_SB_.PCI0.GFX0.LFID */ | |
} | |
If ((Arg0 & CRTM)) | |
{ | |
Return (CRID) /* \_SB_.PCI0.GFX0.CRID */ | |
} | |
If ((Arg0 & TVOM)) | |
{ | |
Return (TVID) /* \_SB_.PCI0.GFX0.TVID */ | |
} | |
If ((Arg0 & HDMM)) | |
{ | |
Return (HDID) /* \_SB_.PCI0.GFX0.HDID */ | |
} | |
If ((Arg0 & DVIM)) | |
{ | |
Return (DVID) /* \_SB_.PCI0.GFX0.DVID */ | |
} | |
If ((Arg0 & DPOM)) | |
{ | |
Return (DPID) /* \_SB_.PCI0.GFX0.DPID */ | |
} | |
Return (Local0) | |
} | |
Name (DDID, Zero) | |
Method (WNDD, 1, NotSerialized) | |
{ | |
DDID = GDOA (Arg0) | |
NADL = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL2 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL3 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL4 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL5 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL6 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL7 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
DDID = GDOA (Arg0) | |
NDL8 = DDID /* \_SB_.PCI0.GFX0.DDID */ | |
CONT = Zero | |
} | |
Name (CONT, Zero) | |
Method (GDOA, 1, NotSerialized) | |
{ | |
While ((CONT < 0x08)) | |
{ | |
Local0 = One | |
Local0 <<= CONT /* \_SB_.PCI0.GFX0.CONT */ | |
Local1 = (NSTE & Local0) | |
CONT++ | |
Local1 = D2OA (Local1) | |
If ((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) | |
{ | |
Local0 = (Arg0 & 0x0F00) | |
If ((Local0 == 0x0100)) | |
{ | |
CRID = Arg0 | |
} | |
If ((Local0 == 0x0200)) | |
{ | |
TVID = Arg0 | |
} | |
If ((Local0 == 0x0400)) | |
{ | |
LFID = Arg0 | |
} | |
} | |
Method (SOID, 0, NotSerialized) | |
{ | |
GOID (CPDL) | |
GOID (CPL2) | |
GOID (CPL3) | |
GOID (CPL4) | |
GOID (CPL5) | |
GOID (CPL6) | |
GOID (CPL7) | |
GOID (CPL8) | |
} | |
Name (DOSF, One) | |
Name (BCMD, Zero) | |
Name (BRNC, Zero) | |
Name (PCTG, Package (0x0B) {}) | |
Name (NXTD, One) | |
Name (LCDM, 0x0808) | |
Name (CRTM, 0x0101) | |
Name (TVOM, 0x0202) | |
Name (HDMM, 0x0404) | |
Name (DVIM, 0x4040) | |
Name (DPOM, 0x8080) | |
Method (PRST, 0, NotSerialized) | |
{ | |
If ((REG0 == 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
Method (NATK, 0, NotSerialized) | |
{ | |
Return (One) | |
} | |
Method (D2AF, 1, NotSerialized) | |
{ | |
Local0 = Zero | |
If ((Arg0 & LCDM)) | |
{ | |
Local0 |= One | |
} | |
If ((Arg0 & CRTM)) | |
{ | |
Local0 |= 0x02 | |
} | |
If ((Arg0 & TVOM)) | |
{ | |
Local0 |= 0x04 | |
} | |
If ((Arg0 & DVIM)) | |
{ | |
Local0 |= 0x08 | |
} | |
If ((Arg0 & HDMM)) | |
{ | |
Local0 |= 0x10 | |
} | |
If ((Arg0 & DPOM)) | |
{ | |
Local0 |= 0x20 | |
} | |
If (!Local0) | |
{ | |
Return (NXTD) /* \_SB_.PCI0.GFX0.NXTD */ | |
} | |
Return (Local0) | |
} | |
Method (GCDD, 0, NotSerialized) | |
{ | |
OGCD () | |
Return (CSTE) /* \_SB_.CSTE */ | |
} | |
Method (GCBL, 1, NotSerialized) | |
{ | |
Local0 = Zero | |
Arg0 &= 0x7FFFFFFF | |
While ((Local0 < 0x0A)) | |
{ | |
Local1 = DerefOf (Index (PCTG, Local0)) | |
Local2 = DerefOf (Index (PCTG, (Local0 + One))) | |
If (((Arg0 <= Local1) && (Arg0 > Local2))) | |
{ | |
Break | |
} | |
Local0++ | |
} | |
Return (Local0) | |
} | |
Method (UPBL, 0, NotSerialized) | |
{ | |
If (BRNC) | |
{ | |
GCDD () | |
Local0 = (D2AF (CSTE) & One) | |
If ((Local0 == Zero)) | |
{ | |
Return (Zero) | |
} | |
Local0 = CBLV /* \_SB_.PCI0.GFX0.CBLV */ | |
BCMD = Zero | |
Notify (DD01, 0x86) // Device-Specific | |
Local2 = 0x012C | |
Local1 = (Local0 & 0x7FFFFFFF) | |
If ((Local1 >= DerefOf (Index (PCTG, One)))) | |
{ | |
Local2 = Zero | |
Local1 = One | |
} | |
If ((MSOS () < OSW8)) | |
{ | |
While ((!BCMD && Local2)) | |
{ | |
Local1 = CBLV /* \_SB_.PCI0.GFX0.CBLV */ | |
If (!(Local1 & 0x80000000)) | |
{ | |
Local1 = Local0 | |
} | |
If ((Local0 == Local1)) | |
{ | |
Sleep (0x0A) | |
Local2-- | |
Local1 = Zero | |
} | |
Else | |
{ | |
Local2 = Zero | |
Local1 = One | |
} | |
} | |
} | |
If ((!BCMD && Local1)) | |
{ | |
If ((MSOS () < OSW8)) | |
{ | |
Local3 = GCBL (CBLV) | |
Local3 -= 0x0A | |
LBTN = Local3 | |
} | |
} | |
} | |
Else | |
{ | |
If ((LBTN < 0x0F)) | |
{ | |
LBTN++ | |
} | |
Else | |
{ | |
LBTN = 0x0F | |
} | |
^^SBRG.EC0.STBR () | |
} | |
Return (Zero) | |
} | |
Method (DWBL, 0, NotSerialized) | |
{ | |
If (BRNC) | |
{ | |
GCDD () | |
Local0 = (D2AF (CSTE) & One) | |
If ((Local0 == Zero)) | |
{ | |
Return (Zero) | |
} | |
Local0 = CBLV /* \_SB_.PCI0.GFX0.CBLV */ | |
BCMD = Zero | |
Notify (DD01, 0x87) // Device-Specific | |
Local2 = 0x012C | |
Local1 = (Local0 & 0x7FFFFFFF) | |
If ((Local1 <= DerefOf (Index (PCTG, 0x0A)))) | |
{ | |
Local2 = Zero | |
Local1 = One | |
} | |
If ((MSOS () < OSW8)) | |
{ | |
While ((!BCMD && Local2)) | |
{ | |
Local1 = CBLV /* \_SB_.PCI0.GFX0.CBLV */ | |
If (!(Local1 & 0x80000000)) | |
{ | |
Local1 = Local0 | |
} | |
If ((Local0 == Local1)) | |
{ | |
Sleep (0x0A) | |
Local2-- | |
Local1 = Zero | |
} | |
Else | |
{ | |
Local2 = Zero | |
Local1 = One | |
} | |
} | |
} | |
If ((!BCMD && Local1)) | |
{ | |
If ((MSOS () < OSW8)) | |
{ | |
Local3 = GCBL (CBLV) | |
Local3 -= 0x0A | |
LBTN = Local3 | |
} | |
} | |
} | |
Else | |
{ | |
If ((LBTN > Zero)) | |
{ | |
LBTN-- | |
} | |
If ((LBTN > 0x0F)) | |
{ | |
LBTN = 0x0F | |
} | |
^^SBRG.EC0.STBR () | |
} | |
Return (Zero) | |
} | |
Device (ISP0) | |
{ | |
Name (_ADR, 0x22B8) // _ADR: Address | |
Name (_DDN, "CHV ISP - 808622B8") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((ISPA != Zero) && (ISPD == One))) | |
{ | |
Return (0x0F) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Name (SBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00400000, // Address Length | |
_Y03) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (SBUF, \_SB.PCI0.GFX0.ISP0._Y03._BAS, B0BA) // _BAS: Base Address | |
B0BA = ISPA /* \ISPA */ | |
Return (SBUF) /* \_SB_.PCI0.GFX0.ISP0.SBUF */ | |
} | |
Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
{ | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
{ | |
If ((Arg0 == One)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If ((Arg0 == 0x02)) | |
{ | |
Return (0x02) | |
} | |
Else | |
{ | |
Return (0x0F) | |
} | |
} | |
} | |
} | |
OperationRegion (VSID, PCI_Config, Zero, 0x04) | |
Field (VSID, ByteAcc, NoLock, Preserve) | |
{ | |
REG0, 32 | |
} | |
} | |
Device (D004) | |
{ | |
Name (_ADR, 0x00030000) // _ADR: Address | |
} | |
Device (D005) | |
{ | |
Name (_ADR, 0x000A0000) // _ADR: Address | |
} | |
Device (D006) | |
{ | |
Name (_ADR, 0x000B0000) // _ADR: Address | |
} | |
Device (D007) | |
{ | |
Name (_ADR, 0x00100000) // _ADR: Address | |
} | |
Device (D008) | |
{ | |
Name (_ADR, 0x00110000) // _ADR: Address | |
} | |
Device (D009) | |
{ | |
Name (_ADR, 0x00120000) // _ADR: Address | |
} | |
Device (XHC1) | |
{ | |
Name (_ADR, 0x00140000) // _ADR: Address | |
} | |
Device (D00B) | |
{ | |
Name (_ADR, 0x00150000) // _ADR: Address | |
} | |
Device (XHC2) | |
{ | |
Name (_ADR, 0x00160000) // _ADR: Address | |
} | |
Device (D00D) | |
{ | |
Name (_ADR, 0x00180000) // _ADR: Address | |
} | |
Device (D00E) | |
{ | |
Name (_ADR, 0x00180002) // _ADR: Address | |
} | |
Device (D00F) | |
{ | |
Name (_ADR, 0x00180003) // _ADR: Address | |
} | |
Device (D010) | |
{ | |
Name (_ADR, 0x00180001) // _ADR: Address | |
} | |
Device (D011) | |
{ | |
Name (_ADR, 0x001A0000) // _ADR: Address | |
} | |
Device (HDEF) | |
{ | |
Name (_ADR, 0x001B0000) // _ADR: Address | |
} | |
Device (D013) | |
{ | |
Name (_ADR, 0x001E0000) // _ADR: Address | |
} | |
Device (D014) | |
{ | |
Name (_ADR, 0x001E0003) // _ADR: Address | |
} | |
Device (D015) | |
{ | |
Name (_ADR, 0x001E0001) // _ADR: Address | |
} | |
Device (D016) | |
{ | |
Name (_ADR, 0x001E0002) // _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, (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) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = Arg0 | |
HCOM = Arg1 | |
HCON = 0x48 | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRXB, 1, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = (Arg0 | One) | |
HCON = 0x44 | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
} | |
Return (0xFFFF) | |
} | |
Method (SWRB, 3, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = Arg0 | |
HCOM = Arg1 | |
DAT0 = Arg2 | |
HCON = 0x48 | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRDB, 2, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = (Arg0 | One) | |
HCOM = Arg1 | |
HCON = 0x48 | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (DAT0) /* \_SB_.PCI0.SBUS.DAT0 */ | |
} | |
Return (0xFFFF) | |
} | |
Method (SWRW, 3, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = Arg0 | |
HCOM = Arg1 | |
DAT1 = (Arg2 & 0xFF) | |
DAT0 = ((Arg2 >> 0x08) & 0xFF) | |
HCON = 0x4C | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SRDW, 2, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (0xFFFF) | |
} | |
I2CE = Zero | |
HSTS = 0xBF | |
TXSA = (Arg0 | One) | |
HCOM = Arg1 | |
HCON = 0x4C | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (((DAT0 << 0x08) | DAT1)) | |
} | |
Return (0xFFFFFFFF) | |
} | |
Method (SBLW, 4, Serialized) | |
{ | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
I2CE = Arg3 | |
HSTS = 0xBF | |
TXSA = Arg0 | |
HCOM = Arg1 | |
DAT0 = SizeOf (Arg2) | |
Local1 = Zero | |
HBDR = DerefOf (Index (Arg2, Zero)) | |
HCON = 0x54 | |
While ((SizeOf (Arg2) > Local1)) | |
{ | |
Local0 = 0x0FA0 | |
While ((!(HSTS & 0x80) && Local0)) | |
{ | |
Local0-- | |
Stall (0x32) | |
} | |
If (!Local0) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
HSTS = 0x80 | |
Local1++ | |
If ((SizeOf (Arg2) > Local1)) | |
{ | |
HBDR = DerefOf (Index (Arg2, Local1)) | |
} | |
} | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (SBLR, 3, Serialized) | |
{ | |
Name (TBUF, Buffer (0x0100) {}) | |
If (STRT ()) | |
{ | |
Return (Zero) | |
} | |
I2CE = Arg2 | |
HSTS = 0xBF | |
TXSA = (Arg0 | One) | |
HCOM = Arg1 | |
HCON = 0x54 | |
Local0 = 0x0FA0 | |
While ((!(HSTS & 0x80) && Local0)) | |
{ | |
Local0-- | |
Stall (0x32) | |
} | |
If (!Local0) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
Index (TBUF, Zero) = DAT0 /* \_SB_.PCI0.SBUS.DAT0 */ | |
HSTS = 0x80 | |
Local1 = One | |
While ((Local1 < DerefOf (Index (TBUF, Zero)))) | |
{ | |
Local0 = 0x0FA0 | |
While ((!(HSTS & 0x80) && Local0)) | |
{ | |
Local0-- | |
Stall (0x32) | |
} | |
If (!Local0) | |
{ | |
KILL () | |
Return (Zero) | |
} | |
Index (TBUF, Local1) = HBDR /* \_SB_.PCI0.SBUS.HBDR */ | |
HSTS = 0x80 | |
Local1++ | |
} | |
If (COMP ()) | |
{ | |
HSTS |= 0xFF | |
Return (TBUF) /* \_SB_.PCI0.SBUS.SBLR.TBUF */ | |
} | |
Return (Zero) | |
} | |
Method (STRT, 0, Serialized) | |
{ | |
Local0 = 0xC8 | |
While (Local0) | |
{ | |
If ((HSTS & 0x40)) | |
{ | |
Local0-- | |
Sleep (One) | |
If ((Local0 == Zero)) | |
{ | |
Return (One) | |
} | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Local0 = 0x0FA0 | |
While (Local0) | |
{ | |
If ((HSTS & One)) | |
{ | |
Local0-- | |
Stall (0x32) | |
If ((Local0 == Zero)) | |
{ | |
KILL () | |
} | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
Method (COMP, 0, Serialized) | |
{ | |
Local0 = 0x0FA0 | |
While (Local0) | |
{ | |
If ((HSTS & 0x02)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Local0-- | |
Stall (0x32) | |
If ((Local0 == Zero)) | |
{ | |
KILL () | |
} | |
} | |
} | |
Return (Zero) | |
} | |
Method (KILL, 0, Serialized) | |
{ | |
HCON |= 0x02 | |
HSTS |= 0xFF | |
} | |
} | |
Device (SBRG) | |
{ | |
Name (_ADR, 0x001F0000) // _ADR: Address | |
Scope (\_SB) | |
{ | |
OperationRegion (ILBR, SystemMemory, IBAS, 0x8C) | |
Field (ILBR, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
PARC, 8, | |
PBRC, 8, | |
PCRC, 8, | |
PDRC, 8, | |
PERC, 8, | |
PFRC, 8, | |
PGRC, 8, | |
PHRC, 8, | |
Offset (0x14), | |
ULKM, 8, | |
Offset (0x88), | |
, 4, | |
UI4E, 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 | |
{ | |
PARC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PARC & 0x0F)) | |
Return (RTLA) /* \_SB_.LNKA._CRS.RTLA */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PARC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PBRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PBRC & 0x0F)) | |
Return (RTLB) /* \_SB_.LNKB._CRS.RTLB */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PBRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PCRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PCRC & 0x0F)) | |
Return (RTLC) /* \_SB_.LNKC._CRS.RTLC */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PCRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PDRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PDRC & 0x0F)) | |
Return (RTLD) /* \_SB_.LNKD._CRS.RTLD */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PDRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PERC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PERC & 0x0F)) | |
Return (RTLE) /* \_SB_.LNKE._CRS.RTLE */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PERC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PFRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PFRC & 0x0F)) | |
Return (RTLF) /* \_SB_.LNKF._CRS.RTLF */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PFRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PGRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PGRC & 0x0F)) | |
Return (RTLG) /* \_SB_.LNKG._CRS.RTLG */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PGRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((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 | |
{ | |
PHRC |= 0x80 | |
} | |
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) | |
IRQ0 = Zero | |
IRQ0 = (One << (PHRC & 0x0F)) | |
Return (RTLH) /* \_SB_.LNKH._CRS.RTLH */ | |
} | |
Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
{ | |
CreateWordField (Arg0, One, IRQ0) | |
FindSetRightBit (IRQ0, Local0) | |
Local0-- | |
PHRC = Local0 | |
} | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If ((PHRC & 0x80)) | |
{ | |
Return (0x09) | |
} | |
Else | |
{ | |
Return (0x0B) | |
} | |
} | |
} | |
} | |
OperationRegion (LPC0, PCI_Config, Zero, 0xC0) | |
Field (LPC0, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SRID, 8, | |
Offset (0x80), | |
C1EN, 1, | |
Offset (0x84) | |
} | |
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 (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, | |
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 | |
0x10, // 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, | |
0x0400, // Range Minimum | |
0x0400, // Range Maximum | |
0x01, // Alignment | |
0x80, // Length | |
) | |
IO (Decode16, | |
0x0500, // Range Minimum | |
0x0500, // Range Maximum | |
0x01, // Alignment | |
0xFF, // Length | |
) | |
}) | |
} | |
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 (RP01) | |
{ | |
Name (_ADR, 0x001C0000) // _ADR: Address | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
L0SE, 1, | |
, 3, | |
LDIS, 1, | |
Offset (0x11), | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1 | |
} | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x9C), | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Device (PXSX) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
} | |
Method (HPME, 0, Serialized) | |
{ | |
If (PMSX) | |
{ | |
Local0 = 0xC8 | |
While (Local0) | |
{ | |
PMSX = One | |
If (PMSX) | |
{ | |
Local0-- | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Notify (PXSX, 0x02) // Device Wake | |
} | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
PDCX = One | |
HPSX = One | |
LDIS = Zero | |
Sleep (0xFA) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR01) /* \_SB_.AR01 */ | |
} | |
Return (PR01) /* \_SB_.PR01 */ | |
} | |
Device (WLAN) | |
{ | |
Name (_ADR, 0xFF) // _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 ((SNUM == 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
If ((BSCC != 0x02)) | |
{ | |
Return (Zero) | |
} | |
Return (One) | |
} | |
} | |
} | |
Device (RP02) | |
{ | |
Name (_ADR, 0x001C0001) // _ADR: Address | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
L0SE, 1, | |
, 3, | |
LDIS, 1, | |
Offset (0x11), | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1 | |
} | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x9C), | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Device (PXSX) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
} | |
Method (HPME, 0, Serialized) | |
{ | |
If (PMSX) | |
{ | |
Local0 = 0xC8 | |
While (Local0) | |
{ | |
PMSX = One | |
If (PMSX) | |
{ | |
Local0-- | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Notify (PXSX, 0x02) // Device Wake | |
} | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
PDCX = One | |
HPSX = One | |
LDIS = Zero | |
Sleep (0xFA) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR02) /* \_SB_.AR02 */ | |
} | |
Return (PR02) /* \_SB_.PR02 */ | |
} | |
} | |
Device (RP03) | |
{ | |
Name (_ADR, 0x001C0002) // _ADR: Address | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
L0SE, 1, | |
, 3, | |
LDIS, 1, | |
Offset (0x11), | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1 | |
} | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x9C), | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Device (PXSX) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
} | |
Method (HPME, 0, Serialized) | |
{ | |
If (PMSX) | |
{ | |
Local0 = 0xC8 | |
While (Local0) | |
{ | |
PMSX = One | |
If (PMSX) | |
{ | |
Local0-- | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Notify (PXSX, 0x02) // Device Wake | |
} | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
PDCX = One | |
HPSX = One | |
LDIS = Zero | |
Sleep (0xFA) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR03) /* \_SB_.AR03 */ | |
} | |
Return (PR03) /* \_SB_.PR03 */ | |
} | |
} | |
Device (RP04) | |
{ | |
Name (_ADR, 0x001C0003) // _ADR: Address | |
OperationRegion (PXCS, PCI_Config, 0x40, 0xC0) | |
Field (PXCS, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
L0SE, 1, | |
, 3, | |
LDIS, 1, | |
Offset (0x11), | |
Offset (0x12), | |
, 13, | |
LASX, 1, | |
Offset (0x1A), | |
ABPX, 1, | |
, 2, | |
PDCX, 1, | |
, 2, | |
PDSX, 1, | |
Offset (0x1B), | |
Offset (0x20), | |
Offset (0x22), | |
PSPX, 1, | |
Offset (0x98), | |
, 30, | |
HPEX, 1, | |
PMEX, 1 | |
} | |
Field (PXCS, AnyAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x9C), | |
, 30, | |
HPSX, 1, | |
PMSX, 1 | |
} | |
Device (PXSX) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
} | |
Method (HPME, 0, Serialized) | |
{ | |
If (PMSX) | |
{ | |
Local0 = 0xC8 | |
While (Local0) | |
{ | |
PMSX = One | |
If (PMSX) | |
{ | |
Local0-- | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Notify (PXSX, 0x02) // Device Wake | |
} | |
} | |
Method (HPHK, 0, NotSerialized) | |
{ | |
PDCX = One | |
HPSX = One | |
LDIS = Zero | |
Sleep (0xFA) | |
} | |
Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
{ | |
If (PICM) | |
{ | |
Return (AR04) /* \_SB_.AR04 */ | |
} | |
Return (PR04) /* \_SB_.PR04 */ | |
} | |
} | |
Device (SATA) | |
{ | |
Name (_ADR, 0x00130000) // _ADR: Address | |
} | |
} | |
} | |
Scope (_GPE) | |
{ | |
} | |
Name (_S0, Package (0x04) // _S0_: S0 System State | |
{ | |
Zero, | |
Zero, | |
Zero, | |
Zero | |
}) | |
Name (_S3, Package (0x04) // _S3_: S3 System State | |
{ | |
0x05, | |
Zero, | |
Zero, | |
Zero | |
}) | |
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) // _PTS: Prepare To Sleep | |
{ | |
If (Arg0) | |
{ | |
PPTS (Arg0) | |
OEMS (Arg0) | |
} | |
} | |
Method (_WAK, 1, NotSerialized) // _WAK: Wake | |
{ | |
PMED () | |
PWAK (Arg0) | |
OEMW (Arg0) | |
Return (WAKP) /* \WAKP */ | |
} | |
Scope (\) | |
{ | |
OperationRegion (PMCR, SystemMemory, PMCB, 0x0100) | |
Field (PMCR, DWordAcc, Lock, Preserve) | |
{ | |
Offset (0x34), | |
L10D, 1, | |
L11D, 1, | |
L12D, 1, | |
L13D, 1, | |
L14D, 1, | |
L15D, 1, | |
L16D, 1, | |
L17D, 1, | |
SD1D, 1, | |
SD2D, 1, | |
SD3D, 1, | |
, 1, | |
, 1, | |
LPED, 1, | |
OTGD, 1, | |
Offset (0x36), | |
, 1, | |
, 1, | |
, 1, | |
, 1, | |
RP1D, 1, | |
RP2D, 1, | |
RP3D, 1, | |
RP4D, 1, | |
L20D, 1, | |
L21D, 1, | |
L22D, 1, | |
L23D, 1, | |
L24D, 1, | |
L25D, 1, | |
L26D, 1, | |
L27D, 1, | |
, 1, | |
, 1, | |
, 1, | |
, 1, | |
ISHD, 1, | |
Offset (0x3C), | |
Offset (0x60), | |
CKC0, 2, | |
CKF0, 1, | |
Offset (0x64), | |
CKC1, 2, | |
CKF1, 1, | |
Offset (0x68), | |
CKC2, 2, | |
CKF2, 1, | |
Offset (0x6C), | |
CKC3, 2, | |
CKF3, 1, | |
Offset (0x70), | |
CKC4, 2, | |
CKF4, 1, | |
Offset (0x74), | |
CKC5, 2, | |
CKF5, 1, | |
Offset (0x78), | |
Offset (0xA0), | |
PMCD, 32, | |
Offset (0xC0), | |
, 14, | |
XPME, 1, | |
Offset (0xEC), | |
PMCC, 32 | |
} | |
OperationRegion (PPSC, SystemMemory, (PMCB + 0xA0), 0x08) | |
Field (PPSC, DWordAcc, Lock, Preserve) | |
{ | |
DM1P, 1, | |
PW1P, 1, | |
PW2P, 1, | |
UR1P, 1, | |
UR2P, 1, | |
SP1P, 1, | |
SP2P, 1, | |
SP3P, 1, | |
EMMP, 1, | |
SDI1, 1, | |
SDI2, 1, | |
, 2, | |
LPEP, 1, | |
, 1, | |
Offset (0x02), | |
, 1, | |
SATP, 1, | |
USBP, 1, | |
SECP, 1, | |
PRP1, 1, | |
PRP2, 1, | |
PRP3, 1, | |
PRP4, 1, | |
DM2P, 1, | |
IC1P, 1, | |
IC2P, 1, | |
IC3P, 1, | |
IC4P, 1, | |
IC5P, 1, | |
IC6P, 1, | |
IC7P, 1, | |
, 2, | |
ISHP, 1, | |
Offset (0x08) | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Scope (SATA) | |
{ | |
OperationRegion (SATR, PCI_Config, 0x74, 0x04) | |
Field (SATR, WordAcc, NoLock, Preserve) | |
{ | |
Offset (0x01), | |
PMEE, 1, | |
, 6, | |
PMES, 1 | |
} | |
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
{ | |
} | |
} | |
Scope (\_SB) | |
{ | |
PowerResource (USBC, 0x00, 0x0000) | |
{ | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (0x0F) | |
} | |
Method (_ON, 0, NotSerialized) // _ON_: Power On | |
{ | |
} | |
Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
{ | |
} | |
} | |
} | |
Scope (XHC1) | |
{ | |
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
{ | |
0x0D, | |
0x04 | |
}) | |
Name (_S3D, 0x02) // _S3D: S3 Device State | |
Name (_S4D, 0x02) // _S4D: S4 Device State | |
Name (XFLT, Zero) | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PMEB = One | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
If ((Arg0 == ToUUID ("ac340cb7-e901-45bf-b7e6-2b34ec931e23"))) | |
{ | |
If ((Arg1 == 0x03)) | |
{ | |
XFLT = Arg1 | |
} | |
} | |
} | |
Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State | |
{ | |
If (_OSI ("Android")) | |
{ | |
Return (0x03) | |
} | |
If ((XFLT == Zero)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (0x03) | |
} | |
} | |
OperationRegion (USBR, PCI_Config, Zero, 0x98) | |
Field (USBR, WordAcc, NoLock, Preserve) | |
{ | |
Offset (0x10), | |
BAR0, 32, | |
Offset (0x74), | |
Offset (0x75), | |
PMEE, 1, | |
, 6, | |
PMES, 1 | |
} | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
Method (_PR3, 0, NotSerialized) // _PR3: Power Resources for D3hot | |
{ | |
Return (Package (0x01) | |
{ | |
USBC | |
}) | |
} | |
} | |
Device (SDHA) | |
{ | |
Name (_HID, "80860F14" /* Intel Baytrail SDIO/MMC Host Controller */) // _HID: Hardware ID | |
Name (_CID, "PNP0D40" /* SDA Standard Compliant SD Host Controller */) // _CID: Compatible ID | |
Name (_DDN, "Intel(R) eMMC Controller - 80862294") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y04) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002D, | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SDHA._Y04._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.SDHA._Y04._LEN, B0LN) // _LEN: Length | |
B0BA = EM0A /* \EM0A */ | |
B0LN = EM0L /* \EM0L */ | |
Return (RBUF) /* \_SB_.PCI0.SDHA.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((EM0A == Zero) || (SD1D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, EM1A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Device (EMMD) | |
{ | |
Name (_ADR, 0x08) // _ADR: Address | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
} | |
} | |
Device (PEMC) | |
{ | |
Name (_ADR, 0x00100000) // _ADR: Address | |
OperationRegion (SDIO, PCI_Config, 0x84, 0x04) | |
Field (SDIO, WordAcc, NoLock, Preserve) | |
{ | |
Offset (0x01), | |
PMEE, 1, | |
, 6, | |
PMES, 1 | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((EM0A == Zero) && (SD1D == Zero))) | |
{ | |
Return (0x0F) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
{ | |
} | |
Device (CARD) | |
{ | |
Name (_ADR, 0x08) // _ADR: Address | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
} | |
} | |
Device (SDHB) | |
{ | |
Name (_ADR, 0x00110000) // _ADR: Address | |
Name (_HID, "INT33BB" /* Intel Baytrail SD Host Controller */) // _HID: Hardware ID | |
Name (_CID, "PNP0D40" /* SDA Standard Compliant SD Host Controller */) // _CID: Compatible ID | |
Name (_DDN, "Intel(R) SDIO Controller - 80862295") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (_HRV, 0x02) // _HRV: Hardware Revision | |
Name (_DEP, Package (0x01) // _DEP: Dependencies | |
{ | |
GPO1 | |
}) | |
Name (PSTS, Zero) | |
Name (ABUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y05) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002E, | |
} | |
GpioIo (Exclusive, PullNone, 0x0000, 0x0000, IoRestrictionOutputOnly, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0005 | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (ABUF, \_SB.PCI0.SDHB._Y05._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (ABUF, \_SB.PCI0.SDHB._Y05._LEN, B0LN) // _LEN: Length | |
B0BA = SI0A /* \SI0A */ | |
B0LN = SI0L /* \SI0L */ | |
Return (ABUF) /* \_SB_.PCI0.SDHB.ABUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((SI0A == Zero) || (SD2D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
If ((PSTS == Zero)) | |
{ | |
If ((^^^GPO1.AVBL == One)) | |
{ | |
^^^GPO1.CWLE = One | |
} | |
PSTS = One | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, SI1A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
Device (BRCM) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Name (_DEP, Package (0x01) // _DEP: Dependencies | |
{ | |
GPO1 | |
}) | |
Name (_HID, "BCM43241") // _HID: Hardware ID | |
Name (_CID, "BCM43241") // _CID: Compatible ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((WIFD == One)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
{ | |
Zero, | |
Zero | |
}) | |
Name (_S4W, 0x02) // _S4W: S4 Device Wake State | |
Name (_S0W, 0x02) // _S0W: S0 Device Wake State | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Interrupt (ResourceConsumer, Edge, ActiveHigh, ExclusiveAndWake, ,, ) | |
{ | |
0x00000035, | |
} | |
GpioInt (Edge, ActiveHigh, ExclusiveAndWake, PullNone, 0x0000, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0015 | |
} | |
GpioIo (Exclusive, PullNone, 0x0000, 0x0000, IoRestrictionOutputOnly, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0005 | |
} | |
}) | |
Return (RBUF) /* \_SB_.PCI0.SDHB.BRCM._CRS.RBUF */ | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((^^^^GPO1.AVBL == One)) | |
{ | |
^^^^GPO1.CWLE = Zero | |
} | |
PSTS = Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((PSTS == Zero)) | |
{ | |
If ((^^^^GPO1.AVBL == One)) | |
{ | |
^^^^GPO1.CWLE = One | |
} | |
PSTS = One | |
} | |
} | |
} | |
Device (BRC1) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Name (_DEP, Package (0x01) // _DEP: Dependencies | |
{ | |
GPO1 | |
}) | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((WIFD == Zero)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
{ | |
Zero, | |
Zero | |
}) | |
Name (_S4W, 0x02) // _S4W: S4 Device Wake State | |
Name (_S0W, 0x02) // _S0W: S0 Device Wake State | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Interrupt (ResourceConsumer, Edge, ActiveHigh, ExclusiveAndWake, ,, ) | |
{ | |
0x00000035, | |
} | |
}) | |
Return (RBUF) /* \_SB_.PCI0.SDHB.BRC1._CRS.RBUF */ | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((^^^^GPO1.AVBL == One)) | |
{ | |
^^^^GPO1.CWLE = Zero | |
} | |
PSTS = Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((PSTS == Zero)) | |
{ | |
If ((^^^^GPO1.AVBL == One)) | |
{ | |
^^^^GPO1.CWLE = One | |
} | |
PSTS = One | |
} | |
} | |
} | |
Device (BRC2) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Name (_STA, 0x0F) // _STA: Status | |
Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
{ | |
Return (Zero) | |
} | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (NAM, Buffer (0x14) | |
{ | |
"\\_SB.PCI0.SDHB.BRC1" | |
}) | |
Name (SPB, Buffer (0x0C) | |
{ | |
/* 0000 */ 0x8E, 0x1D, 0x00, 0x01, 0x00, 0xC0, 0x02, 0x00, /* ........ */ | |
/* 0008 */ 0x00, 0x01, 0x00, 0x00 /* .... */ | |
}) | |
Name (END, ResourceTemplate () | |
{ | |
}) | |
Concatenate (SPB, NAM, Local0) | |
Concatenate (Local0, END, Local1) | |
Return (Local1) | |
} | |
} | |
} | |
Device (SDHC) | |
{ | |
Name (_ADR, 0x00120000) // _ADR: Address | |
Name (_HID, "80860F14" /* Intel Baytrail SDIO/MMC Host Controller */) // _HID: Hardware ID | |
Name (_CID, "PNP0D40" /* SDA Standard Compliant SD Host Controller */) // _CID: Compatible ID | |
Name (_HRV, One) // _HRV: Hardware Revision | |
Name (_DDN, "Intel(R) SD Card Controller - 80862296") // _DDN: DOS Device Name | |
Name (_UID, 0x03) // _UID: Unique ID | |
Name (ABUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y06) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002F, | |
} | |
GpioInt (Edge, ActiveBoth, SharedAndWake, PullNone, 0x2710, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0051 | |
} | |
GpioIo (Shared, PullDefault, 0x0000, 0x0000, IoRestrictionInputOnly, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0051 | |
} | |
GpioIo (Shared, PullDefault, 0x0000, 0x0000, IoRestrictionInputOnly, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0055 | |
} | |
GpioIo (Shared, PullDefault, 0x0000, 0x0000, IoRestrictionInputOnly, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x004E | |
} | |
}) | |
Name (WBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y07) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002F, | |
} | |
GpioInt (Edge, ActiveBoth, SharedAndWake, PullNone, 0x2710, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0051 | |
} | |
GpioIo (Shared, PullDefault, 0x0000, 0x0000, IoRestrictionInputOnly, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0051 | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (ABUF, \_SB.PCI0.SDHC._Y06._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (ABUF, \_SB.PCI0.SDHC._Y06._LEN, B0LN) // _LEN: Length | |
B0BA = SD0A /* \SD0A */ | |
B0LN = SD0L /* \SD0L */ | |
CreateDWordField (WBUF, \_SB.PCI0.SDHC._Y07._BAS, B01A) // _BAS: Base Address | |
CreateDWordField (WBUF, \_SB.PCI0.SDHC._Y07._LEN, B01N) // _LEN: Length | |
B01A = SD0A /* \SD0A */ | |
B01N = SD0L /* \SD0L */ | |
If ((OSID == 0x02)) | |
{ | |
Return (ABUF) /* \_SB_.PCI0.SDHC.ABUF */ | |
} | |
Return (WBUF) /* \_SB_.PCI0.SDHC.WBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((SD0A == Zero) || (SD3D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, SD1A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
{ | |
If ((Arg0 == ToUUID ("f6c13ea5-65cd-461f-ab7a-29f7e8d5bd61"))) | |
{ | |
If ((Arg1 == Zero)) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
Return (Unicode ("\x1F")) | |
} | |
If ((Arg2 == One)) | |
{ | |
Sleep (0x05) | |
Return (One) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Return (0x02) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Sleep (VS18) | |
Return (0x03) | |
} | |
If ((Arg2 == 0x04)) | |
{ | |
Sleep (VD33) | |
Return (0x04) | |
} | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Device (GDM1) | |
{ | |
Name (_HID, "INTL9C60" /* Intel Baytrail SOC DMA Controller */) // _HID: Hardware ID | |
Name (_DDN, "Intel(R) DMA Controller #1 - INTL9C60") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00004000, // Address Length | |
_Y08) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002A, | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.GDM1._Y08._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.GDM1._Y08._LEN, B0LN) // _LEN: Length | |
B0BA = D10A /* \D10A */ | |
B0LN = D10L /* \D10L */ | |
Return (RBUF) /* \_SB_.PCI0.GDM1.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((D10A == Zero) || (L10D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, (D10A | 0x84), 0x04) | |
Field (KEYS, DWordAcc, NoLock, Preserve) | |
{ | |
PSAT, 2 | |
} | |
} | |
Device (GDM3) | |
{ | |
Name (_HID, "INTL9C60" /* Intel Baytrail SOC DMA Controller */) // _HID: Hardware ID | |
Name (_DDN, "Intel(R) DMA Controller #2 - INTL9C60") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00004000, // Address Length | |
_Y09) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000002B, | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.GDM3._Y09._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.GDM3._Y09._LEN, B0LN) // _LEN: Length | |
B0BA = D20A /* \D20A */ | |
B0LN = D20L /* \D20L */ | |
Return (RBUF) /* \_SB_.PCI0.GDM3.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((D20A == Zero) || (L20D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, (D20A | 0x84), 0x04) | |
Field (KEYS, DWordAcc, NoLock, Preserve) | |
{ | |
PSAT, 2 | |
} | |
} | |
Device (PWM1) | |
{ | |
Name (_HID, "80862288") // _HID: Hardware ID | |
Name (_CID, "80862288") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) PWM Controller #1 - 80862288") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0A) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.PWM1._Y0A._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.PWM1._Y0A._LEN, B0LN) // _LEN: Length | |
B0BA = P10A /* \P10A */ | |
B0LN = P10L /* \P10L */ | |
Return (RBUF) /* \_SB_.PCI0.PWM1.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((P10A == Zero) || (L11D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, P11A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (PWM2) | |
{ | |
Name (_HID, "80862288") // _HID: Hardware ID | |
Name (_CID, "80862288") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) PWM Controller #2 - 80862289") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0B) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.PWM2._Y0B._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.PWM2._Y0B._LEN, B0LN) // _LEN: Length | |
B0BA = P20A /* \P20A */ | |
B0LN = P20L /* \P20L */ | |
Return (RBUF) /* \_SB_.PCI0.PWM2.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((P20A == Zero) || (L12D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, P21A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (SPI1) | |
{ | |
Name (_HID, "8086228E") // _HID: Hardware ID | |
Name (_CID, "8086228E") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) SPI Controller #1 - 8086228E") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0C) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000029, | |
} | |
FixedDMA (0x0000, 0x0000, Width32bit, ) | |
FixedDMA (0x0001, 0x0001, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPI1._Y0C._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.SPI1._Y0C._LEN, B0LN) // _LEN: Length | |
B0BA = SP0A /* \SP0A */ | |
B0LN = SP0L /* \SP0L */ | |
Return (RBUF) /* \_SB_.PCI0.SPI1.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((SP0A == Zero) || (L15D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, SP1A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (SPI2) | |
{ | |
Name (_HID, "8086228E") // _HID: Hardware ID | |
Name (_CID, "8086228E") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) SPI Controller #2 - 80862290") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0D) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000059, | |
} | |
FixedDMA (0x0006, 0x0006, Width32bit, ) | |
FixedDMA (0x0007, 0x0007, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPI2._Y0D._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.SPI2._Y0D._LEN, B0LN) // _LEN: Length | |
B0BA = S20A /* \S20A */ | |
B0LN = S20L /* \S20L */ | |
Return (RBUF) /* \_SB_.PCI0.SPI2.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((S20A == Zero) || (L16D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, S21A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (SPI3) | |
{ | |
Name (_HID, "8086228E") // _HID: Hardware ID | |
Name (_CID, "8086228E") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) SPI Controller #3 - 808622AC") // _DDN: DOS Device Name | |
Name (_UID, 0x03) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0E) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000005A, | |
} | |
FixedDMA (0x0008, 0x0008, Width32bit, ) | |
FixedDMA (0x0009, 0x0009, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPI3._Y0E._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.SPI3._Y0E._LEN, B0LN) // _LEN: Length | |
B0BA = S30A /* \S30A */ | |
B0LN = S30L /* \S30L */ | |
Return (RBUF) /* \_SB_.PCI0.SPI3.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((S30A == Zero) || (L16D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, S31A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (NFC2) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "NXP1002") // _HID: Hardware ID | |
Name (_CID, "NXP1002") // _CID: Compatible ID | |
Name (_DDN, "NXP NFC") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((NFCS == 0x02)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Method (CDSM, 5, Serialized) | |
{ | |
If ((Arg0 == ToUUID ("3cdff6f7-4267-4555-ad05-b30a3d8938de") /* HID I2C Device */)) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
If ((Arg1 == One)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
} | |
Else | |
{ | |
If ((Arg2 == One)) | |
{ | |
Return (Arg4) | |
} | |
} | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
Device (I2C1) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #1 - 808622C1") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y0F) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000020, | |
} | |
FixedDMA (0x0010, 0x0000, Width32bit, ) | |
FixedDMA (0x0011, 0x0001, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C1._Y0F._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C1._Y0F._LEN, B0LN) // _LEN: Length | |
B0BA = I10A /* \I10A */ | |
B0LN = I10L /* \I10L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C1.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I10A == Zero) || (L21D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I0D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I0D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I11A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (I2C2) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #2 - 808622C2") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y10) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000021, | |
} | |
FixedDMA (0x0012, 0x0002, Width32bit, ) | |
FixedDMA (0x0013, 0x0003, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C2._Y10._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C2._Y10._LEN, B0LN) // _LEN: Length | |
B0BA = I20A /* \I20A */ | |
B0LN = I20L /* \I20L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C2.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I20A == Zero) || (L22D == One))) | |
{ | |
Return (Zero) | |
} | |
If ((BDID == CRRB)) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I1D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I1D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I21A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (I2C3) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #3 - 808622C3") // _DDN: DOS Device Name | |
Name (_UID, 0x03) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y11) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000022, | |
} | |
FixedDMA (0x0014, 0x0004, Width32bit, ) | |
FixedDMA (0x0015, 0x0005, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C3._Y11._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C3._Y11._LEN, B0LN) // _LEN: Length | |
B0BA = I30A /* \I30A */ | |
B0LN = I30L /* \I30L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C3.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I30A == Zero) || (L23D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I2D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I2D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I31A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
PowerResource (CLK0, 0x00, 0x0000) | |
{ | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (CKC0) /* \CKC0 */ | |
} | |
Method (_ON, 0, NotSerialized) // _ON_: Power On | |
{ | |
CKC0 = One | |
Sleep (0x05) | |
} | |
Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
{ | |
CKC0 = 0x02 | |
} | |
} | |
} | |
Device (I2C4) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #4 - 808622C4") // _DDN: DOS Device Name | |
Name (_UID, 0x04) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y12) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000023, | |
} | |
FixedDMA (0x0016, 0x0006, Width32bit, ) | |
FixedDMA (0x0017, 0x0007, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C4._Y12._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C4._Y12._LEN, B0LN) // _LEN: Length | |
B0BA = I40A /* \I40A */ | |
B0LN = I40L /* \I40L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C4.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I40A == Zero) || (L24D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I3D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I3D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I41A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
PowerResource (CLK0, 0x00, 0x0000) | |
{ | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (CKC0) /* \CKC0 */ | |
} | |
Method (_ON, 0, NotSerialized) // _ON_: Power On | |
{ | |
CKC0 = One | |
Sleep (0x05) | |
} | |
Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
{ | |
CKC0 = 0x02 | |
} | |
} | |
PowerResource (CLK1, 0x00, 0x0000) | |
{ | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (CKC1) /* \CKC1 */ | |
} | |
Method (_ON, 0, NotSerialized) // _ON_: Power On | |
{ | |
CKC1 = One | |
Sleep (0x05) | |
} | |
Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
{ | |
CKC1 = 0x02 | |
} | |
} | |
} | |
Device (I2C5) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #5 - 808622C5") // _DDN: DOS Device Name | |
Name (_UID, 0x05) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y13) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000024, | |
} | |
FixedDMA (0x0018, 0x0000, Width32bit, ) | |
FixedDMA (0x0019, 0x0001, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C5._Y13._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C5._Y13._LEN, B0LN) // _LEN: Length | |
B0BA = I50A /* \I50A */ | |
B0LN = I50L /* \I50L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C5.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I50A == Zero) || (L25D == One))) | |
{ | |
Return (Zero) | |
} | |
If ((BDID == CRRB)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I4D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I4D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I51A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Method (TPS3, 0, Serialized) | |
{ | |
If ((^^GPO0.AVBL == One)) | |
{ | |
If ((BDID == CRRB)) | |
{ | |
^^GPO0.TSRR = Zero | |
} | |
Else | |
{ | |
If ((FBID == 0x02)) | |
{ | |
^^GPO0.TSR2 = Zero | |
} | |
Else | |
{ | |
^^GPO0.TSRS = Zero | |
} | |
} | |
} | |
} | |
Method (TPS0, 0, Serialized) | |
{ | |
If ((^^GPO0.AVBL == One)) | |
{ | |
If ((BDID == CRRB)) | |
{ | |
^^GPO0.TSRR = One | |
} | |
Else | |
{ | |
If ((FBID == 0x02)) | |
{ | |
^^GPO0.TSR2 = One | |
} | |
Else | |
{ | |
^^GPO0.TSRS = One | |
} | |
} | |
} | |
Sleep (0x64) | |
} | |
Method (TCRS, 1, Serialized) | |
{ | |
Name (RSTL, ResourceTemplate () | |
{ | |
I2cSerialBus (0x004A, ControllerInitiated, 0x00061A80, | |
AddressingMode7Bit, "\\_SB.PCI0.I2C6", | |
0x00, ResourceConsumer, _Y14, | |
) | |
GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly, | |
"\\_SB.GPO0", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x004B | |
} | |
GpioInt (Level, ActiveLow, Shared, PullDefault, 0x0000, | |
"\\_SB.GPO0", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x004C | |
} | |
}) | |
CreateByteField (RSTL, \_SB.PCI0.TCRS._Y14._ADR, VAL0) // _ADR: Address | |
VAL0 = Arg0 | |
CreateByteField (RSTL, 0x38, VAL1) | |
If ((BDID == CRRB)) | |
{ | |
VAL1 = 0x4B | |
} | |
Else | |
{ | |
If ((FBID == 0x02)) | |
{ | |
VAL1 = 0x4E | |
} | |
Else | |
{ | |
VAL1 = 0x50 | |
} | |
} | |
Return (RSTL) /* \_SB_.PCI0.TCRS.RSTL */ | |
} | |
Device (I2C6) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #6 - 808622C6") // _DDN: DOS Device Name | |
Name (_UID, 0x06) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y15) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000025, | |
} | |
FixedDMA (0x001A, 0x0002, Width32bit, ) | |
FixedDMA (0x001B, 0x0003, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C6._Y15._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C6._Y15._LEN, B0LN) // _LEN: Length | |
B0BA = I60A /* \I60A */ | |
B0LN = I60L /* \I60L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C6.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I60A == Zero) || (L26D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I5D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I5D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I61A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (I2C7) | |
{ | |
Name (_HID, "808622C1") // _HID: Hardware ID | |
Name (_CID, "808622C1") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) I2C Controller #7 - 808622C7") // _DDN: DOS Device Name | |
Name (_UID, 0x07) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y16) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000026, | |
} | |
FixedDMA (0x001C, 0x0004, Width32bit, ) | |
FixedDMA (0x001D, 0x0005, Width32bit, ) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.I2C7._Y16._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.I2C7._Y16._LEN, B0LN) // _LEN: Length | |
B0BA = I70A /* \I70A */ | |
B0LN = I70L /* \I70L */ | |
Return (RBUF) /* \_SB_.PCI0.I2C7.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((I70A == Zero) || (L27D == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
If ((I6D3 == One)) | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
If ((I6D3 == One)) | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
} | |
OperationRegion (KEYS, SystemMemory, I71A, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Scope (HDEF) | |
{ | |
OperationRegion (HDAR, PCI_Config, 0x4C, 0x10) | |
Field (HDAR, WordAcc, NoLock, Preserve) | |
{ | |
DCKA, 1, | |
Offset (0x01), | |
DCKM, 1, | |
, 6, | |
DCKS, 1, | |
Offset (0x08), | |
Offset (0x09), | |
PMEE, 1, | |
, 6, | |
PMES, 1 | |
} | |
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
{ | |
0x0D, | |
0x04 | |
}) | |
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
{ | |
} | |
} | |
Device (IISH) | |
{ | |
Name (_HID, "808622D8") // _HID: Hardware ID | |
Name (_CID, "808622D8") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) Integrated Sensor Hub - 808622D8") // _DDN: DOS Device Name | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y17) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y18) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000072, | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.IISH._Y17._BAS, B0BA) // _BAS: Base Address | |
B0BA = ISH0 /* \ISH0 */ | |
CreateDWordField (RBUF, \_SB.PCI0.IISH._Y18._BAS, B1BA) // _BAS: Base Address | |
B1BA = ISH1 /* \ISH1 */ | |
Return (RBUF) /* \_SB_.PCI0.IISH.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((ISH0 == Zero) || (ISHD == One))) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, ISH1, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
} | |
Device (LPEA) | |
{ | |
Name (_HID, "808622A8") // _HID: Hardware ID | |
Name (_CID, "808622A8") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) Low Power Audio Controller - 808622A8") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00200000, // Address Length | |
_Y19) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y1A) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00200000, // Address Length | |
_Y1B) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000018, | |
} | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000019, | |
} | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000001A, | |
} | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000001B, | |
} | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000001C, | |
} | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x0000001D, | |
} | |
GpioInt (Edge, ActiveBoth, ExclusiveAndWake, PullNone, 0x0000, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x004D | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.LPEA._Y19._BAS, B0BA) // _BAS: Base Address | |
B0BA = LPE0 /* \LPE0 */ | |
CreateDWordField (RBUF, \_SB.PCI0.LPEA._Y1A._BAS, B1BA) // _BAS: Base Address | |
B1BA = LPE1 /* \LPE1 */ | |
CreateDWordField (RBUF, \_SB.PCI0.LPEA._Y1B._BAS, B2BA) // _BAS: Base Address | |
B2BA = LPE2 /* \LPE2 */ | |
Return (RBUF) /* \_SB_.PCI0.LPEA.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((LPE0 != Zero) && (LPED == Zero))) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
{ | |
} | |
Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
{ | |
PSAT |= 0x03 | |
PSAT |= Zero | |
} | |
Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
{ | |
PSAT &= 0xFFFFFFFC | |
PSAT |= Zero | |
} | |
OperationRegion (KEYS, SystemMemory, LPE1, 0x0100) | |
Field (KEYS, DWordAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x84), | |
PSAT, 32 | |
} | |
Device (ADMA) | |
{ | |
Name (_HID, "ADMA22A8") // _HID: Hardware ID | |
Name (_CID, "ADMA22A8") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) Audio DMA0 - DMA0F28") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00200000, // Address Length | |
_Y1C) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, ,, ) | |
{ | |
0x00000018, | |
} | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.LPEA.ADMA._Y1C._BAS, B3BA) // _BAS: Base Address | |
B3BA = LPE0 /* \LPE0 */ | |
Return (RBUF) /* \_SB_.PCI0.LPEA.ADMA.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((OSID == 0x02) || (OSID == 0x03))) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Device (AMCR) | |
{ | |
Name (_HID, "AMCR22A8") // _HID: Hardware ID | |
Name (_CID, "AMCR22A8") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) Audio Machine Driver - AMCR0F28") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
GpioInt (Edge, ActiveHigh, ExclusiveAndWake, PullNone, 0x0000, | |
"\\_SB.GPO3", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x004D | |
} | |
GpioInt (Edge, ActiveHigh, ExclusiveAndWake, PullNone, 0x0000, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0006 | |
} | |
GpioInt (Edge, ActiveHigh, ExclusiveAndWake, PullNone, 0x0000, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0006 | |
} | |
}) | |
Return (RBUF) /* \_SB_.PCI0.AMCR._CRS.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((LPES == 0x02)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Device (HAD0) | |
{ | |
Name (_HID, "HAD022A8") // _HID: Hardware ID | |
Name (_CID, "HAD022A8") // _CID: Compatible ID | |
Name (_DDN, "Intel(R) HDMI Audio Driver - HAD") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00065800, // Address Base | |
0x00000140, // Address Length | |
) | |
}) | |
Return (RBUF) /* \_SB_.PCI0.HAD0._CRS.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((ADED == One)) | |
{ | |
If (((OSID == 0x02) || (OSID == 0x03))) | |
{ | |
Return (0x0F) | |
} | |
} | |
Return (Zero) | |
} | |
} | |
Device (SPRC) | |
{ | |
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
Name (_UID, 0x03) // _UID: Unique ID | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y1D) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y1E) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y1F) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y20) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y21) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y22) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y23) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y24) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y25) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y26) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y27) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y28) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y29) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2A) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2B) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2C) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2D) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2E) | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y2F) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1D._BAS, BR01) // _BAS: Base Address | |
BR01 = EM1A /* \EM1A */ | |
If (((BR01 != Zero) && (BR01 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1D._LEN, LN01) // _LEN: Length | |
LN01 = EM1L /* \EM1L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1E._BAS, BR02) // _BAS: Base Address | |
BR02 = SI1A /* \SI1A */ | |
If (((BR02 != Zero) && (BR02 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1E._LEN, LN02) // _LEN: Length | |
LN02 = SI1L /* \SI1L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1F._BAS, BR03) // _BAS: Base Address | |
BR03 = SD1A /* \SD1A */ | |
If (((BR03 != Zero) && (BR03 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y1F._LEN, LN03) // _LEN: Length | |
LN03 = SD1L /* \SD1L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y20._BAS, BR04) // _BAS: Base Address | |
BR04 = D11A /* \D11A */ | |
If (((BR04 != Zero) && (BR04 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y20._LEN, LN04) // _LEN: Length | |
LN04 = D11L /* \D11L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y21._BAS, BR05) // _BAS: Base Address | |
BR05 = P11A /* \P11A */ | |
If (((BR05 != Zero) && (BR05 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y21._LEN, LN05) // _LEN: Length | |
LN05 = P11L /* \P11L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y22._BAS, BR06) // _BAS: Base Address | |
BR06 = P21A /* \P21A */ | |
If (((BR06 != Zero) && (BR06 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y22._LEN, LN06) // _LEN: Length | |
LN06 = P21L /* \P21L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y23._BAS, BR07) // _BAS: Base Address | |
BR07 = U11A /* \U11A */ | |
If (((BR07 != Zero) && (BR07 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y23._LEN, LN07) // _LEN: Length | |
LN07 = U11L /* \U11L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y24._BAS, BR08) // _BAS: Base Address | |
BR08 = U21A /* \U21A */ | |
If (((BR08 != Zero) && (BR08 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y24._LEN, LN08) // _LEN: Length | |
LN08 = U21L /* \U21L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y25._BAS, BR09) // _BAS: Base Address | |
BR09 = SP1A /* \SP1A */ | |
If (((BR09 != Zero) && (BR09 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y25._LEN, LN09) // _LEN: Length | |
LN09 = SP1L /* \SP1L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y26._BAS, BR10) // _BAS: Base Address | |
BR10 = S21A /* \S21A */ | |
If (((BR10 != Zero) && (BR10 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y26._LEN, LN10) // _LEN: Length | |
LN10 = S21L /* \S21L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y27._BAS, BR11) // _BAS: Base Address | |
BR11 = S31A /* \S31A */ | |
If (((BR11 != Zero) && (BR11 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y27._LEN, LN11) // _LEN: Length | |
LN11 = S31L /* \S31L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y28._BAS, BR12) // _BAS: Base Address | |
BR12 = D21A /* \D21A */ | |
If (((BR12 != Zero) && (BR12 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y28._LEN, LN12) // _LEN: Length | |
LN12 = D21L /* \D21L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y29._BAS, BR13) // _BAS: Base Address | |
BR13 = I11A /* \I11A */ | |
If (((BR13 != Zero) && (BR13 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y29._LEN, LN13) // _LEN: Length | |
LN13 = I11L /* \I11L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2A._BAS, BR14) // _BAS: Base Address | |
BR14 = I21A /* \I21A */ | |
If (((BR14 != Zero) && (BR14 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2A._LEN, LN14) // _LEN: Length | |
LN14 = I21L /* \I21L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2B._BAS, BR15) // _BAS: Base Address | |
BR15 = I31A /* \I31A */ | |
If (((BR15 != Zero) && (BR15 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2B._LEN, LN15) // _LEN: Length | |
LN15 = I31L /* \I31L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2C._BAS, BR16) // _BAS: Base Address | |
BR16 = I41A /* \I41A */ | |
If (((BR16 != Zero) && (BR16 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2C._LEN, LN16) // _LEN: Length | |
LN16 = I41L /* \I41L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2D._BAS, BR17) // _BAS: Base Address | |
BR17 = I51A /* \I51A */ | |
If (((BR17 != Zero) && (BR17 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2D._LEN, LN17) // _LEN: Length | |
LN17 = I51L /* \I51L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2E._BAS, BR18) // _BAS: Base Address | |
BR18 = I61A /* \I61A */ | |
If (((BR18 != Zero) && (BR18 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2E._LEN, LN18) // _LEN: Length | |
LN18 = I61L /* \I61L */ | |
} | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2F._BAS, BR19) // _BAS: Base Address | |
BR19 = I71A /* \I71A */ | |
If (((BR19 != Zero) && (BR19 != 0xFFFFF000))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SPRC._Y2F._LEN, LN19) // _LEN: Length | |
LN19 = I71L /* \I71L */ | |
} | |
Return (RBUF) /* \_SB_.PCI0.SPRC.RBUF */ | |
} | |
} | |
Device (SEC0) | |
{ | |
Name (_ADR, 0x001A0000) // _ADR: Address | |
Name (_S0W, 0x03) // _S0W: S0 Device Wake State | |
OperationRegion (SECS, PCI_Config, 0x64, 0x04) | |
Field (SECS, DWordAcc, NoLock, Preserve) | |
{ | |
SHAD, 32 | |
} | |
OperationRegion (PMEB, PCI_Config, 0x84, 0x04) | |
Field (PMEB, WordAcc, NoLock, Preserve) | |
{ | |
Offset (0x01), | |
PMEE, 1, | |
, 6, | |
PMES, 1 | |
} | |
Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
{ | |
} | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0x00000000, // Address Base | |
0x00000000, // Address Length | |
_Y30) | |
}) | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
If (((OSYS == 0x07DF) && (PAVL != Zero))) | |
{ | |
CreateDWordField (RBUF, \_SB.PCI0.SEC0._Y30._BAS, B0BA) // _BAS: Base Address | |
CreateDWordField (RBUF, \_SB.PCI0.SEC0._Y30._LEN, B0LN) // _LEN: Length | |
B0BA = PAVB /* \PAVB */ | |
B0LN = PAVL /* \PAVL */ | |
Return (RBUF) /* \_SB_.PCI0.SEC0.RBUF */ | |
} | |
Return (ResourceTemplate () | |
{ | |
}) | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If ((Arg0 == ToUUID ("1730e71d-e5dd-4a34-be57-4d76b6a2fe37"))) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
If ((Arg1 == Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
If ((Arg2 == One)) | |
{ | |
While (One) | |
{ | |
_T_0 = DerefOf (Index (Arg3, Zero)) | |
If ((_T_0 == Zero)) {} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
If (CondRefOf (\_SB.SLPB)) | |
{ | |
Notify (SLPB, 0x80) // Status Change | |
P8XH (Zero, 0x5D) | |
} | |
} | |
Else | |
{ | |
If ((_T_0 == 0x02)) {} | |
Else | |
{ | |
If ((_T_0 == 0x03)) {} | |
} | |
} | |
} | |
Break | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Else | |
{ | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
} | |
} | |
Scope (_PR) | |
{ | |
Processor (CPU0, 0x01, 0x00000000, 0x00) {} | |
Processor (CPU1, 0x02, 0x00000000, 0x00) {} | |
Processor (CPU2, 0x03, 0x00000000, 0x00) {} | |
Processor (CPU3, 0x04, 0x00000000, 0x00) {} | |
} | |
Name (PICM, Zero) | |
Mutex (MUTX, 0x00) | |
OperationRegion (PRT0, SystemIO, 0x80, 0x04) | |
Field (PRT0, DWordAcc, Lock, Preserve) | |
{ | |
P80H, 32 | |
} | |
Method (P8XH, 2, Serialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
P80D = ((P80D & 0xFFFFFF00) | Arg1) | |
} | |
Else | |
{ | |
If ((Arg0 == One)) | |
{ | |
P80D = ((P80D & 0xFFFF00FF) | (Arg1 << 0x08)) | |
} | |
Else | |
{ | |
If ((Arg0 == 0x02)) | |
{ | |
P80D = ((P80D & 0xFF00FFFF) | (Arg1 << 0x10)) | |
} | |
Else | |
{ | |
If ((Arg0 == 0x03)) | |
{ | |
P80D = ((P80D & 0x00FFFFFF) | (Arg1 << 0x18)) | |
} | |
} | |
} | |
} | |
P80H = P80D /* \P80D */ | |
} | |
OperationRegion (SPRT, SystemIO, 0xB2, 0x02) | |
Field (SPRT, ByteAcc, Lock, Preserve) | |
{ | |
SSMP, 8 | |
} | |
Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model | |
{ | |
GPIC = Arg0 | |
PICM = Arg0 | |
} | |
OperationRegion (SWC0, SystemIO, 0x0610, 0x0F) | |
Field (SWC0, ByteAcc, NoLock, Preserve) | |
{ | |
G1S, 8, | |
Offset (0x04), | |
G1E, 8, | |
Offset (0x0A), | |
G1S2, 8, | |
G1S3, 8 | |
} | |
OperationRegion (SWC1, SystemIO, PMBS, 0x34) | |
Field (SWC1, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x02), | |
PM1E, 16, | |
Offset (0x20), | |
G0S, 32, | |
Offset (0x28), | |
G0EN, 32, | |
Offset (0x30), | |
SSMI, 32 | |
} | |
OperationRegion (SCWS, SystemMemory, (GBA1 | 0x0200), 0x04) | |
Field (SCWS, DWordAcc, Lock, Preserve) | |
{ | |
, 9, | |
SOCW, 1 | |
} | |
OperationRegion (TPIS, SystemMemory, (GBA3 | 0x0204), 0x04) | |
Field (TPIS, DWordAcc, Lock, Preserve) | |
{ | |
, 14, | |
PADW, 1 | |
} | |
Method (PPTS, 1, NotSerialized) | |
{ | |
SSEN = SSMI /* \SSMI */ | |
SPM1 = PM1E /* \PM1E */ | |
P80D = Zero | |
P8XH (Zero, Arg0) | |
XMIO = (XMMA & 0xFFFFFFF0) | |
If (_OSI ("Android")) | |
{ | |
If ((\_SB.PWRB.UPPS == One)) {} | |
} | |
G1S3 = Ones | |
G1S2 = Ones | |
G1S = One | |
G1E = One | |
G0S = Ones | |
SOCW = One | |
PADW = One | |
If (CondRefOf (TCGM)) | |
{ | |
\_SB.PCI0.SBRG.TPM.PTS (Arg0) | |
} | |
If ((Arg0 == 0x03)) | |
{ | |
If (CondRefOf (DTSE)) | |
{ | |
If ((DTSE >= One)) | |
{ | |
DTSF = 0x1E | |
} | |
} | |
} | |
} | |
Name (XMIO, Zero) | |
OperationRegion (XPEB, SystemMemory, (PEBS + 0x000A0000), 0x78) | |
Field (XPEB, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
, 1, | |
XMSE, 1, | |
Offset (0x10), | |
XMMA, 32, | |
Offset (0x74), | |
XHDX, 2 | |
} | |
Method (XWAM, 1, Serialized) | |
{ | |
If ((XPME == One)) | |
{ | |
If (((XMIO != Zero) && (XMIO != 0xFFFFFFF0))) | |
{ | |
Local0 = XHDX /* \XHDX */ | |
Local1 = XMMA /* \XMMA */ | |
Local2 = XMSE /* \XMSE */ | |
XMMA = XMIO /* \XMIO */ | |
XHDX = Zero | |
XMSE = One | |
OperationRegion (XWAM, SystemMemory, (XMIO + 0x80A4), 0x04) | |
Field (XWAM, DWordAcc, NoLock, Preserve) | |
{ | |
, 28, | |
PMEC, 1 | |
} | |
PMEC = One | |
PMEB = One | |
XMSE = Local2 | |
XMMA = Local1 | |
XHDX = Local0 | |
P8XH (One, Arg0) | |
} | |
} | |
} | |
Name (LLID, Zero) | |
Method (PWAK, 1, Serialized) | |
{ | |
SSMI = SSEN /* \SSEN */ | |
PM1E = SPM1 /* \SPM1 */ | |
P8XH (One, 0xAB) | |
If ((Arg0 == 0x03)) | |
{ | |
XWAM (0xAE) | |
} | |
If (NEXP) | |
{ | |
If ((OSCC & 0x02)) | |
{ | |
\_SB.PCI0.NHPG () | |
} | |
If ((OSCC & 0x04)) | |
{ | |
\_SB.PCI0.NPME () | |
} | |
} | |
If ((Arg0 == 0x03)) | |
{ | |
\_SB.PCI0.SEC0.SHAD = One | |
} | |
If (((BDID == CHRB) | (BDID == CIRB))) | |
{ | |
PNOT () | |
} | |
Else | |
{ | |
If ((PFLV == FMBL)) | |
{ | |
ECON = One | |
Notify (\_SB.LID, 0x80) // Status Change | |
If (((Arg0 == 0x03) || (Arg0 == 0x04))) | |
{ | |
If ((PFLV == FMBL)) | |
{ | |
If ((Arg0 == 0x04)) | |
{ | |
PNOT () | |
} | |
} | |
If (CondRefOf (DTSE)) | |
{ | |
If ((DTSE >= One)) | |
{ | |
DTSF = 0x14 | |
Notify (\_TZ.THRM, 0x80) // Thermal Status Change | |
} | |
} | |
If ((CFGD & 0x01000000)) {} | |
If ((OSYS == 0x07D2)) | |
{ | |
If ((CFGD & One)) | |
{ | |
If ((\_PR.CPU0._PPC > Zero)) | |
{ | |
\_PR.CPU0._PPC -= One | |
PNOT () | |
\_PR.CPU0._PPC += One | |
PNOT () | |
} | |
Else | |
{ | |
\_PR.CPU0._PPC += One | |
PNOT () | |
\_PR.CPU0._PPC -= One | |
PNOT () | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Method (PNOT, 0, Serialized) | |
{ | |
If (MPEN) | |
{ | |
If ((PDC0 & 0x08)) | |
{ | |
Notify (\_PR.CPU0, 0x80) // Performance Capability Change | |
If ((PDC0 & 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU0, 0x81) // C-State Change | |
} | |
} | |
If ((PDC1 & 0x08)) | |
{ | |
Notify (\_PR.CPU1, 0x80) // Performance Capability Change | |
If ((PDC1 & 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU1, 0x81) // C-State Change | |
} | |
} | |
If ((PDC2 & 0x08)) | |
{ | |
Notify (\_PR.CPU2, 0x80) // Performance Capability Change | |
If ((PDC2 & 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU2, 0x81) // C-State Change | |
} | |
} | |
If ((PDC3 & 0x08)) | |
{ | |
Notify (\_PR.CPU3, 0x80) // Performance Capability Change | |
If ((PDC3 & 0x10)) | |
{ | |
Sleep (0x64) | |
Notify (\_PR.CPU3, 0x81) // C-State Change | |
} | |
} | |
} | |
Else | |
{ | |
Notify (\_PR.CPU0, 0x80) // Performance Capability Change | |
Sleep (0x64) | |
Notify (\_PR.CPU0, 0x81) // C-State Change | |
} | |
} | |
Scope (_SB) | |
{ | |
Name (OSCI, Zero) | |
Name (OSCO, Zero) | |
Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities | |
{ | |
CreateDWordField (Arg3, Zero, STS0) | |
CreateDWordField (Arg3, 0x04, CAP0) | |
If ((Arg0 == ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48") /* Platform-wide Capabilities */)) | |
{ | |
If ((Arg1 == One)) | |
{ | |
If ((CAP0 & 0x04)) | |
{ | |
OSCO = 0x04 | |
If (((HGMD & 0x0F) != 0x02)) | |
{ | |
CAP0 &= 0x3B | |
STS0 |= 0x10 | |
} | |
} | |
} | |
Else | |
{ | |
STS0 &= 0xFFFFFF00 | |
STS0 |= 0x0A | |
} | |
} | |
Else | |
{ | |
STS0 &= 0xFFFFFF00 | |
STS0 |= 0x06 | |
} | |
Return (Arg3) | |
} | |
Device (PWRB) | |
{ | |
Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID | |
Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
{ | |
0x1D, | |
0x04 | |
}) | |
Name (PBST, One) | |
Name (UPPS, Zero) | |
Name (PBLV, Zero) | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (((ECON == One) && PBST)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Method (PBUP, 0, NotSerialized) | |
{ | |
If (UPPS) | |
{ | |
Notify (PWRB, 0xC0) // Hardware-Specific | |
} | |
} | |
Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If ((Arg0 == ToUUID ("9c355bcb-35fa-44f7-8a67-447359c36a03"))) | |
{ | |
If ((Zero == ToInteger (Arg1))) | |
{ | |
While (One) | |
{ | |
_T_0 = ToInteger (Arg2) | |
If ((_T_0 == Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x07 /* . */ | |
}) | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
UPPS = One | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((_T_0 == 0x02)) | |
{ | |
If (UPPS) | |
{ | |
If (!PBLV) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (One) | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Scope (PCI0) | |
{ | |
Method (_INI, 0, NotSerialized) // _INI: Initialize | |
{ | |
OSYS = 0x07D0 | |
If (CondRefOf (\_OSI, Local0)) | |
{ | |
If (_OSI ("Windows 2001")) | |
{ | |
OSYS = 0x07D1 | |
} | |
If (_OSI ("Windows 2001 SP1")) | |
{ | |
OSYS = 0x07D1 | |
} | |
If (_OSI ("Windows 2001 SP2")) | |
{ | |
OSYS = 0x07D2 | |
} | |
If (_OSI ("Windows 2006")) | |
{ | |
OSYS = 0x07D6 | |
} | |
If (_OSI ("Windows 2009")) | |
{ | |
OSYS = 0x07D9 | |
} | |
If (_OSI ("Windows 2012")) | |
{ | |
OSYS = 0x07DC | |
} | |
If (_OSI ("Windows 2013")) | |
{ | |
OSYS = 0x07DD | |
} | |
If (_OSI ("Windows 2015")) | |
{ | |
OSYS = 0x07DF | |
} | |
} | |
} | |
Method (NHPG, 0, Serialized) | |
{ | |
} | |
Method (NPME, 0, Serialized) | |
{ | |
} | |
} | |
Device (GPED) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "INT0002" /* Virtual GPIO Controller */) // _HID: Hardware ID | |
Name (_CID, "INT0002" /* Virtual GPIO Controller */) // _CID: Compatible ID | |
Name (_DDN, "Virtual GPIO controller") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Name (INST, One) | |
Name (XTMP, Zero) | |
OperationRegion (SCIS, SystemMemory, 0xFED030C0, 0x04) | |
Field (SCIS, DWordAcc, NoLock, Preserve) | |
{ | |
, 1, | |
LHAD, 1, | |
LATA, 1, | |
LDIO, 1, | |
LARD, 1, | |
LIO1, 1, | |
LCEP, 1, | |
LANB, 1, | |
LHCI, 1, | |
LOTG, 1, | |
LECI, 1, | |
LHSI, 1 | |
} | |
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
{ | |
If ((Arg0 == ToUUID ("8b38b469-6f95-4b08-9b02-2defcc2d2c35"))) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
If ((Arg1 == One)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
} | |
If ((Arg2 == One)) | |
{ | |
Return ((PMBS + 0x20)) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Interrupt (ResourceConsumer, Level, ActiveHigh, Exclusive, ,, ) | |
{ | |
0x00000009, | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPED._CRS.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((OSYS >= 0x07DD)) | |
{ | |
If ((PB1E & One)) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (Zero) | |
} | |
Method (_AEI, 0, Serialized) // _AEI: ACPI Event Interrupts | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
GpioInt (Edge, ActiveHigh, ExclusiveAndWake, PullDown, 0x0000, | |
"\\_SB.GPED", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0002 | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPED._AEI.RBUF */ | |
} | |
Method (_E02, 0, NotSerialized) // _Exx: Edge-Triggered GPE | |
{ | |
If ((PWBS == One)) | |
{ | |
PWBS = One | |
Notify (PWRB, 0x80) // Status Change | |
} | |
If ((PMEB == One)) | |
{ | |
PMEB = One | |
} | |
If ((^^PCI0.SATA.PMES == One)) | |
{ | |
^^PCI0.SATA.PMES = One | |
Notify (^^PCI0.SATA, 0x02) // Device Wake | |
} | |
If ((^^PCI0.HDEF.PMES == One)) | |
{ | |
^^PCI0.HDEF.PMES = One | |
Notify (^^PCI0.HDEF, 0x02) // Device Wake | |
} | |
If ((^^PCI0.XHC1.PMES == One)) | |
{ | |
^^PCI0.XHC1.PMES = One | |
Notify (^^PCI0.XHC1, 0x02) // Device Wake | |
} | |
} | |
} | |
Device (GPO0) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "INT33FF") // _HID: Hardware ID | |
Name (_CID, "INT33FF") // _CID: Compatible ID | |
Name (_DDN, "General Purpose Input/Output (GPIO) controller - SOUTHWEST") // _DDN: DOS Device Name | |
Name (_UID, One) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xFED80000, // Address Base | |
0x00008000, // Address Length | |
) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
{ | |
0x00000031, | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPO0._CRS.RBUF */ | |
} | |
OperationRegion (GPM0, SystemMemory, (GBA0 | 0x5800), 0x30) | |
Field (GPM0, DWordAcc, Lock, Preserve) | |
{ | |
, 1, | |
TSRR, 1, | |
Offset (0x18), | |
, 1, | |
TSR2, 1, | |
Offset (0x28), | |
, 1, | |
TSRS, 1 | |
} | |
Name (AVBL, One) | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
AVBL = Arg1 | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (!_OSI ("Windows 2012")) | |
{ | |
Return (Zero) | |
} | |
If (_OSI ("Android")) | |
{ | |
AVBL = Zero | |
} | |
If ((GOAE == One)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Device (GPO1) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "INT33FF") // _HID: Hardware ID | |
Name (_CID, "INT33FF") // _CID: Compatible ID | |
Name (_DDN, "General Purpose Input/Output (GPIO) controller - NORTH") // _DDN: DOS Device Name | |
Name (_UID, 0x02) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xFED88000, // Address Base | |
0x00008000, // Address Length | |
) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
{ | |
0x00000030, | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPO1._CRS.RBUF */ | |
} | |
OperationRegion (GPM1, SystemMemory, (GBA1 | 0x4428), 0x04) | |
Field (GPM1, DWordAcc, Lock, Preserve) | |
{ | |
, 1, | |
CWLE, 1 | |
} | |
Name (AVBL, One) | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
AVBL = Arg1 | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (!_OSI ("Windows 2012")) | |
{ | |
Return (Zero) | |
} | |
If (_OSI ("Android")) | |
{ | |
AVBL = Zero | |
} | |
If ((GOAE == One)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Device (GPO2) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "INT33FF") // _HID: Hardware ID | |
Name (_CID, "INT33FF") // _CID: Compatible ID | |
Name (_DDN, "General Purpose Input/Output (GPIO) controller - EAST") // _DDN: DOS Device Name | |
Name (_UID, 0x03) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xFED90000, // Address Base | |
0x00008000, // Address Length | |
) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
{ | |
0x00000032, | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPO2._CRS.RBUF */ | |
} | |
OperationRegion (GPM2, SystemMemory, (GBA2 | 0x4820), 0x04) | |
Field (GPM2, DWordAcc, Lock, Preserve) | |
{ | |
, 1, | |
SHD3, 1 | |
} | |
Name (AVBL, One) | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
AVBL = Arg1 | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (!_OSI ("Windows 2012")) | |
{ | |
Return (Zero) | |
} | |
If (_OSI ("Android")) | |
{ | |
AVBL = Zero | |
} | |
If ((GOAE == One)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Device (GPO3) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Name (_HID, "INT33FF") // _HID: Hardware ID | |
Name (_CID, "INT33FF") // _CID: Compatible ID | |
Name (_DDN, "General Purpose Input/Output (GPIO) controller - SOUTHEAST") // _DDN: DOS Device Name | |
Name (_UID, 0x04) // _UID: Unique ID | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xFED98000, // Address Base | |
0x00008000, // Address Length | |
) | |
Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
{ | |
0x0000005B, | |
} | |
}) | |
Return (RBUF) /* \_SB_.GPO3._CRS.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (!_OSI ("Windows 2012")) | |
{ | |
Return (Zero) | |
} | |
If ((GOAE == One)) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
Device (MBID) | |
{ | |
Name (_HID, "INT33BD" /* Intel Baytrail Mailbox Device */) // _HID: Hardware ID | |
Name (_CID, "INT33BD" /* Intel Baytrail Mailbox Device */) // _CID: Compatible ID | |
Name (_HRV, 0x02) // _HRV: Hardware Revision | |
Name (_UID, One) // _UID: Unique ID | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (RBUF, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadWrite, | |
0xE00000D0, // Address Base | |
0x0000000C, // Address Length | |
) | |
}) | |
Return (RBUF) /* \_SB_.MBID._CRS.RBUF */ | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
Return (Zero) | |
} | |
OperationRegion (REGS, 0x87, Zero, 0x30) | |
Field (REGS, DWordAcc, NoLock, Preserve) | |
{ | |
PORT, 32, | |
REG, 32, | |
DATA, 32, | |
MASK, 32, | |
BE, 32, | |
OP, 32 | |
} | |
Name (AVBL, Zero) | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If ((Arg0 == 0x87)) | |
{ | |
AVBL = Arg1 | |
} | |
} | |
Method (READ, 3, Serialized) | |
{ | |
Local0 = 0xFFFFFFFF | |
If ((AVBL == One)) | |
{ | |
OP = Zero | |
PORT = Arg0 | |
REG = Arg1 | |
BE = Arg2 | |
Local0 = DATA /* \_SB_.MBID.DATA */ | |
} | |
Return (Local0) | |
} | |
Method (WRIT, 4, Serialized) | |
{ | |
If ((AVBL == One)) | |
{ | |
OP = One | |
PORT = Arg0 | |
REG = Arg1 | |
BE = Arg2 | |
DATA = Arg3 | |
} | |
} | |
Method (MODI, 5, Serialized) | |
{ | |
If ((AVBL == One)) | |
{ | |
OP = 0x02 | |
PORT = Arg0 | |
REG = Arg1 | |
BE = Arg2 | |
DATA = Arg3 | |
MASK = Arg4 | |
} | |
} | |
} | |
Device (PIND) | |
{ | |
Name (_HID, "INT3497") // _HID: Hardware ID | |
Name (_UID, Zero) // _UID: Unique ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If (_OSI ("Android")) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Name (PDAT, Package (0x03) | |
{ | |
Package (0x02) | |
{ | |
"VOLUME_UP", | |
Package (0x01) | |
{ | |
0x02 | |
} | |
}, | |
Package (0x02) | |
{ | |
"VOLUME_DOWN", | |
Package (0x01) | |
{ | |
0x02 | |
} | |
}, | |
Package (0x02) | |
{ | |
"HOME_BUTTON", | |
Package (0x01) | |
{ | |
0x02 | |
} | |
} | |
}) | |
Method (_IND, 0, Serialized) | |
{ | |
Return (PDAT) /* \_SB_.PIND.PDAT */ | |
} | |
} | |
} | |
Scope (_TZ) | |
{ | |
Name (LEGA, One) | |
Name (LEGP, One) | |
Name (LEGC, One) | |
PowerResource (FN00, 0x00, 0x0000) | |
{ | |
Method (_STA, 0, Serialized) // _STA: Status | |
{ | |
If (((BDID == CHRB) | (BDID == CIRB))) | |
{ | |
Return (Zero) | |
} | |
Return (VFN0) /* \VFN0 */ | |
} | |
Method (_ON, 0, Serialized) // _ON_: Power On | |
{ | |
VFN0 = One | |
If ((ECON && LEGA)) {} | |
} | |
Method (_OFF, 0, Serialized) // _OFF: Power Off | |
{ | |
VFN0 = Zero | |
If ((ECON && LEGA)) {} | |
} | |
} | |
Device (FAN0) | |
{ | |
Name (_HID, EisaId ("PNP0C0B") /* Fan (Thermal Solution) */) // _HID: Hardware ID | |
Name (_UID, Zero) // _UID: Unique ID | |
Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
{ | |
FN00 | |
}) | |
} | |
ThermalZone (TZ01) | |
{ | |
Name (PTMP, 0x0BB8) | |
Name (SINI, Zero) | |
Name (ADDR, 0x96) | |
Name (LTV0, Zero) | |
Name (RTV1, One) | |
Name (RTV2, 0x30) | |
Name (HITP, 0x55) | |
Method (_SCP, 1, Serialized) // _SCP: Set Cooling Policy | |
{ | |
CTYP = Arg0 | |
} | |
Method (_CRT, 0, Serialized) // _CRT: Critical Temperature | |
{ | |
If ((LEGC == Zero)) | |
{ | |
Return (0x12E0) | |
} | |
Return ((0x0AAC + (CRTT * 0x0A))) | |
} | |
Method (_AC0, 0, Serialized) // _ACx: Active Cooling | |
{ | |
Return (0x0EF8) | |
} | |
Name (_AL0, Package (0x01) // _ALx: Active List | |
{ | |
FAN0 | |
}) | |
Method (_TMP, 0, Serialized) // _TMP: Temperature | |
{ | |
If (DTSE) | |
{ | |
If ((DTS2 > DTS1)) | |
{ | |
Local0 = DTS2 /* \DTS2 */ | |
} | |
Else | |
{ | |
Local0 = DTS1 /* \DTS1 */ | |
} | |
Return ((0x0AAC + (Local0 * 0x0A))) | |
} | |
If (ECON) {} | |
Return (0x0BB8) | |
} | |
Method (_PSL, 0, Serialized) // _PSL: Passive List | |
{ | |
If ((MPEN == 0x04)) | |
{ | |
Return (Package (0x04) | |
{ | |
\_PR.CPU0, | |
\_PR.CPU1, | |
\_PR.CPU2, | |
\_PR.CPU3 | |
}) | |
} | |
If (MPEN) | |
{ | |
Return (Package (0x02) | |
{ | |
\_PR.CPU0, | |
\_PR.CPU1 | |
}) | |
} | |
Return (Package (0x01) | |
{ | |
\_PR.CPU0 | |
}) | |
} | |
Method (_PSV, 0, Serialized) // _PSV: Passive Temperature | |
{ | |
If ((LEGP == Zero)) | |
{ | |
Return (0x0EF8) | |
} | |
Return ((0x0AAC + (PSVT * 0x0A))) | |
} | |
Method (_TC1, 0, Serialized) // _TC1: Thermal Constant 1 | |
{ | |
Return (TC1V) /* \TC1V */ | |
} | |
Method (_TC2, 0, Serialized) // _TC2: Thermal Constant 2 | |
{ | |
Return (TC2V) /* \TC2V */ | |
} | |
Method (_TSP, 0, Serialized) // _TSP: Thermal Sampling Period | |
{ | |
Return (TSPV) /* \TSPV */ | |
} | |
Method (_HOT, 0, Serialized) // _HOT: Hot Temperature | |
{ | |
If ((LEGC == Zero)) | |
{ | |
Return (0x12AE) | |
} | |
Local0 = (CRTT - 0x05) | |
Return ((0x0AAC + (Local0 * 0x0A))) | |
} | |
} | |
} | |
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, | |
0xE0000000, // Address Base | |
0x10000000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFEA00000, // Address Base | |
0x00100000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED01000, // Address Base | |
0x00001000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED03000, // Address Base | |
0x00001000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED06000, // Address Base | |
0x00001000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED08000, // Address Base | |
0x00002000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED80000, // Address Base | |
0x00040000, // Address Length | |
) | |
Memory32Fixed (ReadWrite, | |
0xFED1C000, // Address Base | |
0x00001000, // Address Length | |
) | |
Memory32Fixed (ReadOnly, | |
0xFEE00000, // Address Base | |
0x00100000, // Address Length | |
) | |
}) | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Return (BUF0) /* \_SB_.PCI0.PDRC.BUF0 */ | |
} | |
} | |
} | |
Method (BRTN, 1, Serialized) | |
{ | |
If (((DIDX & 0x0F00) == 0x0400)) | |
{ | |
Notify (\_SB.PCI0.GFX0.DD1F, Arg0) | |
} | |
} | |
Scope (_GPE) | |
{ | |
Method (_L01, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
L01C += One | |
P8XH (Zero, One) | |
P8XH (One, L01C) | |
If (((RP1D == Zero) && \_SB.PCI0.RP01.HPSX)) | |
{ | |
Sleep (0x64) | |
If (\_SB.PCI0.RP01.PDCX) | |
{ | |
\_SB.PCI0.RP01.PDCX = One | |
\_SB.PCI0.RP01.HPSX = One | |
If (!\_SB.PCI0.RP01.PDSX) | |
{ | |
\_SB.PCI0.RP01.L0SE = Zero | |
} | |
Notify (\_SB.PCI0.RP01, Zero) // Bus Check | |
} | |
Else | |
{ | |
\_SB.PCI0.RP01.HPSX = One | |
} | |
} | |
If (((RP2D == Zero) && \_SB.PCI0.RP02.HPSX)) | |
{ | |
Sleep (0x64) | |
If (\_SB.PCI0.RP02.PDCX) | |
{ | |
\_SB.PCI0.RP02.PDCX = One | |
\_SB.PCI0.RP02.HPSX = One | |
If (!\_SB.PCI0.RP02.PDSX) | |
{ | |
\_SB.PCI0.RP02.L0SE = Zero | |
} | |
Notify (\_SB.PCI0.RP02, Zero) // Bus Check | |
} | |
Else | |
{ | |
\_SB.PCI0.RP02.HPSX = One | |
} | |
} | |
If (((RP3D == Zero) && \_SB.PCI0.RP03.HPSX)) | |
{ | |
Sleep (0x64) | |
If (\_SB.PCI0.RP03.PDCX) | |
{ | |
\_SB.PCI0.RP03.PDCX = One | |
\_SB.PCI0.RP03.HPSX = One | |
If (!\_SB.PCI0.RP03.PDSX) | |
{ | |
\_SB.PCI0.RP03.L0SE = Zero | |
} | |
Notify (\_SB.PCI0.RP03, Zero) // Bus Check | |
} | |
Else | |
{ | |
\_SB.PCI0.RP03.HPSX = One | |
} | |
} | |
If (((RP4D == Zero) && \_SB.PCI0.RP04.HPSX)) | |
{ | |
Sleep (0x64) | |
If (\_SB.PCI0.RP04.PDCX) | |
{ | |
\_SB.PCI0.RP04.PDCX = One | |
\_SB.PCI0.RP04.HPSX = One | |
If (!\_SB.PCI0.RP04.PDSX) | |
{ | |
\_SB.PCI0.RP04.L0SE = Zero | |
} | |
Notify (\_SB.PCI0.RP04, Zero) // Bus Check | |
} | |
Else | |
{ | |
\_SB.PCI0.RP04.HPSX = One | |
} | |
} | |
} | |
Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
GPEC = Zero | |
If (CondRefOf (\_TZ.THRM)) | |
{ | |
Notify (\_TZ.THRM, 0x80) // Thermal Status Change | |
} | |
} | |
Method (_L17, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
If (((BDID == CHRB) | (BDID == CIRB))) | |
{ | |
GP23 = One | |
If (CondRefOf (\_TZ.THRM)) | |
{ | |
Notify (\_TZ.THRM, 0x80) // Thermal Status Change | |
} | |
} | |
} | |
Method (_L04, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
PSCI = One | |
} | |
Method (_L05, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
If ((\_SB.PCI0.GFX0.GSSE && !GSMI)) | |
{ | |
\_SB.PCI0.GFX0.GSCI () | |
} | |
} | |
Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
If ((RP1D == Zero)) | |
{ | |
\_SB.PCI0.RP01.HPME () | |
Notify (\_SB.PCI0.RP01, 0x02) // Device Wake | |
} | |
If ((RP2D == Zero)) | |
{ | |
\_SB.PCI0.RP02.HPME () | |
Notify (\_SB.PCI0.RP02, 0x02) // Device Wake | |
} | |
If ((RP3D == Zero)) | |
{ | |
\_SB.PCI0.RP03.HPME () | |
Notify (\_SB.PCI0.RP03, 0x02) // Device Wake | |
} | |
If ((RP4D == Zero)) | |
{ | |
\_SB.PCI0.RP04.HPME () | |
Notify (\_SB.PCI0.RP04, 0x02) // Device Wake | |
} | |
} | |
Method (_L0D, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
{ | |
Notify (\_SB.PCI0.HDEF, 0x02) // Device Wake | |
Notify (\_SB.PCI0.XHC1, 0x02) // Device Wake | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Scope (\) | |
{ | |
Name (MSFG, One) | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Scope (\) | |
{ | |
Name (KBFG, One) | |
} | |
} | |
Device (_SB.TPM) | |
{ | |
Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
{ | |
If (TCMF) | |
{ | |
Return (0x01013469) | |
} | |
Else | |
{ | |
If ((TTDP == Zero)) | |
{ | |
Return (0x310CD041) | |
} | |
Else | |
{ | |
Return ("MSFT0101") | |
} | |
} | |
} | |
Method (_STR, 0, NotSerialized) // _STR: Description String | |
{ | |
If ((TTDP == Zero)) | |
{ | |
Return (Unicode ("TPM 1.2 Device")) | |
} | |
Else | |
{ | |
Return (Unicode ("TPM 2.0 Device")) | |
} | |
} | |
Name (_UID, One) // _UID: Unique ID | |
Name (CRST, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadOnly, | |
0x00000000, // Address Base | |
0x00001000, // Address Length | |
_Y31) | |
Memory32Fixed (ReadOnly, | |
0xFED70000, // Address Base | |
0x00001000, // Address Length | |
_Y32) | |
}) | |
Name (CRSD, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFED40000, // Address Base | |
0x00001000, // Address Length | |
_Y33) | |
}) | |
Name (CRSI, ResourceTemplate () | |
{ | |
Memory32Fixed (ReadOnly, | |
0xFED40000, // Address Base | |
0x00001000, // Address Length | |
_Y34) | |
}) | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
If ((AMDT == One)) | |
{ | |
CreateDWordField (CRST, \_SB.TPM._Y31._BAS, MTFB) // _BAS: Base Address | |
CreateDWordField (CRST, \_SB.TPM._Y31._LEN, LTFB) // _LEN: Length | |
MTFB = TPMB /* \TPMB */ | |
LTFB = 0x1000 | |
CreateDWordField (CRST, \_SB.TPM._Y32._BAS, MTFC) // _BAS: Base Address | |
CreateDWordField (CRST, \_SB.TPM._Y32._LEN, LTFC) // _LEN: Length | |
MTFC = TPMC /* \TPMC */ | |
LTFC = 0x1000 | |
Return (CRST) /* \_SB_.TPM_.CRST */ | |
} | |
Else | |
{ | |
If ((DTPT == One)) | |
{ | |
CreateDWordField (CRSD, \_SB.TPM._Y33._BAS, MTFE) // _BAS: Base Address | |
CreateDWordField (CRSD, \_SB.TPM._Y33._LEN, LTFE) // _LEN: Length | |
MTFE = 0xFED40000 | |
LTFE = 0x0880 | |
Return (CRSD) /* \_SB_.TPM_.CRSD */ | |
} | |
Else | |
{ | |
If ((TTPF == One)) | |
{ | |
CreateDWordField (CRSI, \_SB.TPM._Y34._BAS, MTFD) // _BAS: Base Address | |
CreateDWordField (CRSI, \_SB.TPM._Y34._LEN, LTFD) // _LEN: Length | |
MTFD = 0xFED40000 | |
LTFD = 0x5000 | |
Return (CRSI) /* \_SB_.TPM_.CRSI */ | |
} | |
Else | |
{ | |
If ((TTPF == Zero)) | |
{ | |
CreateDWordField (CRSI, \_SB.TPM._Y34._BAS, MTFF) // _BAS: Base Address | |
MTFF = TPMM /* \TPMM */ | |
Return (CRSI) /* \_SB_.TPM_.CRSI */ | |
} | |
} | |
} | |
} | |
} | |
OperationRegion (TMMB, SystemMemory, 0xFED40000, 0x5000) | |
Field (TMMB, ByteAcc, Lock, Preserve) | |
{ | |
Offset (0x04), | |
LCST, 32, | |
Offset (0x40), | |
CREQ, 32, | |
CSTS, 32, | |
Offset (0x4C), | |
SCMD, 32 | |
} | |
OperationRegion (CRBD, SystemMemory, TPMM, 0x48) | |
Field (CRBD, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
HERR, 32, | |
Offset (0x40), | |
HCMD, 32, | |
HSTS, 32 | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((TTDP == Zero)) | |
{ | |
If (TPMF) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((TTDP == One)) | |
{ | |
If (TPMF) | |
{ | |
Return (0x0F) | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Method (STRT, 3, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
OperationRegion (TPMR, SystemMemory, FTPM, 0x1000) | |
Field (TPMR, AnyAcc, NoLock, Preserve) | |
{ | |
Offset (0x04), | |
FERR, 32, | |
Offset (0x0C), | |
BEGN, 32 | |
} | |
Name (TIMR, Zero) | |
While (One) | |
{ | |
_T_0 = ToInteger (Arg1) | |
If ((_T_0 == Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
TIMR = Zero | |
If ((AMDT == One)) | |
{ | |
While (((BEGN == One) && (TIMR < 0x0200))) | |
{ | |
If ((BEGN == One)) | |
{ | |
Sleep (One) | |
TIMR++ | |
} | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((((HSTS & 0x02) | (HSTS & One)) == | |
0x03)) | |
{ | |
HCMD = One | |
} | |
Else | |
{ | |
FERR = One | |
BEGN = Zero | |
} | |
Return (Zero) | |
} | |
} | |
} | |
Break | |
} | |
Return (One) | |
} | |
Method (CRYF, 3, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
While (One) | |
{ | |
_T_0 = ToInteger (Arg1) | |
If ((_T_0 == Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
Name (TPMV, Package (0x02) | |
{ | |
One, | |
Package (0x02) | |
{ | |
One, | |
0x20 | |
} | |
}) | |
If ((_STA () == Zero)) | |
{ | |
Return (Package (0x01) | |
{ | |
Zero | |
}) | |
} | |
Return (TPMV) /* \_SB_.TPM_.CRYF.TPMV */ | |
} | |
} | |
Break | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Scope (_SB.TPM) | |
{ | |
OperationRegion (ASMI, SystemIO, SMIA, One) | |
Field (ASMI, ByteAcc, NoLock, Preserve) | |
{ | |
INQ, 8 | |
} | |
OperationRegion (BSMI, SystemIO, SMIB, One) | |
Field (BSMI, ByteAcc, NoLock, Preserve) | |
{ | |
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 ((Arg0 == ToUUID ("3dddfaa6-361b-4eb4-a424-8d10089d1653") /* Physical Presence Interface */)) | |
{ | |
While (One) | |
{ | |
_T_0 = ToInteger (Arg2) | |
If ((_T_0 == Zero)) | |
{ | |
Return (Buffer (0x02) | |
{ | |
0xFF, 0x01 /* .. */ | |
}) | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
Return ("1.2") | |
} | |
Else | |
{ | |
If ((_T_0 == 0x02)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
TMF1 = 0x12 | |
DAT = TMF1 /* \TMF1 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
DAT = TMF2 /* \TMF2 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If ((DAT == 0xF1)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((_T_0 == 0x03)) | |
{ | |
Name (PPI1, Package (0x02) | |
{ | |
Zero, | |
Zero | |
}) | |
DAT = 0x11 | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (One) | |
} | |
Index (PPI1, One) = DAT /* \_SB_.TPM_.DAT_ */ | |
Return (PPI1) /* \_SB_.TPM_._DSM.PPI1 */ | |
} | |
Else | |
{ | |
If ((_T_0 == 0x04)) | |
{ | |
Return (TRST) /* \TRST */ | |
} | |
Else | |
{ | |
If ((_T_0 == 0x05)) | |
{ | |
Name (PPI2, Package (0x03) | |
{ | |
Zero, | |
Zero, | |
Zero | |
}) | |
DAT = 0x21 | |
INQ = OFST /* \OFST */ | |
Index (PPI2, One) = DAT /* \_SB_.TPM_.DAT_ */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
DAT = 0x31 | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If ((DAT == 0xF0)) | |
{ | |
DAT = 0x51 | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Index (PPI2, 0x02) = 0xFFFFFFF0 | |
Return (PPI2) /* \_SB_.TPM_._DSM.PPI2 */ | |
} | |
} | |
Else | |
{ | |
If ((DAT == 0xF1)) | |
{ | |
DAT = 0x51 | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Index (PPI2, 0x02) = 0xFFFFFFF1 | |
Return (PPI2) /* \_SB_.TPM_._DSM.PPI2 */ | |
} | |
} | |
Else | |
{ | |
Index (PPI2, 0x02) = DAT /* \_SB_.TPM_.DAT_ */ | |
} | |
} | |
Return (PPI2) /* \_SB_.TPM_._DSM.PPI2 */ | |
} | |
Else | |
{ | |
If ((_T_0 == 0x06)) | |
{ | |
Return (0x03) | |
} | |
Else | |
{ | |
If ((_T_0 == 0x07)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
TMF1 = 0x12 | |
DAT = TMF1 /* \TMF1 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
DAT = TMF2 /* \TMF2 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
If ((DAT == 0xF1)) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((_T_0 == 0x08)) | |
{ | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF2) /* \TMF2 */ | |
TMF1 = 0x43 | |
DAT = TMF1 /* \TMF1 */ | |
INQ = OFST /* \OFST */ | |
DAT = TMF2 /* \TMF2 */ | |
INQ = OFST /* \OFST */ | |
Return (DAT) /* \_SB_.TPM_.DAT_ */ | |
} | |
Else | |
{ | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
Else | |
{ | |
If ((Arg0 == ToUUID ("376054ed-cc13-4675-901c-4756d7f2d45d"))) | |
{ | |
While (One) | |
{ | |
_T_1 = ToInteger (Arg2) | |
If ((_T_1 == Zero)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
If ((_T_1 == One)) | |
{ | |
TMF1 = 0x22 | |
DAT = TMF1 /* \TMF1 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
ToInteger (DerefOf (Index (Arg3, Zero)), TMF1) /* \TMF1 */ | |
DAT = TMF1 /* \TMF1 */ | |
INQ = OFST /* \OFST */ | |
If ((DAT == 0xFF)) | |
{ | |
Return (0x02) | |
} | |
Return (Zero) | |
} | |
Else | |
{ | |
} | |
} | |
Break | |
} | |
} | |
} | |
If ((Arg0 == ToUUID ("cf8e16a5-c1e8-4e25-b712-4f54a96702c8"))) | |
{ | |
Return (CRYF (Arg1, Arg2, Arg3)) | |
} | |
If ((Arg0 == ToUUID ("6bbf6cab-5463-4714-b7cd-f0203c0368d4"))) | |
{ | |
Return (STRT (Arg1, Arg2, Arg3)) | |
} | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
OperationRegion (IRNV, SystemMemory, 0xFFFF0000, 0xAA55) | |
Field (IRNV, AnyAcc, Lock, Preserve) | |
{ | |
INSC, 8 | |
} | |
Scope (_SB.PCI0.XHC1) | |
{ | |
Device (RHUB) | |
{ | |
Name (_ADR, Zero) // _ADR: Address | |
Device (SS01) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
0x0A, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS01._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS01._PLD.XPLD */ | |
} | |
} | |
Device (SS02) | |
{ | |
Name (_ADR, 0x02) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS02._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS02._PLD.XPLD */ | |
} | |
} | |
Device (SS03) | |
{ | |
Name (_ADR, 0x03) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
Zero, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS03._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS03._PLD.XPLD */ | |
} | |
} | |
Device (SS04) | |
{ | |
Name (_ADR, 0x04) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
Zero, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS04._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS04._PLD.XPLD */ | |
} | |
} | |
Device (SS05) | |
{ | |
Name (_ADR, 0x05) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
Zero, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS05._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x80, 0x02, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS05._PLD.XPLD */ | |
} | |
} | |
Device (SS06) | |
{ | |
Name (_ADR, 0x06) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
Zero, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS06._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS06._PLD.XPLD */ | |
} | |
} | |
Device (SS07) | |
{ | |
Name (_ADR, 0x07) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
Zero, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS07._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS07._PLD.XPLD */ | |
} | |
} | |
Device (SS08) | |
{ | |
Name (_ADR, 0x08) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
Zero, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS08._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS08._PLD.XPLD */ | |
} | |
} | |
Device (SS09) | |
{ | |
Name (_ADR, 0x09) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS09._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS09._PLD.XPLD */ | |
} | |
} | |
Device (SS0A) | |
{ | |
Name (_ADR, 0x0A) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
0x0A, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS0A._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS0A._PLD.XPLD */ | |
} | |
} | |
Device (SS0B) | |
{ | |
Name (_ADR, 0x0B) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
0xFF, | |
0x0A, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS0B._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x61, 0x0D, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* a....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS0B._PLD.XPLD */ | |
} | |
} | |
Device (SS0C) | |
{ | |
Name (_ADR, 0x0C) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
Zero, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS0C._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS0C._PLD.XPLD */ | |
} | |
} | |
Device (SS0D) | |
{ | |
Name (_ADR, 0x0D) // _ADR: Address | |
Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
{ | |
Name (XUPC, Package (0x04) | |
{ | |
Zero, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Return (XUPC) /* \_SB_.PCI0.XHC1.RHUB.SS0D._UPC.XUPC */ | |
} | |
Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
{ | |
Name (XPLD, Package (0x01) | |
{ | |
Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x60, 0x0D, 0x80, 0x06, 0x00, 0x00, 0x00, 0x00, /* `....... */ | |
/* 0010 */ 0x00, 0x00, 0x00, 0x00 /* .... */ | |
} | |
}) | |
Return (XPLD) /* \_SB_.PCI0.XHC1.RHUB.SS0D._PLD.XPLD */ | |
} | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Method (DIAG, 1, NotSerialized) | |
{ | |
P8XH (Zero, Arg0) | |
} | |
OperationRegion (GPSC, SystemIO, 0xB2, 0x02) | |
Field (GPSC, ByteAcc, NoLock, Preserve) | |
{ | |
SMCM, 8, | |
SMST, 8 | |
} | |
Method (ISMI, 1, Serialized) | |
{ | |
SMCM = Arg0 | |
} | |
Method (ASMI, 1, Serialized) | |
{ | |
\_SB.ALPR = Arg0 | |
SMCM = 0xA3 | |
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, | |
Offset (0x51), | |
Offset (0x53), | |
WLDP, 1, | |
BTDP, 1, | |
WRST, 1, | |
BRST, 1, | |
WRPS, 1, | |
BRPS, 1, | |
Offset (0x54), | |
SYNA, 1, | |
ALPS, 1, | |
ELAN, 1, | |
STLC, 1, | |
FOLT, 1, | |
TPIF, 1, | |
Offset (0x55), | |
IKF2, 8, | |
UHDB, 8, | |
OSPM, 8, | |
TCGF, 8, | |
PPIS, 8, | |
PPIR, 8, | |
SIDE, 1, | |
PWBS, 1, | |
WFFG, 1, | |
OCST, 3, | |
SMTT, 1, | |
Offset (0x5C), | |
SP80, 1, | |
ITPL, 1, | |
ETPL, 1, | |
Offset (0x5D), | |
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 (0x60), | |
SPDC, 8, | |
DROK, 1, | |
SPDG, 1, | |
Offset (0x62), | |
KBLV, 8, | |
FVGA, 1, | |
P4HN, 1, | |
USSC, 1, | |
MFTM, 1, | |
APBM, 4, | |
EGCP, 8, | |
EGC2, 2, | |
Offset (0x66), | |
VHDA, 1, | |
DP3S, 1, | |
LTCL, 2, | |
LOLK, 2, | |
U3WA, 2, | |
GSDT, 1, | |
PBAF, 1, | |
Offset (0x68), | |
PA3D, 1, | |
S4EN, 1, | |
, 2, | |
TCCA, 4, | |
S4TF, 1, | |
BECF, 1, | |
MMOD, 4, | |
Offset (0x6A) | |
} | |
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, | |
USBF, 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, | |
SMFA, 32, | |
CALB, 32, | |
EVET, 32 | |
} | |
} | |
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) | |
Name (OS13, 0x0110) | |
Name (OS14, 0x0120) | |
Name (OS15, 0x0130) | |
Name (OS16, 0x0140) | |
Name (OS17, 0x0150) | |
Method (MCTH, 2, NotSerialized) | |
{ | |
If ((SizeOf (Arg0) < SizeOf (Arg1))) | |
{ | |
Return (Zero) | |
} | |
Local0 = (SizeOf (Arg0) + One) | |
Name (BUF0, Buffer (Local0) {}) | |
Name (BUF1, Buffer (Local0) {}) | |
BUF0 = Arg0 | |
BUF1 = Arg1 | |
While (Local0) | |
{ | |
Local0-- | |
If ((DerefOf (Index (BUF0, Local0)) != DerefOf (Index (BUF1, Local0 | |
)))) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
Method (MSOS, 0, NotSerialized) | |
{ | |
If ((OSFG != Zero)) | |
{ | |
Return (OSFG) /* \OSFG */ | |
} | |
If (CondRefOf (\_OSI, Local0)) | |
{ | |
If (_OSI ("Windows 2001")) | |
{ | |
OSFG = OSXP /* \OSXP */ | |
} | |
If (_OSI ("Windows 2001 SP1")) | |
{ | |
OSFG = OSXP /* \OSXP */ | |
} | |
If (_OSI ("Windows 2001 SP2")) | |
{ | |
OSFG = OSXP /* \OSXP */ | |
} | |
If (_OSI ("Windows 2006")) | |
{ | |
OSFG = OSVT /* \OSVT */ | |
} | |
If (_OSI ("Linux")) | |
{ | |
OSFG = OSEG /* \OSEG */ | |
} | |
If (_OSI ("Windows 2009")) | |
{ | |
OSFG = OSW7 /* \OSW7 */ | |
} | |
If (_OSI ("Windows 2012")) | |
{ | |
OSFG = OSW8 /* \OSW8 */ | |
} | |
If (_OSI ("Windows 2013")) | |
{ | |
OSFG = OS13 /* \OS13 */ | |
} | |
If (_OSI ("Windows 2014")) | |
{ | |
OSFG = OS14 /* \OS14 */ | |
} | |
If (_OSI ("Windows 2015")) | |
{ | |
OSFG = OS15 /* \OS15 */ | |
} | |
If (_OSI ("Windows 2016")) | |
{ | |
OSFG = OS16 /* \OS16 */ | |
} | |
If (_OSI ("Windows 2017")) | |
{ | |
OSFG = OS17 /* \OS17 */ | |
} | |
Return (OSFG) /* \OSFG */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft Windows")) | |
{ | |
OSFG = OS98 /* \OS98 */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft WindowsME: Millennium Edition")) | |
{ | |
OSFG = OSME /* \OSME */ | |
} | |
Else | |
{ | |
If (MCTH (_OS, "Microsoft Windows NT")) | |
{ | |
OSFG = OS2K /* \OS2K */ | |
} | |
Else | |
{ | |
OSFG = OSXP /* \OSXP */ | |
} | |
} | |
} | |
} | |
Return (OSFG) /* \OSFG */ | |
} | |
Name (ONAM, "ASUSTeK") | |
Method (ADVG, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) {} | |
Return (0x03) | |
} | |
Method (GCDM, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) {} | |
Return (One) | |
} | |
Method (SWHG, 1, Serialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
Return (One) | |
} | |
Return (Zero) | |
} | |
Method (NATK, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.GFX0.PRST ()) | |
{ | |
Return (\_SB.PCI0.GFX0.NATK ()) | |
} | |
Return (One) | |
} | |
} | |
Scope (_SB.PCI0.SBRG) | |
{ | |
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 | |
) | |
}) | |
Method (_GPE, 0, NotSerialized) // _GPE: General Purpose Events | |
{ | |
Local0 = 0x16 | |
Return (Local0) | |
} | |
Mutex (MUEC, 0x00) | |
Mutex (MU4T, 0x00) | |
Name (ECFL, Ones) | |
Method (ECAV, 0, NotSerialized) | |
{ | |
If ((SLPT >= 0x04)) | |
{ | |
Return (Zero) | |
} | |
If ((NVLK == One)) | |
{ | |
Return (Zero) | |
} | |
If ((ECFL == Ones)) | |
{ | |
If ((_REV >= 0x02)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
Return (ECFL) /* \_SB_.PCI0.SBRG.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 (((PBSY & 0x02) == 0x02)) | |
{ | |
If ((Arg6 > 0x1000)) | |
{ | |
Return (Zero) | |
} | |
Arg6 += One | |
Sleep (0x0A) | |
} | |
PBSY &= 0xFD | |
HTAR = Arg0 | |
HWLR = Arg1 | |
HRLR = Arg2 | |
HCMD = Arg3 | |
Name (TEMP, Zero) | |
TEMP = Zero | |
If ((Arg1 != Zero)) | |
{ | |
While (One) | |
{ | |
_T_0 = ToInteger (HCMD) | |
If ((_T_0 == 0xF7)) | |
{ | |
TEMP = Zero | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
TEMP = Zero | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0x02)) | |
{ | |
TEMP = Zero | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xA1)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xA2)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xB1)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xB2)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0x61)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0x62)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xE1)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xE2)) | |
{ | |
TEMP = (Arg1 - One) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xA5)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xA6)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xB5)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xB6)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0x65)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0x66)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xE5)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == 0xE6)) | |
{ | |
HCTL |= 0x40 | |
TEMP = (Arg1 - 0x02) | |
Break | |
} | |
Else | |
{ | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
If ((TEMP > Zero)) | |
{ | |
Local0 = Zero | |
While ((Local0 < TEMP)) | |
{ | |
HWDR = DerefOf (Index (Arg4, Local0)) | |
Local0 += One | |
} | |
} | |
HCTL |= One | |
Name (TIME, 0x5000) | |
Local0 = Zero | |
While ((Local0 < TIME)) | |
{ | |
If ((HSTS & 0x80)) | |
{ | |
HSTS = 0x80 | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
If ((HSTS & 0x40)) | |
{ | |
HSTS = 0x40 | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
If ((HSTS & 0x20)) | |
{ | |
HSTS = 0x20 | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
If ((HSTS & 0x08)) | |
{ | |
HSTS = 0x08 | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
If ((HSTS & 0x04)) | |
{ | |
HSTS = 0x04 | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
If ((HSTS & 0x02)) | |
{ | |
HSTS = 0x02 | |
Break | |
} | |
} | |
If ((Local0 == TIME)) | |
{ | |
PBSY &= 0xFE | |
Return (Zero) | |
} | |
Else | |
{ | |
Local0 = Zero | |
While ((Local0 < HRLR)) | |
{ | |
Local1 = HRDR /* \_SB_.PCI0.SBRG.EC0_.HRDR */ | |
Index (Arg5, Local0) = Local1 | |
Local0 += One | |
} | |
PBSY &= 0xFE | |
Return (One) | |
} | |
PBSY &= 0xFE | |
} | |
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 ((MSOS () <= OSME)) | |
{ | |
ECFL = One | |
} | |
KINI () | |
} | |
Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
{ | |
If ((Arg0 == 0x03)) | |
{ | |
ECFL = Arg1 | |
} | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Name (ATKP, Zero) | |
Name (AITM, Zero) | |
Name (PLMD, Zero) | |
Name (MUTX, One) | |
Name (LEDS, Zero) | |
Name (PWKY, Zero) | |
Name (FNIV, Zero) | |
Device (ATKD) | |
{ | |
Name (_HID, "PNP0C14" /* Windows Management Instrumentation Device */) // _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 ((AQNO >= 0x10)) | |
{ | |
Local0 = 0x64 | |
While ((Local0 && (AQNO >= 0x10))) | |
{ | |
Local0-- | |
Sleep (0x0A) | |
} | |
If ((!Local0 && (AQNO >= 0x10))) | |
{ | |
Return (Zero) | |
} | |
} | |
AQTI++ | |
AQTI &= 0x0F | |
Index (ATKQ, AQTI) = Arg0 | |
AQNO++ | |
Return (One) | |
} | |
Method (GANQ, 0, Serialized) | |
{ | |
If (AQNO) | |
{ | |
AQNO-- | |
Local0 = DerefOf (Index (ATKQ, AQHI)) | |
AQHI++ | |
AQHI &= 0x0F | |
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, Serialized) | |
{ | |
CreateDWordField (Arg2, Zero, IIA0) | |
CreateDWordField (Arg2, 0x04, IIA1) | |
Local0 = (Arg1 & 0xFFFFFFFF) | |
If ((Local0 == 0x54494E49)) | |
{ | |
INIT (IIA0) | |
Return (One) | |
} | |
If ((Local0 == 0x53545342)) | |
{ | |
Return (BSTS ()) | |
} | |
If ((Local0 == 0x4E554653)) | |
{ | |
Return (SFUN ()) | |
} | |
If ((Local0 == 0x43455053)) | |
{ | |
Return (SPEC (IIA0)) | |
} | |
If ((Local0 == 0x494E424B)) | |
{ | |
Return (KBNI ()) | |
} | |
If ((Local0 == 0x5256534F)) | |
{ | |
OSVR (IIA0) | |
Return (Zero) | |
} | |
If ((Local0 == 0x53545344)) | |
{ | |
If ((IIA0 == 0x00060023)) | |
{ | |
Name (LASV, Zero) | |
If ((NVLK == One)) | |
{ | |
Return (LASV) /* \_SB_.ATKD.WMNB.LASV */ | |
} | |
Local0 = Zero | |
FSTA = 0xFFFF | |
FADR = 0x55534243 | |
FSMI (0x05) | |
If ((FSTA == 0x03)) | |
{ | |
Local0 = (^^PCI0.SBRG.EC0.STA8 (Zero) & 0x03) | |
} | |
If (Ones) | |
{ | |
Local0 |= 0x04 | |
} | |
LASV = Local0 | |
Return (Local0) | |
} | |
If ((IIA0 == 0x00060024)) | |
{ | |
Return (Package (0x03) | |
{ | |
0x22B58086, | |
0x02, | |
0xFFFFFFFF | |
}) | |
} | |
If ((IIA0 == 0x00060026)) | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.STA8 (Zero) | |
Local0 &= 0x04 | |
If ((Local0 == 0x04)) | |
{ | |
Return (0x00010001) | |
} | |
Else | |
{ | |
If ((Local0 == Zero)) | |
{ | |
Return (0x00010000) | |
} | |
} | |
} | |
If ((IIA0 == 0x00010002)) | |
{ | |
Return (0x00050006) | |
} | |
If ((IIA0 == 0x00020011)) | |
{ | |
Return ((GALE (One) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00020012)) | |
{ | |
Return ((GALE (0x02) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00020013)) | |
{ | |
Return ((GALE (0x04) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00040015)) | |
{ | |
Return ((GALE (0x08) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00020014)) | |
{ | |
Return ((GALE (0x10) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00020015)) | |
{ | |
Return ((GALE (0x20) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00020016)) | |
{ | |
Return ((GALE (0x40) | 0x00050000)) | |
} | |
If ((IIA0 == 0x00110011)) | |
{ | |
Return ((TMPR () & 0xFFFF)) | |
} | |
If ((IIA0 == 0x00110012)) | |
{ | |
Local0 = TMPR () | |
Local1 = Local0 | |
Local0 = ((Local0 & 0xF0000000) >> 0x1C) | |
Local1 = ((Local1 & 0x0F000000) >> 0x18) | |
Local1 <<= 0x08 | |
Return ((Local0 + Local1)) | |
} | |
If ((IIA0 == 0x00050012)) | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
Local0 = 0x64 | |
Local0 <<= 0x08 | |
Local1 = (Local0 + 0x64) | |
} | |
Else | |
{ | |
Local0 = 0x0A | |
Local0 <<= 0x08 | |
Local1 = (GPLV () + Local0) | |
} | |
Return (Local1) | |
} | |
If ((IIA0 == 0x00010011)) | |
{ | |
If (WLDP) | |
{ | |
Return ((WRST + 0x00030000)) | |
} | |
} | |
If ((IIA0 == 0x00010013)) | |
{ | |
If (BTDP) | |
{ | |
Return ((BRST + 0x00050000)) | |
} | |
} | |
If ((IIA0 == 0x00010001)) | |
{ | |
Return (0x00040000) | |
} | |
If ((IIA0 == 0x00120012)) | |
{ | |
Return (PSTC (Zero)) | |
} | |
If ((IIA0 == 0x00120015)) | |
{ | |
Local0 = (SLMT - One) | |
Return ((Local0 | 0x00010000)) | |
} | |
If ((IIA0 == 0x00080041)) | |
{ | |
Return (Zero) | |
} | |
If ((IIA0 == 0x00080042)) | |
{ | |
Return (Zero) | |
} | |
If ((IIA0 == 0x00080043)) | |
{ | |
Return (Zero) | |
} | |
If ((IIA0 == 0x00080044)) | |
{ | |
Return (Zero) | |
} | |
} | |
If ((Local0 == 0x53564544)) | |
{ | |
If ((IIA0 == 0x00060023)) | |
{ | |
If ((NVLK == One)) | |
{ | |
Return (Zero) | |
} | |
Local0 = Zero | |
FSTA = 0xFFFF | |
FADR = 0x55534243 | |
FSMI (0x05) | |
Local0 = (IIA1 >> 0x09) | |
If (((Local0 & One) == One)) | |
{ | |
VBOF = One | |
Local0 = (IIA1 >> 0x18) | |
Local0 *= 0x0100 | |
VBOF |= Local0 /* \_SB_.VBOF */ | |
} | |
Else | |
{ | |
VBOF = Zero | |
} | |
Local0 = (IIA1 & 0xFF) | |
^^PCI0.SBRG.EC0.STA9 (One, Local0) | |
Local0 = (IIA1 >> 0x08) | |
Local1 = ^^PCI0.SBRG.EC0.STA8 (Zero) | |
If (((Local0 & One) == One)) | |
{ | |
Local1 |= 0x02 | |
Local2 = (Local1 & 0x0F) | |
USBF = Local2 | |
^^PCI0.SBRG.EC0.STA9 (Zero, Local1) | |
} | |
Else | |
{ | |
Local1 &= 0xFD | |
Local2 = (Local1 & 0x0F) | |
USBF = Local2 | |
^^PCI0.SBRG.EC0.STA9 (Zero, Local1) | |
} | |
FSTA = 0xFFFF | |
FADR = 0x55534243 | |
FSMI (0x04) | |
If ((FSTA == 0x03)) | |
{ | |
FSTA = 0xFFFF | |
FSMI (0x06) | |
If ((FSTA != Zero)) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
If ((IIA0 == 0x00060026)) | |
{ | |
Local0 = Zero | |
FSTA = 0xFFFF | |
FADR = 0x55534243 | |
FSMI (0x05) | |
Local0 = ^^PCI0.SBRG.EC0.STA8 (Zero) | |
If ((IIA1 == One)) | |
{ | |
Local2 = (0x04 | USBF) /* \_SB_.USBF */ | |
USBF = Local2 | |
Local0 |= 0x04 | |
^^PCI0.SBRG.EC0.STA9 (Zero, Local0) | |
} | |
Else | |
{ | |
Local2 = (0xFB & USBF) /* \_SB_.USBF */ | |
USBF = Local2 | |
Local0 &= 0xFB | |
^^PCI0.SBRG.EC0.STA9 (Zero, Local0) | |
} | |
FSTA = 0xFFFF | |
FADR = 0x55534243 | |
FSMI (0x04) | |
If ((FSTA == 0x03)) | |
{ | |
FSTA = 0xFFFF | |
FSMI (0x06) | |
If ((FSTA != Zero)) | |
{ | |
Return (Zero) | |
} | |
} | |
Return (One) | |
} | |
If ((IIA0 == 0x00020011)) | |
{ | |
Return (SALE ((IIA1 + 0x02))) | |
} | |
If ((IIA0 == 0x00020012)) | |
{ | |
Return (SALE ((IIA1 + 0x04))) | |
} | |
If ((IIA0 == 0x00020013)) | |
{ | |
Return (SALE ((IIA1 + 0x08))) | |
} | |
If ((IIA0 == 0x00040015)) | |
{ | |
Return (SALE ((IIA1 + 0x10))) | |
} | |
If ((IIA0 == 0x00020014)) | |
{ | |
Return (SALE ((IIA1 + 0x20))) | |
} | |
If ((IIA0 == 0x00020015)) | |
{ | |
Return (SALE ((IIA1 + 0x40))) | |
} | |
If ((IIA0 == 0x00020016)) | |
{ | |
Return (SALE ((IIA1 + 0x80))) | |
} | |
If ((IIA0 == 0x00050011)) | |
{ | |
If ((IIA1 == 0x02)) | |
{ | |
^^PCI0.SBRG.EC0.SPIN (0x37, One) | |
^^PCI0.SBRG.EC0.BLCT = One | |
} | |
Return (One) | |
} | |
If ((IIA0 == 0x00050012)) | |
{ | |
SPLV (IIA1) | |
Return (One) | |
} | |
If ((IIA0 == 0x00010002)) | |
{ | |
If (((IIA1 == 0x04) || (IIA1 == 0x05))) | |
{ | |
IIA1 -= 0x04 | |
} | |
OWGD (IIA1) | |
Return (One) | |
} | |
If ((IIA0 == 0x00010012)) | |
{ | |
WLED (IIA1) | |
Return (One) | |
} | |
If ((IIA0 == 0x00010013)) | |
{ | |
BLED (IIA1) | |
Return (One) | |
} | |
If ((IIA0 == 0x00010003)) | |
{ | |
Return (CWAP (IIA1)) | |
} | |
If ((IIA0 == 0x00120012)) | |
{ | |
Return (PSTC ((IIA1 + One))) | |
} | |
If ((IIA0 == 0x00100021)) | |
{ | |
^^PCI0.SBRG.EC0._Q0B () | |
Return (One) | |
} | |
If ((IIA0 == 0x00100022)) | |
{ | |
If ((IIA1 & 0x02)) | |
{ | |
^^PCI0.SBRG.EC0.STB1 (0x04) | |
^^PCI0.SBRG.EC0.STB1 (0x05) | |
FNIV = One | |
Return (One) | |
} | |
Else | |
{ | |
KINI () | |
Return (One) | |
} | |
Return (Zero) | |
} | |
If ((IIA0 == 0x00120053)) | |
{ | |
If ((IIA1 & One)) | |
{ | |
BATF (One) | |
Return (One) | |
} | |
Else | |
{ | |
BATF (Zero) | |
Return (One) | |
} | |
Return (Zero) | |
} | |
} | |
If ((Local0 == 0x48534C46)) | |
{ | |
FLSH (IIA0) | |
Return (One) | |
} | |
If ((Local0 == 0x494E4946)) | |
{ | |
Return (FINI (IIA0)) | |
} | |
If ((Local0 == 0x53524546)) | |
{ | |
Return (FERS (IIA0)) | |
} | |
If ((Local0 == 0x49525746)) | |
{ | |
Return (FWRI (IIA0)) | |
} | |
If ((Local0 == 0x57504346)) | |
{ | |
Return (FCPW (IIA0)) | |
} | |
If ((Local0 == 0x50504346)) | |
{ | |
Return (FCPP ()) | |
} | |
If ((Local0 == 0x50525746)) | |
{ | |
Return (FWRP ()) | |
} | |
If ((Local0 == 0x52534345)) | |
{ | |
Return (ECSR (IIA0)) | |
} | |
If ((Local0 == 0x43534C46)) | |
{ | |
Return (FLSC (IIA0)) | |
} | |
If ((Local0 == 0x43455246)) | |
{ | |
Return (FREC (IIA0)) | |
} | |
If ((Local0 == 0x454D4946)) | |
{ | |
Return (FIME (IIA0)) | |
} | |
If ((Local0 == 0x4C425053)) | |
{ | |
If ((IIA0 == 0x80)) | |
{ | |
If ((MSOS () >= OSVT)) | |
{ | |
Return (Zero) | |
} | |
Return (One) | |
} | |
If ((IIA0 > 0x0F)) | |
{ | |
Return (Zero) | |
} | |
If ((IIA0 < Zero)) | |
{ | |
Return (Zero) | |
} | |
SPLV (IIA0) | |
Return (One) | |
} | |
If ((Local0 == 0x50534453)) | |
{ | |
SDSP (IIA0) | |
Return (One) | |
} | |
If ((Local0 == 0x50534447)) | |
{ | |
Return (GDSP (IIA0)) | |
} | |
If ((Local0 == 0x44495047)) | |
{ | |
Return (GPID ()) | |
} | |
If ((Local0 == 0x44434C47)) | |
{ | |
Return (GLCD ()) | |
} | |
If ((Local0 == 0x444F4D51)) | |
{ | |
Return (QMOD (IIA0)) | |
} | |
If ((Local0 == 0x49564E41)) | |
{ | |
Return (ANVI (IIA0)) | |
} | |
If ((Local0 == 0x46494243)) | |
{ | |
Return (CBIF (IIA0)) | |
} | |
If ((Local0 == 0x4E464741)) | |
{ | |
Return (AGFN (IIA0)) | |
} | |
If ((Local0 == 0x46494643)) | |
{ | |
CFIF (IIA0) | |
Return (One) | |
} | |
If ((Local0 == 0x44495046)) | |
{ | |
Return (0x0118) | |
} | |
If ((Local0 == 0x59454B48)) | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */ | |
Return (One) | |
} | |
If ((Local0 == 0x5446424B)) | |
{ | |
^^PCI0.SBRG.EC0.HKEN = IIA0 /* \_SB_.ATKD.WMNB.IIA0 */ | |
Return (One) | |
} | |
If ((Local0 == 0x47444353)) | |
{ | |
Return (SCDG (IIA0)) | |
} | |
Return (0xFFFFFFFE) | |
} | |
Method (_WED, 1, NotSerialized) // _Wxx: Wake Event | |
{ | |
If ((Arg0 == 0xFF)) | |
{ | |
Return (GANQ ()) | |
} | |
Return (Ones) | |
} | |
Method (IANE, 1, Serialized) | |
{ | |
IANQ (Arg0) | |
Notify (ATKD, 0xFF) // Hardware-Specific | |
} | |
Method (INIT, 1, NotSerialized) | |
{ | |
ATKP = One | |
Return (MNAM) /* \_SB_.MNAM */ | |
} | |
Method (BSTS, 0, NotSerialized) | |
{ | |
Local0 = IKFG /* \_SB_.IKFG */ | |
Local0 |= (IKF2 << 0x08) | |
If (ACPF) | |
{ | |
Local0 = Zero | |
Return (Local0) | |
} | |
Else | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.RRAM (0x04FE) | |
If (((Local0 & 0xFF) == 0x34)) | |
{ | |
Local0 = 0x05 | |
Return (Local0) | |
} | |
Else | |
{ | |
Local0 = Zero | |
Return (Local0) | |
} | |
} | |
Local0 &= 0xFFDF | |
Return (Local0) | |
} | |
Method (TMPR, 0, NotSerialized) | |
{ | |
Return (Ones) | |
} | |
Method (SFUN, 0, NotSerialized) | |
{ | |
Local0 = 0x37 | |
Local0 |= 0x40 | |
Local0 |= 0x0800 | |
Local0 |= 0x00020000 | |
Local0 |= 0x00080000 | |
Return (Local0) | |
} | |
Method (SPEC, 1, NotSerialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Return (0x00070009) | |
} | |
Else | |
{ | |
If ((Arg0 == One)) | |
{ | |
Return (One) | |
} | |
} | |
Return (0xFFFFFFFE) | |
} | |
Method (OSVR, 1, NotSerialized) | |
{ | |
If ((OSFG == Zero)) | |
{ | |
OSFG = Arg0 | |
} | |
} | |
Method (GPLV, 0, NotSerialized) | |
{ | |
Return (LBTN) /* \_SB_.LBTN */ | |
} | |
Method (SPLV, 1, NotSerialized) | |
{ | |
LBTN = Arg0 | |
^^PCI0.SBRG.EC0.STBR () | |
Return (One) | |
} | |
Method (SPBL, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x0100)) | |
{ | |
Local0 = 0x0A | |
Return (Local0) | |
} | |
If ((Arg0 == 0x80)) | |
{ | |
Return (One) | |
} | |
If ((Arg0 > 0x0F)) | |
{ | |
Return (Zero) | |
} | |
If ((Arg0 < Zero)) | |
{ | |
Return (Zero) | |
} | |
SPLV (Arg0) | |
Return (One) | |
} | |
Method (WLED, 1, NotSerialized) | |
{ | |
OWLD (Arg0) | |
Return (One) | |
} | |
Method (KBNI, 0, NotSerialized) | |
{ | |
Return (One) | |
} | |
Method (GALE, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x04)) | |
{ | |
If ((LEDS && 0x04)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
If ((Arg0 == 0x08)) | |
{ | |
If ((LEDS && 0x08)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
If ((Arg0 == 0x10)) | |
{ | |
If ((LEDS && 0x10)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Return (0x02) | |
} | |
Method (SALE, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x10)) {} | |
If ((Arg0 == 0x11)) {} | |
Return (One) | |
} | |
Method (BLED, 1, NotSerialized) | |
{ | |
OBTD (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 (HWRS, 0, NotSerialized) | |
{ | |
Return (OHWR ()) | |
} | |
Method (GLCD, 0, NotSerialized) | |
{ | |
Return (LCDV) /* \_SB_.LCDV */ | |
} | |
Name (WAPF, Zero) | |
Method (CWAP, 1, NotSerialized) | |
{ | |
WAPF |= Arg0 /* \_SB_.ATKD.WAPF */ | |
Return (One) | |
} | |
Method (QMOD, 1, NotSerialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Return (Zero) | |
} | |
If ((Arg0 == One)) | |
{ | |
^^PCI0.SBRG.EC0.ST98 (QFAN) | |
} | |
If ((Arg0 == 0x02)) | |
{ | |
^^PCI0.SBRG.EC0.ST98 (0xFF) | |
} | |
Return (One) | |
} | |
Method (ANVI, 1, Serialized) | |
{ | |
Local0 = ASMI (Arg0) | |
Return (Local0) | |
} | |
Method (PSTC, 1, Serialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Local0 = CPUP /* \_SB_.CPUP */ | |
Local0 <<= 0x08 | |
Local0 += CPUP | |
Return (Local0) | |
} | |
If ((Arg0 > CPUP)) | |
{ | |
Return (Ones) | |
} | |
SLMT = Arg0 | |
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 | |
} | |
Return (Zero) | |
} | |
Method (SMBB, 1, Serialized) | |
{ | |
} | |
Method (SMBW, 1, Serialized) | |
{ | |
} | |
Method (SMBK, 1, Serialized) | |
{ | |
} | |
Method (ECRW, 1, Serialized) | |
{ | |
Local0 = (Arg0 >> 0x18) | |
Local0 &= 0xFF | |
Local1 = (Arg0 >> 0x10) | |
Local1 &= 0xFF | |
Local2 = (Arg0 >> 0x08) | |
Local2 &= 0xFF | |
Local3 = (Arg0 & 0xFF) | |
Acquire (^^PCI0.SBRG.EC0.MUEC, 0xFFFF) | |
^^PCI0.SBRG.EC0.CDT3 = Local0 | |
^^PCI0.SBRG.EC0.CDT2 = Local1 | |
^^PCI0.SBRG.EC0.CDT1 = Local2 | |
^^PCI0.SBRG.EC0.CMD1 = Local3 | |
Local0 = 0x05 | |
While ((Local0 && ^^PCI0.SBRG.EC0.CMD1)) | |
{ | |
Sleep (One) | |
Local0-- | |
} | |
Local0 = ^^PCI0.SBRG.EC0.CDT3 /* \_SB_.PCI0.SBRG.EC0_.CDT3 */ | |
Local1 = ^^PCI0.SBRG.EC0.CDT2 /* \_SB_.PCI0.SBRG.EC0_.CDT2 */ | |
Local2 = ^^PCI0.SBRG.EC0.CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */ | |
Local3 = ^^PCI0.SBRG.EC0.CMD1 /* \_SB_.PCI0.SBRG.EC0_.CMD1 */ | |
Release (^^PCI0.SBRG.EC0.MUEC) | |
Local0 <<= 0x08 | |
Local0 |= Local1 | |
Local0 <<= 0x08 | |
Local0 |= Local2 | |
Local0 <<= 0x08 | |
Local0 |= Local3 | |
Return (Local0) | |
} | |
Method (CBIF, 1, Serialized) | |
{ | |
TMPB = Arg0 | |
ALPR = 0x03 | |
ISMI (0xA3) | |
Return (One) | |
} | |
Method (CFIF, 1, Serialized) | |
{ | |
TMPB = Arg0 | |
ISMI (0xA6) | |
Return (One) | |
} | |
Method (GDSP, 1, NotSerialized) | |
{ | |
If (NATK ()) | |
{ | |
If ((Arg0 == 0x80)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
If ((Arg0 == 0x02)) | |
{ | |
Return (GCDM ()) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
} | |
Return (Zero) | |
} | |
Name (CA1M, Zero) | |
Method (RMEM, 1, NotSerialized) | |
{ | |
OperationRegion (VMEM, SystemMemory, Arg0, 0x04) | |
Field (VMEM, ByteAcc, NoLock, Preserve) | |
{ | |
MEMI, 32 | |
} | |
Local0 = MEMI /* \_SB_.ATKD.RMEM.MEMI */ | |
Return (Local0) | |
} | |
Method (WMEM, 2, NotSerialized) | |
{ | |
OperationRegion (VMEM, SystemMemory, Arg0, 0x04) | |
Field (VMEM, ByteAcc, NoLock, Preserve) | |
{ | |
MEMI, 32 | |
} | |
MEMI = Arg1 | |
} | |
Name (MEMD, Package (0x41) | |
{ | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF | |
}) | |
Method (SCDG, 1, NotSerialized) | |
{ | |
CA1M = CALB /* \_SB_.CALB */ | |
If (!((ToInteger (Arg0) >= Zero) && (ToInteger ( | |
Arg0) <= 0x09))) | |
{ | |
Index (MEMD, Zero) = Zero | |
Return (MEMD) /* \_SB_.ATKD.MEMD */ | |
} | |
CA1M = (CALB + (0x0100 * ToInteger (Arg0))) | |
Local2 = Zero | |
Local3 = One | |
Local1 = CA1M /* \_SB_.ATKD.CA1M */ | |
Index (MEMD, Zero) = 0x0100 | |
While ((Local3 < 0x41)) | |
{ | |
Index (MEMD, Local3) = RMEM ((Local1 + Local2)) | |
Local2 += 0x04 | |
Local3 += One | |
} | |
Return (MEMD) /* \_SB_.ATKD.MEMD */ | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (ASHS) | |
{ | |
Name (_HID, "ATK4002") // _HID: Hardware ID | |
Method (HSWC, 1, Serialized) | |
{ | |
If ((Arg0 < 0x02)) | |
{ | |
OWGD (Arg0) | |
Return (One) | |
} | |
If ((Arg0 == 0x04)) | |
{ | |
OWGD (Zero) | |
Return (One) | |
} | |
If ((Arg0 == 0x05)) | |
{ | |
OWGD (One) | |
Return (One) | |
} | |
If ((Arg0 == 0x02)) | |
{ | |
Local0 = OWGS () | |
If (Local0) | |
{ | |
Return (0x05) | |
} | |
Else | |
{ | |
Return (0x04) | |
} | |
} | |
If ((Arg0 == 0x03)) | |
{ | |
Return (0xFF) | |
} | |
If ((Arg0 == 0x80)) | |
{ | |
Return (One) | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
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 (^^SBRG.EC0.ACAP ()) | |
} | |
Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
{ | |
PCI0 | |
}) | |
} | |
} | |
Scope (_SB.PCI0.SBRG.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 (^^SBRG.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, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0x3C, | |
0x3C, | |
"M3N", | |
" ", | |
"LIon", | |
"ASUSTeK" | |
}) | |
Name (NBIX, Package (0x14) | |
{ | |
Zero, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
One, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
Zero, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
0xFFFFFFFF, | |
"", | |
"", | |
"", | |
"" | |
}) | |
Method (FBIF, 5, NotSerialized) | |
{ | |
PUNT = Arg0 | |
Local1 = Arg1 | |
Local2 = Arg2 | |
If ((PUNT == Zero)) | |
{ | |
Local1 *= 0x0A | |
Local2 *= 0x0A | |
} | |
Index (PBIF, Zero) = Arg0 | |
Index (PBIF, One) = Local1 | |
Index (PBIF, 0x02) = Local2 | |
LFCC = Local2 | |
Index (PBIF, 0x03) = Arg3 | |
Index (PBIF, 0x04) = Arg4 | |
Divide (Local1, 0x0A, Local3, Local5) | |
Index (PBIF, 0x05) = Local5 | |
Divide (Local1, 0x64, Local3, Local6) | |
Index (PBIF, 0x06) = Local6 | |
LOW2 = Local6 | |
Divide (Local1, 0x64, Local3, Local7) | |
Index (PBIF, 0x07) = Local7 | |
Index (PBIF, 0x08) = Local7 | |
} | |
Method (CBIF, 0, NotSerialized) | |
{ | |
If (PUNT) | |
{ | |
Local0 = DerefOf (Index (PBIF, 0x04)) | |
Index (PBIF, Zero) = Zero | |
Index (PBIF, One) = (DerefOf (Index (PBIF, One)) * Local0) | |
Index (PBIF, 0x02) = (DerefOf (Index (PBIF, 0x02)) * Local0) | |
Index (PBIF, 0x05) = (DerefOf (Index (PBIF, 0x05)) * Local0) | |
Index (PBIF, 0x06) = (DerefOf (Index (PBIF, 0x06)) * Local0) | |
Index (PBIF, 0x07) = (DerefOf (Index (PBIF, 0x07)) * Local0) | |
Index (PBIF, 0x08) = (DerefOf (Index (PBIF, 0x08)) * Local0) | |
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 (!^^SBRG.EC0.BATP (Zero)) | |
{ | |
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ | |
} | |
If ((^^SBRG.EC0.GBTT (Zero) == 0xFF)) | |
{ | |
Return (NBIF) /* \_SB_.PCI0.BAT0.NBIF */ | |
} | |
BATO () | |
BATS (Zero) | |
Index (PBIF, 0x09) = ^^SBRG.EC0.BIF9 () | |
Index (PBIF, 0x0C) = ONAM /* \ONAM */ | |
Local0 = ^^SBRG.EC0.BIF0 () | |
Local1 = ^^SBRG.EC0.BIF1 () | |
Local2 = ^^SBRG.EC0.BIF2 () | |
Local3 = ^^SBRG.EC0.BIF3 () | |
Local4 = ^^SBRG.EC0.BIF4 () | |
If ((Local0 != Ones)) | |
{ | |
If ((Local1 != Ones)) | |
{ | |
If ((Local2 != Ones)) | |
{ | |
If ((Local3 != Ones)) | |
{ | |
If ((Local4 != Ones)) | |
{ | |
FBIF (Local0, Local1, Local2, Local3, Local4) | |
CBIF () | |
} | |
} | |
} | |
} | |
} | |
If ((PUNT == Zero)) | |
{ | |
Local2 *= 0x0A | |
} | |
LFCC = Local2 | |
BATR () | |
Return (PBIF) /* \_SB_.PCI0.BAT0.PBIF */ | |
} | |
Method (FBST, 4, NotSerialized) | |
{ | |
Local1 = (Arg1 & 0xFFFF) | |
Local0 = Zero | |
If (^^SBRG.EC0.ACAP ()) | |
{ | |
Local0 = One | |
} | |
If (Local0) | |
{ | |
If (CHGS (Zero)) | |
{ | |
Local0 = 0x02 | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Else | |
{ | |
Local0 = One | |
} | |
If (BLLO) | |
{ | |
Local2 = 0x04 | |
Local0 |= Local2 | |
} | |
If ((^^SBRG.EC0.EB0S & 0x08)) | |
{ | |
Local2 = 0x04 | |
Local0 |= Local2 | |
} | |
If ((Local1 >= 0x8000)) | |
{ | |
Local1 -= 0xFFFF | |
} | |
Local2 = Arg2 | |
If ((PUNT == Zero)) | |
{ | |
Local1 *= ^^SBRG.EC0.B0DV /* \_SB_.PCI0.SBRG.EC0_.B0DV */ | |
Local2 *= 0x0A | |
} | |
Local3 = (Local0 & 0x02) | |
If (!Local3) | |
{ | |
Local3 = (LFCC - Local2) | |
Divide (LFCC, 0xC8, Local4, Local5) | |
If ((Local3 < Local5)) | |
{ | |
Local2 = LFCC /* \_SB_.PCI0.BAT0.LFCC */ | |
} | |
} | |
Else | |
{ | |
Divide (LFCC, 0xC8, Local4, Local5) | |
Local4 = (LFCC - Local5) | |
If ((Local2 > Local4)) | |
{ | |
Local2 = Local4 | |
} | |
} | |
If (!^^SBRG.EC0.ACAP ()) | |
{ | |
Divide (Local2, MBLF, Local3, Local4) | |
If ((Local1 < Local4)) | |
{ | |
Local1 = Local4 | |
} | |
} | |
Index (PBST, Zero) = Local0 | |
Index (PBST, One) = Local1 | |
Index (PBST, 0x02) = Local2 | |
Index (PBST, 0x03) = Arg3 | |
} | |
Method (CBST, 0, NotSerialized) | |
{ | |
If (PUNT) | |
{ | |
Index (PBST, 0x03) = ^^SBRG.EC0.B0DV /* \_SB_.PCI0.SBRG.EC0_.B0DV */ | |
Local0 = DerefOf (Index (PBST, 0x03)) | |
Index (PBST, One) = (DerefOf (Index (PBST, One)) * Local0) | |
Divide (DerefOf (Index (PBST, One)), 0x03E8, Local1, Index (PBST, One)) | |
Index (PBST, 0x02) = (DerefOf (Index (PBST, 0x02)) * Local0) | |
Divide (DerefOf (Index (PBST, 0x02)), 0x03E8, Local1, Index (PBST, 0x02)) | |
} | |
} | |
Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
{ | |
Index (PBST, Zero) = Zero | |
Index (PBST, One) = Ones | |
Index (PBST, 0x02) = Ones | |
Index (PBST, 0x03) = Ones | |
If (!^^SBRG.EC0.BATP (Zero)) | |
{ | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
If ((^^SBRG.EC0.GBTT (Zero) == 0xFF)) | |
{ | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
If (MES4) | |
{ | |
MES4-- | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
BATO () | |
BATS (Zero) | |
Local0 = ^^SBRG.EC0.BSTS () | |
Local1 = ^^SBRG.EC0.BCRT () | |
Local2 = ^^SBRG.EC0.BRCP () | |
Local3 = ^^SBRG.EC0.BVOT () | |
If ((Local0 != Ones)) | |
{ | |
If ((Local1 != Ones)) | |
{ | |
If ((Local2 != Ones)) | |
{ | |
If ((Local3 != Ones)) | |
{ | |
FBST (Local0, Local1, Local2, Local3) | |
CBST () | |
} | |
} | |
} | |
} | |
BATR () | |
Return (PBST) /* \_SB_.PCI0.BAT0.PBST */ | |
} | |
Method (_BIX, 0, NotSerialized) // _BIX: Battery Information Extended | |
{ | |
If (!^^SBRG.EC0.BATP (Zero)) | |
{ | |
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ | |
} | |
If ((^^SBRG.EC0.GBTT (Zero) == 0xFF)) | |
{ | |
Return (NBIX) /* \_SB_.PCI0.BAT0.NBIX */ | |
} | |
_BIF () | |
Index (BIXT, One) = DerefOf (Index (PBIF, Zero)) | |
Index (BIXT, 0x02) = DerefOf (Index (PBIF, One)) | |
Index (BIXT, 0x03) = DerefOf (Index (PBIF, 0x02)) | |
Index (BIXT, 0x04) = DerefOf (Index (PBIF, 0x03)) | |
Index (BIXT, 0x05) = DerefOf (Index (PBIF, 0x04)) | |
Index (BIXT, 0x06) = DerefOf (Index (PBIF, 0x05)) | |
Index (BIXT, 0x07) = DerefOf (Index (PBIF, 0x06)) | |
Index (BIXT, 0x0E) = DerefOf (Index (PBIF, 0x07)) | |
Index (BIXT, 0x0F) = DerefOf (Index (PBIF, 0x08)) | |
Index (BIXT, 0x10) = DerefOf (Index (PBIF, 0x09)) | |
Index (BIXT, 0x11) = DerefOf (Index (PBIF, 0x0A)) | |
Index (BIXT, 0x12) = DerefOf (Index (PBIF, 0x0B)) | |
Index (BIXT, 0x13) = DerefOf (Index (PBIF, 0x0C)) | |
If ((DerefOf (Index (BIXT, One)) == One)) | |
{ | |
Index (BIXT, One) = Zero | |
Local0 = DerefOf (Index (BIXT, 0x05)) | |
Index (BIXT, 0x02) = (DerefOf (Index (BIXT, 0x02)) * Local0) | |
Index (BIXT, 0x03) = (DerefOf (Index (BIXT, 0x03)) * Local0) | |
Index (BIXT, 0x06) = (DerefOf (Index (BIXT, 0x06)) * Local0) | |
Index (BIXT, 0x07) = (DerefOf (Index (BIXT, 0x07)) * Local0) | |
Index (BIXT, 0x0E) = (DerefOf (Index (BIXT, 0x0E)) * Local0) | |
Index (BIXT, 0x0F) = (DerefOf (Index (BIXT, 0x0F)) * Local0) | |
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, 0x0E)), 0x03E8, Local0, Index (BIXT, 0x0E)) | |
Divide (DerefOf (Index (BIXT, 0x0F)), 0x03E8, Local0, Index (BIXT, 0x0F)) | |
} | |
Index (BIXT, 0x08) = ^^SBRG.EC0.B0C3 /* \_SB_.PCI0.SBRG.EC0_.B0C3 */ | |
Index (BIXT, 0x09) = 0x0001869F | |
Return (BIXT) /* \_SB_.PCI0.BAT0.BIXT */ | |
} | |
Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point | |
{ | |
^^SBRG.EC0.ST8E (0x29, 0xFF) | |
^^SBRG.EC0.ST8E (0x2A, 0xFF) | |
^^SBRG.EC0.ST8E (0x28, 0x0F) | |
If ((Arg0 != Zero)) | |
{ | |
Local0 = DerefOf (Index (PBIF, 0x04)) | |
Local1 = (Arg0 * 0x03E8) | |
Divide (Local1, Local0, Local2, Local3) | |
^^SBRG.EC0.ST9E (0x29, 0xFF, (Local3 & 0xFF)) | |
Local2 = (Local3 >> 0x08) | |
Local2 &= 0xFF | |
^^SBRG.EC0.ST9E (0x2A, 0xFF, Local2) | |
} | |
} | |
} | |
} | |
Scope (_SB.PCI0) | |
{ | |
Name (B0CR, Zero) | |
Name (B1CR, Zero) | |
Method (GGCC, 1, Serialized) | |
{ | |
BATO () | |
BATS (Arg0) | |
Local0 = ^SBRG.EC0.BCRT () | |
BATR () | |
If ((Local0 == Ones)) | |
{ | |
If (Arg0) | |
{ | |
Local0 = B1CR /* \_SB_.PCI0.B1CR */ | |
} | |
Else | |
{ | |
Local0 = B0CR /* \_SB_.PCI0.B0CR */ | |
} | |
} | |
Local1 = (Local0 & 0x8000) | |
If (Local1) | |
{ | |
Local0 = Zero | |
} | |
If (Arg0) | |
{ | |
B1CR = Local0 | |
} | |
Else | |
{ | |
B0CR = Local0 | |
} | |
Return (Local0) | |
} | |
} | |
Scope (_SB.PCI0.SBRG.EC0) | |
{ | |
Name (BADR, 0x0B) | |
Name (CADR, 0x09) | |
Name (SADR, 0x0A) | |
Method (ALMH, 1, NotSerialized) | |
{ | |
If ((Arg0 == BADR)) | |
{ | |
NBAT (0x80) | |
} | |
} | |
Method (BIFW, 1, NotSerialized) | |
{ | |
Local0 = SMBR (RDWD, BADR, Arg0) | |
Local1 = DerefOf (Index (Local0, Zero)) | |
If (Local1) | |
{ | |
Return (Ones) | |
} | |
Else | |
{ | |
Return (DerefOf (Index (Local0, 0x02))) | |
} | |
} | |
Method (BIF0, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1MD /* \_SB_.PCI0.SBRG.EC0_.B1MD */ | |
} | |
Else | |
{ | |
Local0 = B0MD /* \_SB_.PCI0.SBRG.EC0_.B0MD */ | |
} | |
If ((Local0 != 0xFFFF)) | |
{ | |
Local1 = (Local0 >> 0x0F) | |
Local1 &= One | |
Local0 = (Local1 ^ One) | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BIF1, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1DC /* \_SB_.PCI0.SBRG.EC0_.B1DC */ | |
} | |
Else | |
{ | |
Local0 = B0DC /* \_SB_.PCI0.SBRG.EC0_.B0DC */ | |
} | |
Local0 &= 0xFFFF | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BIF2, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1FC /* \_SB_.PCI0.SBRG.EC0_.B1FC */ | |
} | |
Else | |
{ | |
Local0 = B0FC /* \_SB_.PCI0.SBRG.EC0_.B0FC */ | |
} | |
Local0 &= 0xFFFF | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BIF3, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1MD /* \_SB_.PCI0.SBRG.EC0_.B1MD */ | |
} | |
Else | |
{ | |
Local0 = B0MD /* \_SB_.PCI0.SBRG.EC0_.B0MD */ | |
} | |
If ((Local0 != 0xFFFF)) | |
{ | |
Local0 >>= 0x09 | |
Local0 &= One | |
Local0 ^= One | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BIF4, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1DV /* \_SB_.PCI0.SBRG.EC0_.B1DV */ | |
} | |
Else | |
{ | |
Local0 = B0DV /* \_SB_.PCI0.SBRG.EC0_.B0DV */ | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BIF9, 0, NotSerialized) | |
{ | |
Name (BSTR, Buffer (0x20) {}) | |
Local0 = SMBR (RDBL, BADR, 0x21) | |
If ((DerefOf (Index (Local0, Zero)) != Zero)) | |
{ | |
BSTR = MNAM /* \_SB_.MNAM */ | |
Index (BSTR, 0x04) = Zero | |
} | |
Else | |
{ | |
BSTR = DerefOf (Index (Local0, 0x02)) | |
Index (BSTR, DerefOf (Index (Local0, One))) = Zero | |
} | |
Return (BSTR) /* \_SB_.PCI0.SBRG.EC0_.BIF9.BSTR */ | |
} | |
Method (BIFA, 0, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1SN /* \_SB_.PCI0.SBRG.EC0_.B1SN */ | |
} | |
Else | |
{ | |
Local0 = B0SN /* \_SB_.PCI0.SBRG.EC0_.B0SN */ | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BSTS, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1ST /* \_SB_.PCI0.SBRG.EC0_.B1ST */ | |
} | |
Else | |
{ | |
Local0 = B0ST /* \_SB_.PCI0.SBRG.EC0_.B0ST */ | |
} | |
Return (Local0) | |
} | |
Method (BCRT, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1CC /* \_SB_.PCI0.SBRG.EC0_.B1CC */ | |
} | |
Else | |
{ | |
Local0 = B0CC /* \_SB_.PCI0.SBRG.EC0_.B0CC */ | |
} | |
Return (Local0) | |
} | |
Method (BRCP, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1RC /* \_SB_.PCI0.SBRG.EC0_.B1RC */ | |
} | |
Else | |
{ | |
Local0 = B0RC /* \_SB_.PCI0.SBRG.EC0_.B0RC */ | |
} | |
If ((Local0 == 0xFFFF)) | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Method (BVOT, 0, NotSerialized) | |
{ | |
If (BSLF) | |
{ | |
Local0 = B1VL /* \_SB_.PCI0.SBRG.EC0_.B1VL */ | |
} | |
Else | |
{ | |
Local0 = B0VL /* \_SB_.PCI0.SBRG.EC0_.B0VL */ | |
} | |
Return (Local0) | |
} | |
} | |
Scope (\) | |
{ | |
Method (CHGS, 1, Serialized) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.BCHG (Arg0) | |
Return (Local0) | |
} | |
Name (BSLF, Zero) | |
Method (BATS, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
BSLF = One | |
} | |
Else | |
{ | |
BSLF = Zero | |
} | |
} | |
Mutex (MMPX, 0x00) | |
Method (BATO, 0, Serialized) | |
{ | |
Acquire (MMPX, 0xFFFF) | |
} | |
Method (BATR, 0, Serialized) | |
{ | |
Release (MMPX) | |
} | |
Name (BLLO, Zero) | |
} | |
Scope (_SB.PCI0.SBRG.EC0) | |
{ | |
Method (_QA1, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
DCPF = DCPS (Zero) | |
If (DCPF) | |
{ | |
Sleep (0x07D0) | |
} | |
Notify (BAT0, 0x80) // Status Change | |
Notify (BAT0, 0x81) // Information Change | |
} | |
Method (_QA5, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
BLLO = One | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6E) | |
} | |
Else | |
{ | |
If (BATP (Zero)) | |
{ | |
Notify (BAT0, 0x80) // Status Change | |
} | |
} | |
} | |
Method (_QA3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (BATP (Zero)) | |
{ | |
Local0 = BCLE (Zero) | |
If ((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) | |
{ | |
\_SB.PCI0.GFX0.OPTS (Arg0) | |
If ((Arg0 == 0x03)) | |
{ | |
If ((MSOS () <= OSME)) | |
{ | |
\_SB.WIDE = One | |
} | |
Else | |
{ | |
\_SB.WIDE = Zero | |
} | |
} | |
SBRS (Arg0) | |
\_SB.PCI0.SBRG.EC0.EC0S (Arg0) | |
\_SB.SLPN = Arg0 | |
DIAG ((Arg0 + 0xD0)) | |
PPRJ (Arg0) | |
\_SB.SLPT = Arg0 | |
If (Arg0) | |
{ | |
STRP (One) | |
} | |
PRJS (Arg0) | |
If ((Arg0 == 0x04)) | |
{ | |
\_SB.S4EN = One | |
} | |
Else | |
{ | |
\_SB.S4EN = Zero | |
} | |
} | |
Method (OEMW, 1, NotSerialized) | |
{ | |
\_SB.ATKD.GENW (Arg0) | |
\_SB.PCI0.GFX0.OWAK (Arg0) | |
ISMI (0x9E) | |
\_SB.SLPT = Zero | |
\_SB.PCI0.SBRG.EC0.EC0W (Arg0) | |
If ((Arg0 == 0x04)) | |
{ | |
If ((MSOS () <= OSME)) | |
{ | |
MES4 = 0x02 | |
} | |
Else | |
{ | |
MES4 = Zero | |
} | |
} | |
SBRW (Arg0) | |
If ((Arg0 == 0x04)) | |
{ | |
Notify (\_SB.SLPB, 0x02) // Device Wake | |
} | |
PRJW (Arg0) | |
DIAG ((Arg0 + 0xF0)) | |
} | |
} | |
Scope (_SB.ATKD) | |
{ | |
Method (AGFN, 1, Serialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Return (GNBF) /* \_SB_.GNBF */ | |
} | |
Local0 = Zero | |
OperationRegion (\PARM, SystemMemory, Arg0, 0x08) | |
Field (PARM, DWordAcc, NoLock, Preserve) | |
{ | |
MFUN, 16, | |
SFUN, 16, | |
LEN, 16, | |
STAS, 8, | |
EROR, 8 | |
} | |
EROR = Zero | |
STAS = One | |
If ((MFUN == 0x02)) | |
{ | |
BSMI (Arg0) | |
STAS &= 0xFE | |
} | |
Local0 = (MFUN & 0xF0) | |
If ((Local0 == 0x10)) | |
{ | |
MF1X (Arg0, LEN, MFUN, SFUN) | |
} | |
If ((MFUN == One)) | |
{ | |
GVER (Arg0, LEN) | |
STAS &= 0xFE | |
} | |
If ((MFUN == 0x30)) | |
{ | |
MF30 (Arg0, SFUN, LEN) | |
STAS &= 0xFE | |
} | |
If ((STAS == One)) | |
{ | |
EROR = One | |
STAS |= 0x02 | |
} | |
STAS &= 0xFE | |
STAS |= 0x80 | |
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 | |
} | |
Local0 = One | |
If ((Arg1 == Zero)) | |
{ | |
Local0 = G30V (Arg0, Arg2) | |
} | |
If ((Arg1 == One)) | |
{ | |
Local0 = EC01 (Arg0, Arg2) | |
} | |
If ((Arg1 == 0x02)) | |
{ | |
Local0 = EC02 (Arg0, Arg2) | |
} | |
If (Local0) | |
{ | |
EM30 = Local0 | |
SM30 |= 0x02 | |
} | |
SM30 |= 0x80 | |
Return (Zero) | |
} | |
Method (G30V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F300, SystemMemory, Arg0, Arg1) | |
Field (F300, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (EC01, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (FEC1, SystemMemory, Arg0, Arg1) | |
Field (FEC1, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ECMD, 8, | |
EDA1, 8, | |
EDA2, 8, | |
EDA3, 8, | |
EDA4, 8, | |
EDA5, 8 | |
} | |
Local0 = ^^PCI0.SBRG.EC0.ECXT (ECMD, EDA1, EDA2, EDA3, EDA4, EDA5) | |
EDA1 = DerefOf (Index (Local0, One)) | |
EDA2 = DerefOf (Index (Local0, 0x02)) | |
EDA3 = DerefOf (Index (Local0, 0x03)) | |
EDA4 = DerefOf (Index (Local0, 0x04)) | |
EDA5 = DerefOf (Index (Local0, 0x05)) | |
Return (DerefOf (Index (Local0, Zero))) | |
} | |
Method (EC02, 2, NotSerialized) | |
{ | |
If ((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 | |
} | |
Local1 = Package (0x02) | |
{ | |
Zero, | |
Buffer (0x20) {} | |
} | |
Index (Local1, Zero) = BLEN /* \_SB_.ATKD.EC02.BLEN */ | |
Index (Local1, One) = BLKK /* \_SB_.ATKD.EC02.BLKK */ | |
Local0 = ^^PCI0.SBRG.EC0.ECSB (BUSN, PROT, DADD, DREG, DAT0, DAT1, Local1) | |
If ((DerefOf (Index (Local0, Zero)) == Zero)) | |
{ | |
DAT0 = DerefOf (Index (Local0, One)) | |
DAT1 = DerefOf (Index (Local0, 0x02)) | |
BLEN = DerefOf (Index (Local0, 0x03)) | |
BLKK = DerefOf (Index (Local0, 0x04)) | |
} | |
Local2 = DerefOf (Index (Local0, Zero)) | |
Local2 &= 0x3F | |
Return (Local2) | |
} | |
Method (GENW, 1, NotSerialized) | |
{ | |
RTCW = Zero | |
} | |
Method (BSMI, 1, Serialized) | |
{ | |
BIPA = Arg0 | |
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 | |
} | |
Local0 = One | |
If ((Arg2 == 0x10)) | |
{ | |
Local0 = MF10 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x11)) | |
{ | |
Local0 = MF11 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x12)) | |
{ | |
Local0 = MF12 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x13)) | |
{ | |
Local0 = MF13 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x14)) | |
{ | |
Local0 = MF14 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x15)) | |
{ | |
Local0 = MF15 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x16)) | |
{ | |
Local0 = MF16 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x17)) | |
{ | |
Local0 = MF17 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x18)) | |
{ | |
Local0 = MF18 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x19)) | |
{ | |
Local0 = MF19 (Arg0, Arg1, Arg3) | |
} | |
If ((Arg2 == 0x1F)) | |
{ | |
Local0 = MF1F (Arg0, Arg1, Arg3) | |
} | |
SM1X &= 0xFE | |
If (Local0) | |
{ | |
EM1X = Local0 | |
SM1X |= 0x02 | |
} | |
SM1X |= 0x80 | |
} | |
Method (MF10, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G10V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = SRTC (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G10V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F100, SystemMemory, Arg0, Arg1) | |
Field (F100, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (SRTC, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F101, SystemMemory, Arg0, Arg1) | |
Field (F101, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DLTM, 16 | |
} | |
RTCW = DLTM /* \_SB_.ATKD.SRTC.DLTM */ | |
Return (Zero) | |
} | |
Method (MF11, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G11V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GBAT (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = ASBR (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Local0 = ASBE (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x04)) | |
{ | |
Local0 = BTCR (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G11V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F110, SystemMemory, Arg0, Arg1) | |
Field (F100, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GBAT, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F111, SystemMemory, Arg0, Arg1) | |
Field (F111, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BTNM, 8, | |
BTTP, 8 | |
} | |
BTNM = One | |
BTTP = Zero | |
Return (Zero) | |
} | |
Method (ASBR, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x30)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F112, SystemMemory, Arg0, Arg1) | |
Field (F112, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BATN, 8, | |
BATA, 8, | |
REGS, 8, | |
BDAT, 16, | |
BLEN, 8, | |
BREV, 16, | |
BLK1, 32, | |
BLK2, 32, | |
BLK3, 32, | |
BLK4, 32, | |
BLK5, 32, | |
BLK6, 32, | |
BLK7, 32, | |
BLK8, 32 | |
} | |
If ((BATN >= One)) | |
{ | |
Return (0x11) | |
} | |
If ((BATA == Zero)) | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.SMBR (^^PCI0.SBRG.EC0.RDWD, ^^PCI0.SBRG.EC0.BADR, REGS) | |
BDAT = DerefOf (Index (Local0, 0x02)) | |
Local2 = DerefOf (Index (Local0, Zero)) | |
Local2 &= 0x1F | |
If (Local2) | |
{ | |
Local2 += 0x10 | |
} | |
Return (Local2) | |
} | |
If ((BATA == One)) | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.SMBW (^^PCI0.SBRG.EC0.WRWD, ^^PCI0.SBRG.EC0.BADR, REGS, 0x02, BDAT) | |
Local2 = DerefOf (Index (Local0, Zero)) | |
Local2 &= 0x1F | |
If (Local2) | |
{ | |
Local2 += 0x10 | |
} | |
Return (Local2) | |
} | |
If ((BATA == 0x02)) | |
{ | |
Local0 = ^^PCI0.SBRG.EC0.SMBR (^^PCI0.SBRG.EC0.RDBL, ^^PCI0.SBRG.EC0.BADR, REGS) | |
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) | |
BKUF = DerefOf (Index (Local0, 0x02)) | |
BLK1 = DAT1 /* \_SB_.ATKD.ASBR.DAT1 */ | |
BLK2 = DAT2 /* \_SB_.ATKD.ASBR.DAT2 */ | |
BLK3 = DAT3 /* \_SB_.ATKD.ASBR.DAT3 */ | |
BLK4 = DAT4 /* \_SB_.ATKD.ASBR.DAT4 */ | |
BLK5 = DAT5 /* \_SB_.ATKD.ASBR.DAT5 */ | |
BLK6 = DAT6 /* \_SB_.ATKD.ASBR.DAT6 */ | |
BLK7 = DAT7 /* \_SB_.ATKD.ASBR.DAT7 */ | |
BLK8 = DAT8 /* \_SB_.ATKD.ASBR.DAT8 */ | |
BLEN = DerefOf (Index (Local0, One)) | |
Local2 = DerefOf (Index (Local0, Zero)) | |
Local2 &= 0x1F | |
If (Local2) | |
{ | |
Local2 += 0x10 | |
} | |
Return (Local2) | |
} | |
Return (0x10) | |
} | |
Method (ASBE, 2, Serialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F113, SystemMemory, Arg0, Arg1) | |
Field (F113, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BATN, 8, | |
BATA, 8, | |
REGS, 8, | |
BDAT, 8 | |
} | |
If ((BATN > One)) | |
{ | |
Return (0x11) | |
} | |
If ((BATA == Zero)) | |
{ | |
Local2 = ^^PCI0.SBRG.EC0.RBEP (REGS) | |
Local3 = (Local2 & 0xFF) | |
BDAT = Local3 | |
Local2 >>= 0x08 | |
Local2 &= 0x1F | |
If (Local2) | |
{ | |
Local2 += 0x10 | |
} | |
Return (Local2) | |
} | |
If ((BATA == One)) | |
{ | |
Local2 = ^^PCI0.SBRG.EC0.WBEP (REGS, BDAT) | |
Local2 &= 0x1F | |
If (Local2) | |
{ | |
Local2 += 0x10 | |
} | |
Return (Local2) | |
} | |
Return (0x10) | |
} | |
Method (BTCR, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F114, SystemMemory, Arg0, Arg1) | |
Field (F114, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BCDC, 8 | |
} | |
SBTL (BCDC) | |
Return (Zero) | |
} | |
Method (MF12, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G12V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GLDI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = LDCR (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G12V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F120, SystemMemory, Arg0, Arg1) | |
Field (F120, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GLDI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F121, SystemMemory, Arg0, Arg1) | |
Field (F121, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDI0, 32, | |
LDI1, 32 | |
} | |
Local0 = Zero | |
Local0 |= 0x10 | |
Local0 |= 0x20 | |
LDI0 = Local0 | |
Return (Zero) | |
} | |
Method (LDCR, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F122, SystemMemory, Arg0, Arg1) | |
Field (F122, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDNM, 8, | |
LCRT, 8 | |
} | |
If ((LDNM == 0x04)) | |
{ | |
WLED (LCRT) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (MF13, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G13V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GTSI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = GTSV (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Local0 = GVSN (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x04)) | |
{ | |
Local0 = GVSV (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x05)) | |
{ | |
Local0 = GFNN (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x06)) | |
{ | |
Local0 = GFNS (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x07)) | |
{ | |
Local0 = SFNS (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G13V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F130, SystemMemory, Arg0, Arg1) | |
Field (F130, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GTSI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F131, SystemMemory, Arg0, Arg1) | |
Field (F131, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
THRI, 32 | |
} | |
Local0 = Zero | |
Local0 |= One | |
If ((CPUN >= One)) | |
{ | |
Local0 |= 0x0100 | |
} | |
If ((CPUN >= 0x02)) | |
{ | |
Local0 |= 0x0200 | |
} | |
If ((CPUN >= 0x03)) | |
{ | |
Local0 |= 0x0400 | |
} | |
If ((CPUN >= 0x04)) | |
{ | |
Local0 |= 0x0800 | |
} | |
THRI = Local0 | |
Return (Zero) | |
} | |
Method (GTSV, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F132, SystemMemory, Arg0, Arg1) | |
Field (F132, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
TSNM, 8, | |
TSVL, 8, | |
TSST, 8 | |
} | |
TSST = Zero | |
If ((TSNM == Zero)) | |
{ | |
TSVL = \_TZ.RTMP () | |
Return (Zero) | |
} | |
If ((TSNM == 0x08)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If ((TSNM == 0x09)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If ((TSNM == 0x0A)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
If ((TSNM == 0x0B)) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (GVSN, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F133, SystemMemory, Arg0, Arg1) | |
Field (F133, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NMVS, 8 | |
} | |
NMVS = Zero | |
Return (Zero) | |
} | |
Method (GVSV, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0B)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F134, SystemMemory, Arg0, Arg1) | |
Field (F134, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
VSNM, 8, | |
VSVL, 16 | |
} | |
If ((VSNM > Zero)) | |
{ | |
Return (0x10) | |
} | |
Return (Zero) | |
} | |
Method (GFNN, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F135, SystemMemory, Arg0, Arg1) | |
Field (F135, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NMFN, 32 | |
} | |
NMFN = One | |
Return (Zero) | |
} | |
Method (GFNS, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0D)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F136, SystemMemory, Arg0, Arg1) | |
Field (F136, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
FNNM, 8, | |
GFNS, 32 | |
} | |
If (((FNNM == Zero) | (FNNM > One))) | |
{ | |
Return (0x10) | |
} | |
Local0 = FNNM /* \_SB_.ATKD.GFNS.FNNM */ | |
GFNS = \_TZ.RFAN (Local0--) | |
Return (Zero) | |
} | |
Method (SFNS, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F137, SystemMemory, Arg0, Arg1) | |
Field (F137, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
FNNB, 8, | |
FNSP, 8 | |
} | |
If ((FNNB > One)) | |
{ | |
Return (0x10) | |
} | |
^^PCI0.SBRG.EC0.SFNV (FNNB, FNSP) | |
Return (Zero) | |
} | |
Method (MF14, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G14V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GNBT (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = GBTS (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G14V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F140, SystemMemory, Arg0, Arg1) | |
Field (F140, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GNBT, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x09)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F141, SystemMemory, Arg0, Arg1) | |
Field (F141, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NBBT, 8 | |
} | |
NBBT = 0x05 | |
Return (Zero) | |
} | |
Method (GBTS, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F142, SystemMemory, Arg0, Arg1) | |
Field (F142, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BTNM, 8, | |
BTST, 8 | |
} | |
Name (BTTB, Package (0x05) | |
{ | |
Package (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 ((BTNM > 0x05)) | |
{ | |
Return (0x10) | |
} | |
Local0 = BTNM /* \_SB_.ATKD.GBTS.BTNM */ | |
Local0-- | |
Local1 = DerefOf (Index (BTTB, Local0)) | |
If ((DerefOf (Index (Local1, One)) == Zero)) | |
{ | |
Local2 = ^^PCI0.SBRG.EC0.RPIN (DerefOf (Index (Local1, Zero))) | |
} | |
If ((DerefOf (Index (Local1, One)) == 0x03)) {} | |
If ((DerefOf (Index (Local1, 0x02)) == Local2)) | |
{ | |
BTST = Zero | |
} | |
Else | |
{ | |
BTST = One | |
} | |
Return (Zero) | |
} | |
Method (MF15, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G15V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GLDB (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = SLDB (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Local0 = GDPI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x04)) | |
{ | |
Local0 = SODP (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G15V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F150, SystemMemory, Arg0, Arg1) | |
Field (F150, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GLDB, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F151, SystemMemory, Arg0, Arg1) | |
Field (F151, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LCDB, 8, | |
MLDB, 8 | |
} | |
LCDB = GPLV () | |
MLDB = 0x0B | |
Return (Zero) | |
} | |
Method (SLDB, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F152, SystemMemory, Arg0, Arg1) | |
Field (F152, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LCDL, 8, | |
LTPE, 8 | |
} | |
If ((LTPE == Zero)) | |
{ | |
If ((LCDL > 0x0B)) | |
{ | |
Return (0x10) | |
} | |
SPLV (LCDL) | |
Return (Zero) | |
} | |
If ((LTPE == One)) | |
{ | |
^^PCI0.SBRG.EC0.SBRV (LCDL) | |
Return (Zero) | |
} | |
Return (0x11) | |
} | |
Method (GDPI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F153, SystemMemory, Arg0, Arg1) | |
Field (F153, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ODPI, 32, | |
ODPC, 8 | |
} | |
Local0 = Zero | |
Local0 |= One | |
Local0 |= 0x02 | |
ODPI = Local0 | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (SODP, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F154, SystemMemory, Arg0, Arg1) | |
Field (F154, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ODPM, 32 | |
} | |
Local0 = Zero | |
Local0 |= One | |
Local0 |= 0x02 | |
Local0 &= ODPM | |
If ((Local0 == ODPM)) | |
{ | |
SDSP (ODPM) | |
Return (Zero) | |
} | |
Return (0x10) | |
} | |
Method (MF16, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G16V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = SFBD (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = LCMD (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G16V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F160, SystemMemory, Arg0, Arg1) | |
Field (F160, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (SFBD, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F161, SystemMemory, Arg0, Arg1) | |
Field (F161, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
NXBD, 8 | |
} | |
If (OFBD (NXBD)) | |
{ | |
UHDB = NXBD /* \_SB_.ATKD.SFBD.NXBD */ | |
Return (Zero) | |
} | |
Else | |
{ | |
Return (0x10) | |
} | |
} | |
Method (LCMD, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (MF17, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G17V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GMDL (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = GBSI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Local0 = GECI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x04)) | |
{ | |
Local0 = GFII (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G17V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F170, SystemMemory, Arg0, Arg1) | |
Field (F170, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GMDL, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x19)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F171, SystemMemory, Arg0, Arg1) | |
Field (F171, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
MLEN, 8, | |
MDL1, 32, | |
MDL2, 32, | |
MDL3, 32, | |
MDL4, 32 | |
} | |
MDL1 = Zero | |
MDL2 = Zero | |
MDL3 = Zero | |
MDL4 = Zero | |
Name (BBUF, Buffer (0x10) {}) | |
CreateDWordField (BBUF, Zero, DAT1) | |
CreateDWordField (BBUF, 0x04, DAT2) | |
CreateDWordField (BBUF, 0x08, DAT3) | |
CreateDWordField (BBUF, 0x0C, DAT4) | |
Local0 = GBMN () | |
MLEN = SizeOf (Local0) | |
BBUF = GBMN () | |
MDL1 = DAT1 /* \_SB_.ATKD.GMDL.DAT1 */ | |
MDL2 = DAT2 /* \_SB_.ATKD.GMDL.DAT2 */ | |
MDL3 = DAT3 /* \_SB_.ATKD.GMDL.DAT3 */ | |
MDL4 = DAT4 /* \_SB_.ATKD.GMDL.DAT4 */ | |
Return (Zero) | |
} | |
Method (GBSI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x19)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F172, SystemMemory, Arg0, Arg1) | |
Field (F172, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
BLEN, 8, | |
BDL1, 32, | |
BDL2, 32, | |
BDL3, 32, | |
BDL4, 32 | |
} | |
BDL1 = Zero | |
BDL2 = Zero | |
BDL3 = Zero | |
BDL4 = Zero | |
Name (BBUF, Buffer (0x10) {}) | |
CreateDWordField (BBUF, Zero, DAT1) | |
CreateDWordField (BBUF, 0x04, DAT2) | |
CreateDWordField (BBUF, 0x08, DAT3) | |
CreateDWordField (BBUF, 0x0C, DAT4) | |
Local0 = GBRV () | |
BLEN = SizeOf (Local0) | |
BBUF = GBRV () | |
BDL1 = DAT1 /* \_SB_.ATKD.GBSI.DAT1 */ | |
BDL2 = DAT2 /* \_SB_.ATKD.GBSI.DAT2 */ | |
BDL3 = DAT3 /* \_SB_.ATKD.GBSI.DAT3 */ | |
BDL4 = DAT4 /* \_SB_.ATKD.GBSI.DAT4 */ | |
Return (Zero) | |
} | |
Method (GECI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x19)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F173, SystemMemory, Arg0, Arg1) | |
Field (F173, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
ELEN, 8, | |
EDL1, 32, | |
EDL2, 32, | |
EDL3, 32, | |
EDL4, 32 | |
} | |
EDL1 = Zero | |
EDL2 = Zero | |
EDL3 = Zero | |
EDL4 = Zero | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (GFII, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x10)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F174, SystemMemory, Arg0, Arg1) | |
Field (F174, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SFII, 8 | |
} | |
SFII = BECF /* \_SB_.BECF */ | |
Return (Zero) | |
} | |
Method (MF18, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G18V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = GDVI (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = GDVS (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x03)) | |
{ | |
Local0 = SDPW (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G18V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F180, SystemMemory, Arg0, Arg1) | |
Field (F180, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (GDVI, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x18)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F181, SystemMemory, Arg0, Arg1) | |
Field (F181, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
LDI0, 32, | |
LDI1, 32 | |
} | |
LDI0 = FEBL /* \_SB_.FEBL */ | |
Return (Zero) | |
} | |
Method (GDVS, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F182, SystemMemory, Arg0, Arg1) | |
Field (F182, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DNUM, 8, | |
DSTS, 8 | |
} | |
Local0 = (One << DNUM) /* \_SB_.ATKD.GDVS.DNUM */ | |
If (((Local0 & FEBL) == Zero)) | |
{ | |
Return (0x10) | |
} | |
Return (Zero) | |
} | |
Method (SDPW, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F183, SystemMemory, Arg0, Arg1) | |
Field (F183, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
DNUM, 8, | |
DCTR, 8 | |
} | |
Local0 = (One << DNUM) /* \_SB_.ATKD.SDPW.DNUM */ | |
If (((Local0 & FEBL) == Zero)) | |
{ | |
Return (0x10) | |
} | |
If ((DCTR > One)) | |
{ | |
Return (0x11) | |
} | |
Return (Zero) | |
} | |
Method (MF19, 3, NotSerialized) | |
{ | |
Local0 = One | |
If ((Arg2 == Zero)) | |
{ | |
Local0 = G19V (Arg0, Arg1) | |
} | |
If ((Arg2 == One)) | |
{ | |
Local0 = ACMS (Arg0, Arg1) | |
} | |
If ((Arg2 == 0x02)) | |
{ | |
Local0 = CSIN (Arg0, Arg1) | |
} | |
Return (Local0) | |
} | |
Method (G19V, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0C)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F190, SystemMemory, Arg0, Arg1) | |
Field (F190, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
SVER, 16, | |
MVER, 16 | |
} | |
MVER = Zero | |
SVER = Zero | |
Return (Zero) | |
} | |
Method (ACMS, 2, NotSerialized) | |
{ | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
Method (CSIN, 2, NotSerialized) | |
{ | |
If ((Arg1 < 0x0A)) | |
{ | |
Return (0x02) | |
} | |
OperationRegion (\F192, SystemMemory, Arg0, Arg1) | |
Field (F192, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
CMAX, 16 | |
} | |
CMAX = 0xFF | |
Return (Zero) | |
} | |
Method (NVIN, 2, NotSerialized) | |
{ | |
OperationRegion (FM1F, SystemMemory, Arg0, Arg1) | |
Field (FM1F, DWordAcc, NoLock, Preserve) | |
{ | |
Offset (0x08), | |
AM1F, 32 | |
} | |
Return (ANVI (AM1F)) | |
} | |
Method (BATF, 1, NotSerialized) | |
{ | |
Local0 = GNBF /* \_SB_.GNBF */ | |
OperationRegion (FMAD, SystemMemory, Local0, 0x10) | |
Field (FMAD, DWordAcc, NoLock, Preserve) | |
{ | |
MFUN, 16, | |
SFUN, 16, | |
LEN, 16, | |
SM1X, 8, | |
EM1X, 8, | |
BATE, 8, | |
Offset (0x10) | |
} | |
MFUN = 0x1F | |
SFUN = 0x14 | |
LEN = 0x10 | |
If (Arg0) | |
{ | |
BATE = One | |
} | |
Else | |
{ | |
BATE = Zero | |
} | |
EM1X = Zero | |
SM1X = One | |
MF1X (Local0, LEN, MFUN, SFUN) | |
} | |
Method (MF1F, 3, NotSerialized) | |
{ | |
If ((Arg2 == 0x11)) | |
{ | |
Return (NVIN (Arg0, Arg1)) | |
} | |
BSMI (Arg0) | |
Return (Zero) | |
} | |
} | |
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 | |
}) | |
Local0 = Match (FBDT, MEQ, Arg0, MTR, Zero, Zero) | |
Local0++ | |
Return (Local0) | |
} | |
Method (GBRV, 0, NotSerialized) | |
{ | |
Local0 = "202" | |
Return (Local0) | |
} | |
Method (GBMN, 0, NotSerialized) | |
{ | |
Local0 = "E202SA" | |
Return (Local0) | |
} | |
Method (OGDP, 1, NotSerialized) | |
{ | |
Local0 = Arg0 | |
Local1 = 0x02 | |
Return (Local1) | |
} | |
Method (RSID, 0, NotSerialized) | |
{ | |
Return (Zero) | |
} | |
Method (OSDP, 2, NotSerialized) | |
{ | |
Local0 = Arg0 | |
Local1 = Arg1 | |
} | |
} | |
Scope (\) | |
{ | |
OperationRegion (PMIO, SystemIO, 0x0400, 0x46) | |
Field (PMIO, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x01), | |
PWBS, 1, | |
Offset (0x20), | |
, 9, | |
SBPS, 1, | |
, 3, | |
PMEB, 1, | |
Offset (0x30), | |
, 4, | |
SLPE, 1, | |
Offset (0x42), | |
, 1, | |
GPEC, 1 | |
} | |
Field (PMIO, ByteAcc, NoLock, WriteAsZeros) | |
{ | |
Offset (0x20), | |
, 4, | |
PSCI, 1, | |
SCIS, 1, | |
, 17, | |
GP23, 1 | |
} | |
OperationRegion (FDRG, SystemMemory, 0xFED03000, 0xFF) | |
Field (FDRG, ByteAcc, NoLock, Preserve) | |
{ | |
Offset (0x34), | |
FDRT, 32 | |
} | |
Method (RGPL, 3, Serialized) | |
{ | |
OperationRegion (GIRD, SystemMemory, (GBAS + (Arg0 + Arg1)), 0x04) | |
Field (GIRD, DWordAcc, NoLock, Preserve) | |
{ | |
TEMP, 32 | |
} | |
Local1 = (TEMP & One) | |
If ((Arg2 == Zero)) | |
{ | |
If ((Local1 == Zero)) | |
{ | |
Local1 = One | |
} | |
Else | |
{ | |
Local1 = Zero | |
} | |
} | |
Return ((Local1 & One)) | |
} | |
Method (SGPL, 4, Serialized) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
If ((Arg3 == Zero)) | |
{ | |
Arg3 = One | |
} | |
Else | |
{ | |
Arg3 = Zero | |
} | |
} | |
OperationRegion (GIWR, SystemMemory, (GBAS + (Arg0 + Arg1)), 0x04) | |
Field (GIWR, DWordAcc, NoLock, Preserve) | |
{ | |
TEMP, 32 | |
} | |
If ((Arg3 == One)) | |
{ | |
TEMP = (TEMP | 0x02) | |
} | |
Else | |
{ | |
If ((Arg3 == Zero)) | |
{ | |
Local0 = 0xFFFFFFFFFFFFFFFD | |
TEMP = (TEMP & Local0) | |
} | |
} | |
} | |
Method (RGPP, 1, Serialized) | |
{ | |
} | |
Method (TGPP, 1, Serialized) | |
{ | |
} | |
Method (SGPP, 2, Serialized) | |
{ | |
} | |
Name (PMEW, Zero) | |
Method (SBRS, 1, NotSerialized) | |
{ | |
CPXS () | |
} | |
Method (SBRW, 1, NotSerialized) | |
{ | |
PMEW = SBPS /* \SBPS */ | |
} | |
Method (STRP, 1, NotSerialized) | |
{ | |
If (Arg0) | |
{ | |
SLPE = One | |
} | |
Else | |
{ | |
SLPE = Zero | |
} | |
} | |
Method (HKTH, 0, Serialized) | |
{ | |
} | |
Method (CPXS, 0, NotSerialized) | |
{ | |
Local0 = Zero | |
Local1 = 0x00100000 | |
Local2 = 0x000E0060 | |
Local3 = 0x000E00DC | |
While ((Local0 < 0x04)) | |
{ | |
If (!(FDRT & Local1)) | |
{ | |
While ((\_SB.RDPE (Local2) & 0x00010000)) | |
{ | |
Local4 = (\_SB.RDPE (Local2) | 0x00010000) | |
\_SB.WDPE (Local2, Local4) | |
} | |
While ((\_SB.RDPE (Local3) & 0x80000000)) | |
{ | |
Local4 = (\_SB.RDPE (Local3) | 0x80000000) | |
\_SB.WDPE (Local3, Local4) | |
} | |
} | |
Local2 += 0x1000 | |
Local3 += 0x1000 | |
Local1 <<= One | |
Local0++ | |
} | |
While ((SBPS & One)) | |
{ | |
SBPS |= One | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Name (CNTB, Buffer (0x0E) | |
{ | |
/* 0000 */ 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* ...... */ | |
}) | |
Name (VISB, Buffer (0x0E) | |
{ | |
/* 0000 */ 0x00, 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. */ | |
}) | |
Name (PLD3, Buffer (0x14) | |
{ | |
/* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */ | |
/* 0008 */ 0x51, 0x1A, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, /* Q....... */ | |
/* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF /* .... */ | |
}) | |
Name (UPC3, Package (0x04) | |
{ | |
0xFF, | |
0x03, | |
Zero, | |
Zero | |
}) | |
Method (OUPC, 1, Serialized) | |
{ | |
Local0 = DerefOf (Index (CNTB, Arg0)) | |
Index (BUPC, Zero) = Local0 | |
} | |
Method (OPLD, 1, Serialized) | |
{ | |
Local0 = DerefOf (Index (VISB, Arg0)) | |
Local1 = DerefOf (Index (BPLD, 0x08)) | |
Local1 &= 0xFE | |
Local1 |= Local0 | |
Index (BPLD, 0x08) = Local1 | |
Local0 = DerefOf (Index (SHPB, Arg0)) | |
Local1 = DerefOf (Index (BPLD, 0x09)) | |
Local1 &= 0xC3 | |
Local1 |= Local0 | |
Index (BPLD, 0x09) = Local1 | |
} | |
} | |
Scope (_SB) | |
{ | |
Name (XCPD, Zero) | |
Name (XNPT, One) | |
Name (XCAP, 0x02) | |
Name (XDCP, 0x04) | |
Name (XDCT, 0x08) | |
Name (XDST, 0x0A) | |
Name (XLCP, 0x0C) | |
Name (XLCT, 0x10) | |
Name (XLST, 0x12) | |
Name (XSCP, 0x14) | |
Name (XSCT, 0x18) | |
Name (XSST, 0x1A) | |
Name (XRCT, 0x1C) | |
Mutex (MUTE, 0x00) | |
Method (RBPE, 1, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, One) | |
Field (PCFG, ByteAcc, NoLock, Preserve) | |
{ | |
XCFG, 8 | |
} | |
Release (MUTE) | |
Return (XCFG) /* \_SB_.RBPE.XCFG */ | |
} | |
Method (RWPE, 1, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Arg0 &= 0xFFFFFFFE | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, 0x02) | |
Field (PCFG, WordAcc, NoLock, Preserve) | |
{ | |
XCFG, 16 | |
} | |
Release (MUTE) | |
Return (XCFG) /* \_SB_.RWPE.XCFG */ | |
} | |
Method (RDPE, 1, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Arg0 &= 0xFFFFFFFC | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, 0x04) | |
Field (PCFG, DWordAcc, NoLock, Preserve) | |
{ | |
XCFG, 32 | |
} | |
Release (MUTE) | |
Return (XCFG) /* \_SB_.RDPE.XCFG */ | |
} | |
Method (WBPE, 2, NotSerialized) | |
{ | |
Acquire (MUTE, 0x0FFF) | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, One) | |
Field (PCFG, ByteAcc, NoLock, Preserve) | |
{ | |
XCFG, 8 | |
} | |
XCFG = Arg1 | |
Release (MUTE) | |
} | |
Method (WWPE, 2, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Arg0 &= 0xFFFFFFFE | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, 0x02) | |
Field (PCFG, WordAcc, NoLock, Preserve) | |
{ | |
XCFG, 16 | |
} | |
XCFG = Arg1 | |
Release (MUTE) | |
} | |
Method (WDPE, 2, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Arg0 &= 0xFFFFFFFC | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, 0x04) | |
Field (PCFG, DWordAcc, NoLock, Preserve) | |
{ | |
XCFG, 32 | |
} | |
XCFG = Arg1 | |
Release (MUTE) | |
} | |
Method (RWDP, 3, NotSerialized) | |
{ | |
Acquire (MUTE, 0x03E8) | |
Arg0 &= 0xFFFFFFFC | |
Local0 = (Arg0 + PEBS) /* \PEBS */ | |
OperationRegion (PCFG, SystemMemory, Local0, 0x04) | |
Field (PCFG, DWordAcc, NoLock, Preserve) | |
{ | |
XCFG, 32 | |
} | |
Local1 = (XCFG & Arg2) | |
XCFG = (Local1 | Arg1) | |
Release (MUTE) | |
} | |
Method (RPME, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 + 0x84) | |
Local1 = RDPE (Local0) | |
If ((Local1 == 0xFFFFFFFF)) | |
{ | |
Return (Zero) | |
} | |
Else | |
{ | |
If ((Local1 && 0x00010000)) | |
{ | |
WDPE (Local0, (Local1 & 0x00010000)) | |
Return (One) | |
} | |
Return (Zero) | |
} | |
} | |
Method (BDFR, 4, NotSerialized) | |
{ | |
Arg0 <<= 0x14 | |
Arg1 <<= 0x0F | |
Arg2 <<= 0x0C | |
Local0 = (Arg0 + Zero) | |
Local0 += Arg1 | |
Local0 += Arg2 | |
Local0 += Arg3 | |
Return (Local0) | |
} | |
} | |
Scope (_SB.PCI0.SBRG) | |
{ | |
Device (ADBG) | |
{ | |
Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
Name (_UID, 0x13) // _UID: Unique ID | |
Name (CRS1, ResourceTemplate () | |
{ | |
IO (Decode16, | |
0x0240, // Range Minimum | |
0x0240, // Range Maximum | |
0x01, // Alignment | |
0x1A, // Length | |
) | |
}) | |
OperationRegion (DBGC, SystemIO, 0x0259, 0x10) | |
Field (DBGC, ByteAcc, Lock, Preserve) | |
{ | |
DBGP, 8 | |
} | |
OperationRegion (DBPP, SystemIO, 0x0250, 0x02) | |
Field (DBPP, ByteAcc, Lock, Preserve) | |
{ | |
PPDT, 8, | |
PPST, 8 | |
} | |
OperationRegion (DB80, SystemIO, 0x80, One) | |
Field (DB80, ByteAcc, Lock, Preserve) | |
{ | |
DP80, 8 | |
} | |
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
{ | |
Return (CRS1) /* \_SB_.PCI0.SBRG.ADBG.CRS1 */ | |
} | |
Method (CALL, 0, Serialized) | |
{ | |
ISMI (0x96) | |
} | |
Method (PUTD, 1, Serialized) | |
{ | |
Local0 = ((Arg0 & 0x0F) | 0x10) | |
Local1 = ((Arg0 >> 0x04) & 0x0F) | |
Local2 = (~Local1 & 0x0F) | |
Local4 = 0x3FFF | |
PPDT = Local0 | |
Local3 = ((PPST ^ 0x80) >> 0x03) | |
While (((Local3 != 0x10) && (Local4 != Zero))) | |
{ | |
Local3 = ((PPST ^ 0x80) >> 0x03) | |
Local4-- | |
Stall (0x1E) | |
} | |
If ((Local4 == Zero)) | |
{ | |
PPDT = Zero | |
Return (Zero) | |
} | |
Local4 = 0x3FFF | |
PPDT = Local1 | |
Local3 = ((PPST ^ 0x80) >> 0x03) | |
While (((Local3 != Zero) && (Local4 != Zero))) | |
{ | |
Local3 = ((PPST ^ 0x80) >> 0x03) | |
Local4-- | |
Stall (0x1E) | |
} | |
If ((Local4 == Zero)) | |
{ | |
PPDT = Zero | |
Return (Zero) | |
} | |
PPDT = Local2 | |
Return (One) | |
} | |
Method (OUTS, 1, Serialized) | |
{ | |
If ((DBGP != 0xFF)) | |
{ | |
Local0 = (SizeOf (Arg0) + One) | |
Local1 = Zero | |
Name (BUFF, Buffer (Local0) {}) | |
BUFF = Arg0 | |
Local0 -= One | |
If ((PUTD (0x53) == Zero)) | |
{ | |
Return (Zero) | |
} | |
While ((DerefOf (Index (BUFF, Local1)) != Zero)) | |
{ | |
If ((PUTD (DerefOf (Index (BUFF, Local1))) == Zero)) | |
{ | |
PUTD (Zero) | |
Return (Zero) | |
} | |
Local1++ | |
} | |
PUTD (Zero) | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (OUTD, 1, Serialized) | |
{ | |
Name (DEC, Buffer (0x0B) | |
{ | |
"0123456789" | |
}) | |
Name (TMP, Buffer (0x0B) {}) | |
Local0 = Zero | |
Local1 = Arg0 | |
If ((Local1 == Zero)) | |
{ | |
OUTS ("0") | |
} | |
Else | |
{ | |
While ((Local1 > Zero)) | |
{ | |
Divide (Local1, 0x0A, Local2, Local1) | |
Index (TMP, Local0) = DerefOf (Index (DEC, Local2)) | |
Local0++ | |
Index (TMP, Local0) = Zero | |
} | |
Local2 = Zero | |
Local0-- | |
While ((Local2 < Local0)) | |
{ | |
Local3 = DerefOf (Index (TMP, Local2)) | |
Index (TMP, Local2) = DerefOf (Index (TMP, Local0)) | |
Index (TMP, Local0) = Local3 | |
Local2++ | |
Local0-- | |
} | |
OUTS (TMP) | |
} | |
} | |
Method (OUTH, 1, Serialized) | |
{ | |
Name (HEX, Buffer (0x11) | |
{ | |
"0123456789ABCDEF" | |
}) | |
Name (TMP, Buffer (0x0A) {}) | |
Local0 = Zero | |
Local1 = Arg0 | |
While ((Local0 < 0x08)) | |
{ | |
Local2 = (Local1 & 0x0F) | |
Index (TMP, Local0) = DerefOf (Index (HEX, Local2)) | |
Local1 >>= 0x04 | |
Local0++ | |
Index (TMP, Local0) = Zero | |
} | |
Local2 = Zero | |
Local0-- | |
While ((Local2 < Local0)) | |
{ | |
Local3 = DerefOf (Index (TMP, Local2)) | |
Index (TMP, Local2) = DerefOf (Index (TMP, Local0)) | |
Index (TMP, Local0) = Local3 | |
Local2++ | |
Local0-- | |
} | |
OUTS (TMP) | |
} | |
OperationRegion (SIO1, SystemIO, 0x0240, 0x08) | |
Field (SIO1, ByteAcc, NoLock, Preserve) | |
{ | |
SOUT, 8, | |
Offset (0x05), | |
SSAT, 8 | |
} | |
Method (THRE, 0, NotSerialized) | |
{ | |
Local0 = (SSAT & 0x20) | |
While ((Local0 == Zero)) | |
{ | |
Local0 = (SSAT & 0x20) | |
} | |
} | |
Method (OUTX, 1, NotSerialized) | |
{ | |
THRE () | |
SOUT = Arg0 | |
} | |
Method (OUTC, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x0A)) | |
{ | |
OUTX (0x0D) | |
} | |
OUTX (Arg0) | |
} | |
Method (DBGN, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 & 0x0F) | |
If ((Local0 < 0x0A)) | |
{ | |
Local0 += 0x30 | |
} | |
Else | |
{ | |
Local0 += 0x37 | |
} | |
OUTC (Local0) | |
} | |
Method (DBGB, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 >> 0x04) | |
DBGN (Local0) | |
DBGN (Arg0) | |
} | |
Method (DBGW, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 >> 0x08) | |
DBGB (Local0) | |
DBGB (Arg0) | |
} | |
Method (DBGD, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 >> 0x10) | |
DBGW (Local0) | |
DBGW (Arg0) | |
} | |
Method (DBGQ, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 >> 0x30) | |
DBGW (Local0) | |
Local0 = (Arg0 >> 0x20) | |
DBGW (Local0) | |
Local0 = (Arg0 >> 0x10) | |
DBGW (Local0) | |
DBGW (Arg0) | |
} | |
Name (DBGZ, Buffer (0x50) {}) | |
Method (GETC, 2, NotSerialized) | |
{ | |
CreateByteField (Arg0, Arg1, DBGC) | |
Return (DBGC) /* \_SB_.PCI0.SBRG.ADBG.GETC.DBGC */ | |
} | |
Method (MNIO, 1, NotSerialized) | |
{ | |
If ((ObjectType (Arg0) == One)) | |
{ | |
If ((Arg0 > 0xFFFFFFFF)) | |
{ | |
DBGQ (Arg0) | |
} | |
Else | |
{ | |
If ((Arg0 > 0xFFFF)) | |
{ | |
DBGD (Arg0) | |
} | |
Else | |
{ | |
If ((Arg0 > 0xFF)) | |
{ | |
DBGW (Arg0) | |
} | |
Else | |
{ | |
DBGB (Arg0) | |
} | |
} | |
} | |
Return (Zero) | |
} | |
If ((ObjectType (Arg0) == 0x02)) | |
{ | |
DBGZ = Arg0 | |
Local1 = Zero | |
While (One) | |
{ | |
Local0 = GETC (DBGZ, Local1) | |
If ((Local0 == Zero)) | |
{ | |
Return (Zero) | |
} | |
OUTC (Local0) | |
Local1++ | |
} | |
Return (Zero) | |
} | |
If ((ObjectType (Arg0) == 0x03)) | |
{ | |
Local0 = Zero | |
While ((Local0 < SizeOf (Arg0))) | |
{ | |
Local1 = GETC (Arg0, Local0) | |
If ((Local0 > Zero)) | |
{ | |
OUTC (0x20) | |
} | |
DBGB (Local1) | |
Local0++ | |
} | |
Return (Zero) | |
} | |
If ((ObjectType (Arg0) == 0x04)) | |
{ | |
Local0 = Zero | |
While ((Local0 < SizeOf (Arg0))) | |
{ | |
OUTC (0x20) | |
OUTC (0x20) | |
MNIO (DerefOf (Index (Arg0, Local0))) | |
OUTC (0x0A) | |
Local0++ | |
} | |
Return (Zero) | |
} | |
Return (One) | |
} | |
} | |
} | |
Scope (\) | |
{ | |
Method (MNIO, 1, NotSerialized) | |
{ | |
\_SB.PCI0.SBRG.ADBG.MNIO (Arg0) | |
} | |
} | |
Scope (_SB.PCI0.SBRG.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 | |
} | |
OperationRegion (ECAD, SystemMemory, GNBF, 0x10) | |
Field (ECAD, DWordAcc, NoLock, Preserve) | |
{ | |
MFUN, 16, | |
SFUN, 16, | |
LEN, 16, | |
STAS, 8, | |
EROR, 8, | |
CMD, 8, | |
EDA1, 8, | |
EDA2, 8, | |
EDA3, 8, | |
EDA4, 8, | |
EDA5, 8, | |
Offset (0x10) | |
} | |
Method (WEIE, 0, Serialized) | |
{ | |
EDA1 = One | |
ECAC () | |
If ((EDA1 == 0xFF)) | |
{ | |
Return (Ones) | |
} | |
Return (Zero) | |
} | |
Method (WEOF, 0, Serialized) | |
{ | |
EDA1 = 0x02 | |
ECAC () | |
If ((EDA1 == 0xFF)) | |
{ | |
Return (Ones) | |
} | |
Return (Zero) | |
} | |
Method (WEOE, 0, NotSerialized) | |
{ | |
EDA1 = 0x03 | |
ECAC () | |
If ((EDA1 == 0xFF)) | |
{ | |
Return (Ones) | |
} | |
Return (Zero) | |
} | |
Method (ST83, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x83 | |
EDA2 = Arg0 | |
ECAC () | |
Release (MU4T) | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Ones) | |
} | |
Method (ST84, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x84 | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST85, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x85 | |
EDA2 = Arg0 | |
ECAC () | |
Release (MU4T) | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Ones) | |
} | |
Method (ST86, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x86 | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST87, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x87 | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
If ((Arg0 == Zero)) | |
{ | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST8E, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x8E | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Ones) | |
} | |
Method (ST95, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x95 | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
If ((Arg0 == Zero)) | |
{ | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST98, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x98 | |
EDA2 = Arg0 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (ST9E, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x9E | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
EDA4 = Arg2 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STA8, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0xA8 | |
EDA2 = Arg0 | |
ECAC () | |
Release (MU4T) | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Ones) | |
} | |
Method (ST9F, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0x9F | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
EDA4 = Arg2 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STA9, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
CMD = 0xFF | |
EDA1 = 0xA9 | |
EDA2 = Arg0 | |
EDA3 = Arg1 | |
ECAC () | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB0, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If ((WEOE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4C = 0xB0 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4D = Arg0 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB1, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If ((WEOE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4C = 0xB1 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4D = Arg0 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (STB2, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
If ((WEOE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4C = 0xB2 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
EC4D = Arg0 | |
If ((WEIE () != Zero)) | |
{ | |
Release (MU4T) | |
Return (Ones) | |
} | |
Release (MU4T) | |
Return (Zero) | |
} | |
Return (Ones) | |
} | |
Method (GBTT, 1, Serialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Local0 = EB0T /* \_SB_.PCI0.SBRG.EC0_.EB0T */ | |
} | |
Else | |
{ | |
Local0 = EB1T /* \_SB_.PCI0.SBRG.EC0_.EB1T */ | |
} | |
Return (Local0) | |
} | |
Method (WCMD, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
CMD1 = Arg0 | |
Release (MUEC) | |
} | |
} | |
Method (DLY0, 1, Serialized) | |
{ | |
If (!ECAV ()) | |
{ | |
Return (Ones) | |
} | |
Local0 = Ones | |
Acquire (MUEC, 0xFFFF) | |
CDT1 = Arg0 | |
CDT2 = 0x6B | |
CDT3 = Zero | |
CMD1 = 0xBB | |
Local1 = 0x7F | |
While ((Local1 && CMD1)) | |
{ | |
Sleep (One) | |
Local1-- | |
} | |
If ((CMD1 == Zero)) | |
{ | |
Local0 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */ | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Method (RRAM, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
Local0 = Arg0 | |
Local1 = (Local0 & 0xFF) | |
Local0 >>= 0x08 | |
Local0 &= 0xFF | |
CMD = 0xFF | |
EDA1 = 0x80 | |
EDA2 = Local0 | |
EDA3 = Local1 | |
ECAC () | |
Release (MU4T) | |
Return (EDA1) /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
} | |
Return (Ones) | |
} | |
Method (WRAM, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
Local0 = Arg0 | |
Local1 = (Local0 & 0xFF) | |
Local0 >>= 0x08 | |
Local0 &= 0xFF | |
CMD = 0xFF | |
EDA1 = 0x81 | |
EDA2 = Local0 | |
EDA3 = Local1 | |
EDA4 = Arg1 | |
ECAC () | |
Release (MU4T) | |
Return (One) | |
} | |
Return (Ones) | |
} | |
Method (STBR, 0, Serialized) | |
{ | |
Local0 = Zero | |
Local1 = Zero | |
Local2 = Zero | |
If ((VGAF & One)) | |
{ | |
Local0 = One | |
} | |
If (Local0) | |
{ | |
Local2 = One | |
} | |
If (Local1) | |
{ | |
ISMI (0x9A) | |
} | |
Else | |
{ | |
If ((Local2 == One)) | |
{ | |
If ((MSOS () != OSEG)) | |
{ | |
If ((MSOS () < OSW8)) | |
{ | |
Local4 = BRTI /* \_SB_.BRTI */ | |
Local4 <<= 0x04 | |
Local3 = LBTN /* \_SB_.LBTN */ | |
Local3 = (Local4 + Local3) | |
^^^GFX0.AINT (One, ((DerefOf (Index (PWAC, Local3)) * 0x64) / 0xFF | |
)) | |
} | |
} | |
Else | |
{ | |
ISMI (0x9A) | |
} | |
} | |
Else | |
{ | |
If ((Local2 == Zero)) | |
{ | |
ECCB () | |
} | |
Else | |
{ | |
If ((Local2 == 0x02)) | |
{ | |
ISMI (0x9A) | |
} | |
Else | |
{ | |
} | |
} | |
} | |
} | |
} | |
Method (ECCB, 0, Serialized) | |
{ | |
If ((ACAP () || (MSOS () == OSVT))) | |
{ | |
Local0 = LBTN /* \_SB_.LBTN */ | |
} | |
Else | |
{ | |
Local0 = LBTN /* \_SB_.LBTN */ | |
} | |
Local1 = BRTI /* \_SB_.BRTI */ | |
Local1 <<= 0x04 | |
Local1 += Local0 | |
Local0 = DerefOf (Index (PWAC, Local1)) | |
SADC (Local0) | |
} | |
Method (SBRV, 1, Serialized) | |
{ | |
ST86 (Zero, Arg0) | |
} | |
Name (DECF, Zero) | |
Method (SFNV, 2, Serialized) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
If ((DECF & One)) | |
{ | |
Local0 = RRAM (0x0521) | |
Local0 |= 0x80 | |
WRAM (0x0521, Local0) | |
} | |
If ((DECF & 0x02)) | |
{ | |
Local0 = RRAM (0x0522) | |
Local0 |= 0x80 | |
WRAM (0x0522, Local0) | |
} | |
DECF = Zero | |
Return (Zero) | |
} | |
If ((Arg0 == One)) | |
{ | |
Local0 = RRAM (0x0521) | |
Local0 &= 0x7F | |
WRAM (0x0521, Local0) | |
DECF |= One | |
ST84 (Zero, Arg1) | |
Return (Zero) | |
} | |
If ((Arg0 == 0x02)) | |
{ | |
Local0 = RRAM (0x0522) | |
Local0 &= 0x7F | |
WRAM (0x0522, Local0) | |
DECF |= 0x02 | |
ST84 (One, Arg1) | |
Return (Zero) | |
} | |
Return (Zero) | |
} | |
Method (SADC, 1, Serialized) | |
{ | |
Return (ST86 (Zero, Arg0)) | |
} | |
Method (SPIN, 2, Serialized) | |
{ | |
If (Arg1) | |
{ | |
ST87 (0x20, Arg0) | |
} | |
Else | |
{ | |
ST87 (0x40, Arg0) | |
} | |
Return (One) | |
} | |
Method (RPIN, 1, Serialized) | |
{ | |
Local1 = ST87 (Zero, Arg0) | |
Return (Local1) | |
} | |
Method (RBAT, 2, Serialized) | |
{ | |
If (!ECAV ()) | |
{ | |
Return (Ones) | |
} | |
Acquire (MUEC, 0xFFFF) | |
Local0 = 0x03 | |
While (Local0) | |
{ | |
CDT2 = Arg0 | |
Local1 = Arg1 | |
Local1 <<= One | |
Local1 += 0xDA | |
CMD1 = Local1 | |
Local1 = 0x7F | |
While ((CMD1 && Local1)) | |
{ | |
Local1-- | |
Sleep (One) | |
} | |
If ((CMD1 == Zero)) | |
{ | |
Local1 = CDT1 /* \_SB_.PCI0.SBRG.EC0_.CDT1 */ | |
Local0 = Zero | |
} | |
Else | |
{ | |
Local1 = Ones | |
Local0-- | |
} | |
} | |
Release (MUEC) | |
Return (Local1) | |
Return (Ones) | |
} | |
Method (WBAT, 3, Serialized) | |
{ | |
Local3 = (Arg0 | 0x80) | |
If (!ECAV ()) | |
{ | |
Return (Ones) | |
} | |
Acquire (MUEC, 0xFFFF) | |
Local0 = 0x03 | |
While (Local0) | |
{ | |
CDT1 = Arg2 | |
CDT2 = Local3 | |
Local1 = Arg1 | |
Local1 <<= One | |
Local1 += 0xDA | |
CMD1 = Local1 | |
Local1 = 0x7F | |
While ((CMD1 && Local1)) | |
{ | |
Local1-- | |
Sleep (One) | |
} | |
} | |
Release (MUEC) | |
Return (Local1) | |
Return (Ones) | |
} | |
Method (FNCT, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
CDT2 = Arg0 | |
CDT1 = Arg1 | |
CMD1 = 0xC4 | |
Local0 = 0x7F | |
While ((Local0 && CMD1)) | |
{ | |
Sleep (One) | |
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) | |
{ | |
Local0 = UKER /* \_SB_.PCI0.SBRG.EC0_.UKER */ | |
Local1 = 0x03 | |
While ((Local0 && Local1)) | |
{ | |
Local2 = 0x23 | |
While (Local2) | |
{ | |
If (PRTC) | |
{ | |
Sleep (One) | |
Local2-- | |
} | |
Else | |
{ | |
Local2 = Zero | |
Local0 = SSTS /* \_SB_.PCI0.SBRG.EC0_.SSTS */ | |
} | |
} | |
If (Local0) | |
{ | |
PRTC = Zero | |
Local1-- | |
If (Local1) | |
{ | |
Sleep (One) | |
PRTC = Arg0 | |
} | |
} | |
} | |
Return (Local0) | |
} | |
Method (SMBR, 3, Serialized) | |
{ | |
Local0 = Package (0x03) | |
{ | |
0x07, | |
Zero, | |
Zero | |
} | |
If (!ECAV ()) | |
{ | |
Return (Local0) | |
} | |
If ((Arg0 != RDBL)) | |
{ | |
If ((Arg0 != RDWD)) | |
{ | |
If ((Arg0 != RDBT)) | |
{ | |
If ((Arg0 != RCBT)) | |
{ | |
If ((Arg0 != RDQK)) | |
{ | |
Return (Local0) | |
} | |
} | |
} | |
} | |
} | |
Acquire (MUEC, 0xFFFF) | |
Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
Local2 = Zero | |
While ((Local1 != Zero)) | |
{ | |
Stall (0x0A) | |
Local2++ | |
If ((Local2 > 0x03E8)) | |
{ | |
Index (Local0, Zero) = SBBY /* \_SB_.PCI0.SBRG.EC0_.SBBY */ | |
Local1 = Zero | |
} | |
Else | |
{ | |
Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
} | |
} | |
If ((Local2 <= 0x03E8)) | |
{ | |
Local3 = (Arg1 << One) | |
Local3 |= One | |
ADDR = Local3 | |
If ((Arg0 != RDQK)) | |
{ | |
If ((Arg0 != RCBT)) | |
{ | |
CMDB = Arg2 | |
} | |
} | |
BDAT = Zero | |
PRTC = Arg0 | |
Index (Local0, Zero) = SWTC (Arg0) | |
If ((DerefOf (Index (Local0, Zero)) == Zero)) | |
{ | |
If ((Arg0 == RDBL)) | |
{ | |
Index (Local0, One) = BCNT /* \_SB_.PCI0.SBRG.EC0_.BCNT */ | |
Index (Local0, 0x02) = BDAT /* \_SB_.PCI0.SBRG.EC0_.BDAT */ | |
} | |
If ((Arg0 == RDWD)) | |
{ | |
Index (Local0, One) = 0x02 | |
Index (Local0, 0x02) = DT2B /* \_SB_.PCI0.SBRG.EC0_.DT2B */ | |
} | |
If ((Arg0 == RDBT)) | |
{ | |
Index (Local0, One) = One | |
Index (Local0, 0x02) = DAT0 /* \_SB_.PCI0.SBRG.EC0_.DAT0 */ | |
} | |
If ((Arg0 == RCBT)) | |
{ | |
Index (Local0, One) = One | |
Index (Local0, 0x02) = DAT0 /* \_SB_.PCI0.SBRG.EC0_.DAT0 */ | |
} | |
} | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Method (SMBW, 5, Serialized) | |
{ | |
Local0 = Package (0x01) | |
{ | |
0x07 | |
} | |
If (!ECAV ()) | |
{ | |
Return (Local0) | |
} | |
If ((Arg0 != WRBL)) | |
{ | |
If ((Arg0 != WRWD)) | |
{ | |
If ((Arg0 != WRBT)) | |
{ | |
If ((Arg0 != SDBT)) | |
{ | |
If ((Arg0 != WRQK)) | |
{ | |
Return (Local0) | |
} | |
} | |
} | |
} | |
} | |
Acquire (MUEC, 0xFFFF) | |
Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
Local2 = Zero | |
While ((Local1 != Zero)) | |
{ | |
Stall (0x0A) | |
Local2++ | |
If ((Local2 > 0x03E8)) | |
{ | |
Index (Local0, Zero) = SBBY /* \_SB_.PCI0.SBRG.EC0_.SBBY */ | |
Local1 = Zero | |
} | |
Else | |
{ | |
Local1 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
} | |
} | |
If ((Local2 <= 0x03E8)) | |
{ | |
BDAT = Zero | |
Local3 = (Arg1 << One) | |
ADDR = Local3 | |
If ((Arg0 != WRQK)) | |
{ | |
If ((Arg0 != SDBT)) | |
{ | |
CMDB = Arg2 | |
} | |
} | |
If ((Arg0 == WRBL)) | |
{ | |
BCNT = Arg3 | |
BDAT = Arg4 | |
} | |
If ((Arg0 == WRWD)) | |
{ | |
DT2B = Arg4 | |
} | |
If ((Arg0 == WRBT)) | |
{ | |
DAT0 = Arg4 | |
} | |
If ((Arg0 == SDBT)) | |
{ | |
DAT0 = Arg4 | |
} | |
PRTC = Arg0 | |
Index (Local0, Zero) = SWTC (Arg0) | |
} | |
Release (MUEC) | |
Return (Local0) | |
} | |
Mutex (MUEP, 0x00) | |
Method (RBEP, 1, NotSerialized) | |
{ | |
Local1 = 0xFFFF | |
Acquire (MUEP, 0xFFFF) | |
Local3 = RRAM (0x0620) | |
Local4 = (Local3 & 0x7F) | |
WRAM (0x0620, Local4) | |
Local2 = 0x10 | |
Local1 = 0x10 | |
While (((Local1 == 0x10) & (Local2 != Zero))) | |
{ | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0635) | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0606) | |
Local0 = SMBR (RDBT, 0x50, Arg0) | |
Local1 = DerefOf (Index (Local0, Zero)) | |
Local2-- | |
} | |
WRAM (0x0620, Local3) | |
Local1 <<= 0x08 | |
Local1 |= DerefOf (Index (Local0, 0x02)) | |
Release (MUEP) | |
Return (Local1) | |
} | |
Method (WBEP, 2, NotSerialized) | |
{ | |
Local1 = 0xFFFF | |
Acquire (MUEP, 0xFFFF) | |
Local3 = RRAM (0x0620) | |
Local4 = (Local3 & 0x7F) | |
WRAM (0x0620, Local4) | |
Local2 = 0x10 | |
Local1 = 0x10 | |
While (((Local1 == 0x10) & (Local2 != Zero))) | |
{ | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0635) | |
SMBW (WRWD, BADR, Zero, 0x02, 0x0606) | |
Local0 = SMBW (WRBT, 0x50, Arg0, One, Arg1) | |
Local1 = DerefOf (Index (Local0, Zero)) | |
Local2-- | |
} | |
WRAM (0x0620, Local3) | |
Release (MUEP) | |
Return (Local1) | |
} | |
Method (ECXT, 6, NotSerialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MU4T, 0xFFFF) | |
Local0 = Package (0x06) | |
{ | |
0x10, | |
Zero, | |
Zero, | |
Zero, | |
Zero, | |
Zero | |
} | |
CMD = Arg0 | |
EDA1 = Arg1 | |
EDA2 = Arg2 | |
EDA3 = Arg3 | |
EDA4 = Arg4 | |
EDA5 = Arg5 | |
ECAC () | |
Index (Local0, Zero) = CMD /* \_SB_.PCI0.SBRG.EC0_.CMD_ */ | |
Index (Local0, One) = EDA1 /* \_SB_.PCI0.SBRG.EC0_.EDA1 */ | |
Index (Local0, 0x02) = EDA2 /* \_SB_.PCI0.SBRG.EC0_.EDA2 */ | |
Index (Local0, 0x03) = EDA3 /* \_SB_.PCI0.SBRG.EC0_.EDA3 */ | |
Index (Local0, 0x04) = EDA4 /* \_SB_.PCI0.SBRG.EC0_.EDA4 */ | |
Index (Local0, 0x05) = EDA5 /* \_SB_.PCI0.SBRG.EC0_.EDA5 */ | |
Release (MU4T) | |
Return (Local0) | |
} | |
} | |
Method (ECSB, 7, NotSerialized) | |
{ | |
Local1 = Package (0x05) | |
{ | |
0x11, | |
Zero, | |
Zero, | |
Zero, | |
Buffer (0x20) {} | |
} | |
If ((Arg0 > One)) | |
{ | |
Return (Local1) | |
} | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
If ((Arg0 == Zero)) | |
{ | |
Local0 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
} | |
Else | |
{ | |
Local0 = PRT2 /* \_SB_.PCI0.SBRG.EC0_.PRT2 */ | |
} | |
Local2 = Zero | |
While ((Local0 != Zero)) | |
{ | |
Stall (0x0A) | |
Local2++ | |
If ((Local2 > 0x03E8)) | |
{ | |
Index (Local1, Zero) = SBBY /* \_SB_.PCI0.SBRG.EC0_.SBBY */ | |
Local0 = Zero | |
} | |
Else | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Local0 = PRTC /* \_SB_.PCI0.SBRG.EC0_.PRTC */ | |
} | |
Else | |
{ | |
Local0 = PRT2 /* \_SB_.PCI0.SBRG.EC0_.PRT2 */ | |
} | |
} | |
} | |
If ((Local2 <= 0x03E8)) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
ADDR = Arg2 | |
CMDB = Arg3 | |
If (((Arg1 == 0x0A) || (Arg1 == 0x0B))) | |
{ | |
BCNT = DerefOf (Index (Arg6, Zero)) | |
BDAT = DerefOf (Index (Arg6, One)) | |
} | |
Else | |
{ | |
DAT0 = Arg4 | |
DAT1 = Arg5 | |
} | |
PRTC = Arg1 | |
} | |
Else | |
{ | |
ADD2 = Arg2 | |
CMD2 = Arg3 | |
If (((Arg1 == 0x0A) || (Arg1 == 0x0B))) | |
{ | |
BCN2 = DerefOf (Index (Arg6, Zero)) | |
BDA2 = DerefOf (Index (Arg6, One)) | |
} | |
Else | |
{ | |
DA20 = Arg4 | |
DA21 = Arg5 | |
} | |
PRT2 = Arg1 | |
} | |
Local0 = 0x7F | |
If ((Arg0 == Zero)) | |
{ | |
While (PRTC) | |
{ | |
Sleep (One) | |
Local0-- | |
} | |
} | |
Else | |
{ | |
While (PRT2) | |
{ | |
Sleep (One) | |
Local0-- | |
} | |
} | |
If (Local0) | |
{ | |
If ((Arg0 == Zero)) | |
{ | |
Local0 = SSTS /* \_SB_.PCI0.SBRG.EC0_.SSTS */ | |
Index (Local1, One) = DAT0 /* \_SB_.PCI0.SBRG.EC0_.DAT0 */ | |
Index (Local1, 0x02) = DAT1 /* \_SB_.PCI0.SBRG.EC0_.DAT1 */ | |
Index (Local1, 0x03) = BCNT /* \_SB_.PCI0.SBRG.EC0_.BCNT */ | |
Index (Local1, 0x04) = BDAT /* \_SB_.PCI0.SBRG.EC0_.BDAT */ | |
} | |
Else | |
{ | |
Local0 = SST2 /* \_SB_.PCI0.SBRG.EC0_.SST2 */ | |
Index (Local1, One) = DA20 /* \_SB_.PCI0.SBRG.EC0_.DA20 */ | |
Index (Local1, 0x02) = DA21 /* \_SB_.PCI0.SBRG.EC0_.DA21 */ | |
Index (Local1, 0x03) = BCN2 /* \_SB_.PCI0.SBRG.EC0_.BCN2 */ | |
Index (Local1, 0x04) = BDA2 /* \_SB_.PCI0.SBRG.EC0_.BDA2 */ | |
} | |
Local0 &= 0x1F | |
If (Local0) | |
{ | |
Local0 += 0x10 | |
} | |
Index (Local1, Zero) = Local0 | |
} | |
Else | |
{ | |
Index (Local1, Zero) = 0x10 | |
} | |
} | |
Release (MUEC) | |
} | |
Return (Local1) | |
} | |
Method (TPSW, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 & One) | |
If (Local0) | |
{ | |
ECXT (0xB6, 0xB8, One, One, Zero, Zero) | |
} | |
Else | |
{ | |
ECXT (0xB6, 0xB8, One, 0x02, Zero, Zero) | |
} | |
} | |
Method (TPST, 0, NotSerialized) | |
{ | |
Local0 = ECXT (0xB6, 0xB8, 0x02, Zero, Zero, Zero) | |
Local1 = DerefOf (Index (Local0, One)) | |
If ((Local1 == Zero)) | |
{ | |
Return (One) | |
} | |
Else | |
{ | |
Return (Zero) | |
} | |
} | |
Method (LBSW, 1, NotSerialized) | |
{ | |
If ((Arg0 == One)) | |
{ | |
ECXT (0xB6, 0xB9, One, Zero, Zero, Zero) | |
} | |
Else | |
{ | |
ECXT (0xB6, 0xB9, 0x02, Zero, Zero, Zero) | |
} | |
} | |
Method (LBST, 0, NotSerialized) | |
{ | |
Local0 = RRAM (0x044A) | |
Local0 &= 0x03 | |
Return (Local0) | |
} | |
Method (ECAC, 0, NotSerialized) | |
{ | |
BIPA = GNBF /* \_SB_.GNBF */ | |
MFUN = 0x30 | |
SFUN = One | |
LEN = 0x10 | |
EROR = Zero | |
STAS = One | |
ISMI (0xA1) | |
} | |
} | |
Scope (\) | |
{ | |
Name (TSP, 0x0A) | |
Name (TC1, 0x02) | |
Name (TC2, 0x0A) | |
} | |
Scope (_TZ) | |
{ | |
Method (KELV, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 & 0xFF) | |
If ((Local0 >= 0x80)) | |
{ | |
Local0 -= 0x0100 | |
Local0 *= 0x0A | |
Local0 -= 0x0AAC | |
Return (Local0) | |
} | |
Local0 *= 0x0A | |
Local0 += 0x0AAC | |
Return (Local0) | |
} | |
Method (CELC, 1, NotSerialized) | |
{ | |
Local0 = (Arg0 - 0x0AAC) | |
Divide (Local0, 0x0A, Local1, Local0) | |
Return (Local0) | |
} | |
Name (PLCY, Zero) | |
ThermalZone (THRM) | |
{ | |
Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature | |
{ | |
RCRT () | |
Return (KELV (\_SB.TCRT)) | |
} | |
Method (_TMP, 0, NotSerialized) // _TMP: Temperature | |
{ | |
Local1 = 0x05 | |
While (Local1) | |
{ | |
Local0 = RTMP () | |
If ((Local0 > \_SB.TCRT)) | |
{ | |
Local1-- | |
} | |
Else | |
{ | |
Local1 = Zero | |
} | |
} | |
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 | |
{ | |
Local0 = (TSP * 0x0A) | |
Return (Local0) | |
} | |
Method (_TC1, 0, NotSerialized) // _TC1: Thermal Constant 1 | |
{ | |
Return (TC1) /* \TC1_ */ | |
} | |
Method (_TC2, 0, NotSerialized) // _TC2: Thermal Constant 2 | |
{ | |
Return (TC2) /* \TC2_ */ | |
} | |
Method (_PSV, 0, NotSerialized) // _PSV: Passive Temperature | |
{ | |
RPSV () | |
If (PLCY) | |
{ | |
Return (KELV (\_SB.PPSV)) | |
} | |
Else | |
{ | |
Return (KELV (\_SB.TPSV)) | |
} | |
} | |
Method (_SCP, 1, NotSerialized) // _SCP: Set Cooling Policy | |
{ | |
PLCY = Zero | |
Notify (THRM, 0x81) // Thermal Trip Point Change | |
} | |
} | |
} | |
Scope (_TZ) | |
{ | |
Name (ATMP, 0x3C) | |
Name (LTMP, 0x3C) | |
Name (FANS, Zero) | |
Method (RTMP, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.SBRG.EC0.ECAV ()) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.ECPU | |
If ((Local0 < 0x80)) | |
{ | |
LTMP = Local0 | |
} | |
} | |
Return (LTMP) /* \_TZ_.LTMP */ | |
} | |
Method (RCRT, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.SBRG.EC0.ECAV ()) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.ECRT | |
If ((Local0 < 0x80)) | |
{ | |
\_SB.TCRT = Local0 | |
} | |
} | |
} | |
Method (RPSV, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.SBRG.EC0.ECAV ()) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.EPSV | |
If ((Local0 < 0x80)) | |
{ | |
\_SB.TPSV = Local0 | |
} | |
} | |
} | |
Method (RFAN, 1, NotSerialized) | |
{ | |
If (\_SB.PCI0.SBRG.EC0.ECAV ()) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.ST83 (Arg0) | |
If ((Local0 == 0xFF)) | |
{ | |
Return (Local0) | |
} | |
Local0 = \_SB.PCI0.SBRG.EC0.TACH (Arg0) | |
Divide (Local0, 0x64, Local1, Local0) | |
Local0 += One | |
If ((Local0 <= 0x3C)) | |
{ | |
FANS = Local0 | |
} | |
Else | |
{ | |
Local0 = FANS /* \_TZ_.FANS */ | |
} | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
Return (Local0) | |
} | |
Method (RFSE, 0, NotSerialized) | |
{ | |
If (\_SB.PCI0.SBRG.EC0.ECAV ()) | |
{ | |
Local1 = \_SB.PCI0.SBRG.EC0.ST83 (Zero) | |
If ((Local1 < 0x80)) | |
{ | |
If ((Local1 < 0x0A)) | |
{ | |
Local0 = Zero | |
} | |
Else | |
{ | |
Local0 = One | |
} | |
} | |
Else | |
{ | |
If ((Local1 < 0xF5)) | |
{ | |
Local0 = 0x02 | |
} | |
Else | |
{ | |
Local0 = 0x03 | |
} | |
} | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
Return (Local0) | |
} | |
Method (TCHG, 0, NotSerialized) | |
{ | |
} | |
Method (THDL, 0, NotSerialized) | |
{ | |
} | |
Method (TMSS, 1, NotSerialized) | |
{ | |
} | |
Method (TMSW, 1, NotSerialized) | |
{ | |
} | |
} | |
Scope (_SB.PCI0.SBRG.EC0) | |
{ | |
Name (PWAC, Buffer (0x40) | |
{ | |
/* 0000 */ 0x1B, 0x2E, 0x3B, 0x48, 0x55, 0x61, 0x6E, 0x7B, /* ..;HUan{ */ | |
/* 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 (BLCT, Zero) | |
Method (ACPS, 0, Serialized) | |
{ | |
Return ((GPWS () & One)) | |
} | |
Method (DCPS, 1, Serialized) | |
{ | |
Local0 = GPWS () | |
If (Arg0) | |
{ | |
Local0 &= 0x04 | |
} | |
Else | |
{ | |
Local0 &= 0x02 | |
} | |
If (Local0) | |
{ | |
Local0 = One | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
Return (Local0) | |
} | |
Method (GPWS, 0, Serialized) | |
{ | |
Local0 = EPWS /* \_SB_.PCI0.SBRG.EC0_.EPWS */ | |
Return (Local0) | |
} | |
Method (BCHG, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
If (ECAV ()) | |
{ | |
Local0 = EB1S /* \_SB_.PCI0.SBRG.EC0_.EB1S */ | |
Local0 &= 0xFF | |
If ((Local0 != 0xFF)) | |
{ | |
Local0 &= 0x02 | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
Return (Local0) | |
} | |
Else | |
{ | |
If (ECAV ()) | |
{ | |
Local0 = EB0S /* \_SB_.PCI0.SBRG.EC0_.EB0S */ | |
Local0 &= 0xFF | |
If ((Local0 != 0xFF)) | |
{ | |
Local0 &= 0x02 | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
Return (Local0) | |
} | |
} | |
Method (BCLE, 1, Serialized) | |
{ | |
If (Arg0) | |
{ | |
If (ECAV ()) | |
{ | |
Local0 = Ones | |
Local1 = EB1S /* \_SB_.PCI0.SBRG.EC0_.EB1S */ | |
Local1 &= 0xFFFF | |
If ((Local1 != 0xFFFF)) | |
{ | |
Local1 &= 0x16 | |
If ((Local1 == 0x04)) | |
{ | |
Local0 = Zero | |
} | |
Else | |
{ | |
If ((Local1 == 0x02)) | |
{ | |
Local0 = One | |
} | |
Else | |
{ | |
If ((Local1 == 0x10)) | |
{ | |
Local0 = One | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
Else | |
{ | |
If (ECAV ()) | |
{ | |
Local0 = Ones | |
Local1 = EB0S /* \_SB_.PCI0.SBRG.EC0_.EB0S */ | |
Local1 &= 0xFFFF | |
If ((Local1 != 0xFFFF)) | |
{ | |
Local1 &= 0x16 | |
If ((Local1 == 0x04)) | |
{ | |
Local0 = Zero | |
} | |
Else | |
{ | |
If ((Local1 == 0x02)) | |
{ | |
Local0 = One | |
} | |
Else | |
{ | |
If ((Local1 == 0x10)) | |
{ | |
Local0 = One | |
} | |
} | |
} | |
} | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Return (Local0) | |
} | |
} | |
Method (CHBT, 1, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Local1 = GBTT (Arg0) | |
If ((Local1 == 0xFF)) | |
{ | |
Local0 = Zero | |
} | |
Else | |
{ | |
Local0 = (Local1 & 0x10) | |
If (Local0) | |
{ | |
Local0 = One | |
} | |
} | |
} | |
Else | |
{ | |
Local0 = DCTP /* \_SB_.DCTP */ | |
} | |
Return (Local0) | |
} | |
Method (TACH, 1, Serialized) | |
{ | |
Name (_T_0, Zero) // _T_x: Emitted by ASL Compiler | |
If (ECAV ()) | |
{ | |
While (One) | |
{ | |
_T_0 = Arg0 | |
If ((_T_0 == Zero)) | |
{ | |
Local0 = TAH0 /* \_SB_.PCI0.SBRG.EC0_.TAH0 */ | |
Break | |
} | |
Else | |
{ | |
If ((_T_0 == One)) | |
{ | |
Local0 = TAH1 /* \_SB_.PCI0.SBRG.EC0_.TAH1 */ | |
Break | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Break | |
} | |
Local0 *= 0x02 | |
If ((Local0 != Zero)) | |
{ | |
Divide (0x0041CDB4, Local0, Local1, Local0) | |
Return (Local0) | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Else | |
{ | |
Return (Ones) | |
} | |
} | |
Name (HKFG, Zero) | |
Method (EC0S, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x03)) {} | |
If (((Arg0 == 0x03) || (Arg0 == 0x04))) {} | |
If ((Arg0 == 0x05)) {} | |
If ((Arg0 > 0x04)) {} | |
HKFG = HKEN /* \_SB_.PCI0.SBRG.EC0_.HKEN */ | |
} | |
Method (EC0W, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x03)) {} | |
If ((Arg0 <= 0x04)) | |
{ | |
DCPF = DCPS (Zero) | |
Local0 = ACPS () | |
If ((Local0 != ACPF)) | |
{ | |
ACPF = ACPS () | |
PNOT () | |
} | |
} | |
If (((Arg0 == 0x03) || (Arg0 == 0x04))) | |
{ | |
Local0 = RRAM (0x0449) | |
Local1 = (Local0 & 0x02) | |
If (Local1) | |
{ | |
Local0 |= One | |
WRAM (0x0449, Local0) | |
} | |
} | |
If ((Arg0 == 0x05)) {} | |
HKEN = HKFG /* \_SB_.PCI0.SBRG.EC0_.HKFG */ | |
If ((WOLO & One)) | |
{ | |
Local0 = 0x0580 | |
Local0 += Zero | |
Local1 = RRAM (Local0) | |
Local1 |= 0x05 | |
WRAM (Local0, Local1) | |
} | |
If ((DSYN & One)) | |
{ | |
ST9F (0x2B, 0x20, 0x20) | |
} | |
} | |
Name (FHKM, One) | |
Method (FHKW, 0, Serialized) | |
{ | |
While (!FHKM) | |
{ | |
Sleep (0x0A) | |
} | |
FHKM = Zero | |
} | |
Method (FHKS, 0, Serialized) | |
{ | |
FHKM = One | |
} | |
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 ((MSOS () >= OSW8)) | |
{ | |
Notify (ASHS, 0x88) // Device-Specific | |
} | |
Else | |
{ | |
If ((^^^^ATKD.WAPF & 0x04)) | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x88) | |
} | |
} | |
Else | |
{ | |
Local0 = OHWR () | |
If ((Local0 & 0x02)) | |
{ | |
If ((Local0 & One)) | |
{ | |
Local0 = One | |
} | |
Else | |
{ | |
Local0 = Zero | |
} | |
} | |
Else | |
{ | |
Local0 = One | |
} | |
If (Local0) | |
{ | |
If ((^^^^ATKD.WAPF & One)) | |
{ | |
If ((WLDP && BTDP)) | |
{ | |
Local0 = WRST /* \_SB_.WRST */ | |
Local0 |= (BRST << One) | |
Local0++ | |
If ((Local0 > 0x03)) | |
{ | |
Local0 = Zero | |
} | |
Local1 = DerefOf (Index (WBTL, Local0)) | |
If ((Local1 == Zero)) | |
{ | |
^^^^ATKD.IANE (0x74) | |
OWLD (Zero) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
} | |
If ((Local1 == One)) | |
{ | |
^^^^ATKD.IANE (0x73) | |
OWLD (One) | |
Sleep (0x0DAC) | |
OBTD (One) | |
} | |
If ((Local1 == 0x02)) | |
{ | |
^^^^ATKD.IANE (0x74) | |
OWLD (Zero) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
} | |
If ((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 ((WLDP && BTDP)) | |
{ | |
Local0 = WRST /* \_SB_.WRST */ | |
Local0 |= (BRST << One) | |
Local0++ | |
If ((Local0 > 0x03)) | |
{ | |
Local0 = Zero | |
} | |
Local1 = DerefOf (Index (WBTL, Local0)) | |
If ((Local1 == Zero)) | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
If ((Local1 == One)) | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
Sleep (0x0DAC) | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
If ((Local1 == 0x02)) | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
Sleep (0x0DAC) | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
If ((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 ((WLDP && BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
} | |
} | |
Name (WBTL, Package (0x04) | |
{ | |
Zero, | |
One, | |
0x02, | |
0x03 | |
}) | |
Method (_Q0C, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x50) | |
} | |
} | |
Method (_Q0D, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x51) | |
} | |
} | |
Name (ASBN, Zero) | |
Method (SBRN, 0, Serialized) | |
{ | |
If (^^^GFX0.PRST ()) | |
{ | |
Local0 = ^^^GFX0.GCBL (^^^GFX0.CBLV) | |
Local1 = (0x0A - Local0) | |
If ((Local1 != LBTN)) | |
{ | |
LBTN = Local1 | |
} | |
} | |
} | |
Method (_Q0E, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((MSOS () < OSW8)) | |
{ | |
SBRN () | |
} | |
If ((MSOS () >= OSVT)) | |
{ | |
Local0 = LBTN /* \_SB_.LBTN */ | |
If (^^^GFX0.PRST ()) | |
{ | |
If ((^^^GFX0.DD01._DCS () != 0x1F)) | |
{ | |
Return (Zero) | |
} | |
^^^GFX0.DWBL () | |
ASBN = One | |
} | |
ASBN = Zero | |
If (ATKP) | |
{ | |
If ((MSOS () >= OSW8)) {} | |
Else | |
{ | |
If ((Local0 > Zero)) | |
{ | |
Local0-- | |
} | |
If ((Local0 > 0x0A)) | |
{ | |
Local0 = 0x0A | |
} | |
LBTN = Local0 | |
^^^^ATKD.IANE ((Local0 + 0x20)) | |
} | |
} | |
} | |
Else | |
{ | |
If ((LBTN > Zero)) | |
{ | |
LBTN-- | |
} | |
If ((LBTN > 0x0A)) | |
{ | |
LBTN = 0x0A | |
} | |
STBR () | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE ((LBTN + 0x20)) | |
} | |
} | |
Return (Zero) | |
} | |
Method (_Q0F, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((MSOS () < OSW8)) | |
{ | |
SBRN () | |
} | |
If ((MSOS () >= OSVT)) | |
{ | |
Local0 = LBTN /* \_SB_.LBTN */ | |
If (^^^GFX0.PRST ()) | |
{ | |
If ((^^^GFX0.DD01._DCS () != 0x1F)) | |
{ | |
Return (Zero) | |
} | |
^^^GFX0.UPBL () | |
ASBN = One | |
} | |
ASBN = Zero | |
If (ATKP) | |
{ | |
If ((MSOS () >= OSW8)) {} | |
Else | |
{ | |
If ((Local0 < 0x0A)) | |
{ | |
Local0++ | |
} | |
Else | |
{ | |
Local0 = 0x0A | |
} | |
LBTN = Local0 | |
^^^^ATKD.IANE ((Local0 + 0x10)) | |
} | |
} | |
} | |
Else | |
{ | |
If ((LBTN < 0x0A)) | |
{ | |
LBTN++ | |
} | |
Else | |
{ | |
LBTN = 0x0A | |
} | |
STBR () | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE ((LBTN + 0x10)) | |
} | |
} | |
Return (Zero) | |
} | |
Method (_Q10, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((BLCT == Zero)) | |
{ | |
Local0 = One | |
Local0 = RPIN (0x37) | |
Local0 ^= One | |
SPIN (0x37, Local0) | |
If (ATKP) | |
{ | |
Local0 -= 0x34 | |
^^^^ATKD.IANE (Local0) | |
} | |
} | |
Else | |
{ | |
If ((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 ((MSOS () >= OSW8)) | |
{ | |
If ((F8FG == Zero)) | |
{ | |
F8FG = One | |
STB2 (0xE0) | |
STB2 (0x5B) | |
} | |
STB2 (0x19) | |
STB2 (0x99) | |
Return (Zero) | |
} | |
FHKW () | |
Local0 = ADVG () | |
If (NATK ()) | |
{ | |
If ((Local0 < 0x08)) | |
{ | |
Local1 = (Local0 + 0x60) | |
} | |
Else | |
{ | |
If ((Local0 < 0x10)) | |
{ | |
Local1 = (Local0 - 0x08) | |
Local1 += 0x8C | |
} | |
Else | |
{ | |
If ((Local0 < 0x20)) | |
{ | |
Local1 = (Local0 & 0x07) | |
Local1 += 0xA0 | |
} | |
Else | |
{ | |
If ((Local0 < 0x40)) | |
{ | |
While (One) | |
{ | |
_T_0 = ToInteger (Local0) | |
If ((_T_0 == 0x20)) | |
{ | |
Local1 = 0xD0 | |
} | |
Else | |
{ | |
If ((_T_0 == 0x21)) | |
{ | |
Local1 = 0xD1 | |
} | |
Else | |
{ | |
If ((_T_0 == 0x22)) | |
{ | |
Local1 = 0xD2 | |
} | |
Else | |
{ | |
If ((_T_0 == 0x24)) | |
{ | |
Local1 = 0xD3 | |
} | |
Else | |
{ | |
If ((_T_0 == 0x28)) | |
{ | |
Local1 = 0xD4 | |
} | |
Else | |
{ | |
If ((_T_0 == 0x30)) | |
{ | |
Local1 = 0xD5 | |
} | |
} | |
} | |
} | |
} | |
} | |
Break | |
} | |
} | |
} | |
} | |
} | |
If (ATKP) | |
{ | |
If ((Local1 != 0x60)) | |
{ | |
^^^^ATKD.IANE (Local1) | |
} | |
} | |
Else | |
{ | |
SWHG (Local0) | |
} | |
} | |
Else | |
{ | |
SWHG (Local0) | |
} | |
FHKS () | |
} | |
Method (_Q12, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (!(DSYN & One)) | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6B) | |
} | |
} | |
Else | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x6F) | |
} | |
} | |
} | |
Method (_Q13, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x20) | |
STB2 (0xE0) | |
STB2 (0xA0) | |
Return (Zero) | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x32) | |
} | |
Return (Zero) | |
} | |
Method (_Q14, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x2E) | |
STB2 (0xE0) | |
STB2 (0xAE) | |
Return (Zero) | |
} | |
If ((AVOL < 0x0F)) | |
{ | |
AVOL++ | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x31) | |
} | |
Return (Zero) | |
} | |
Method (_Q15, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
STB2 (0xE0) | |
STB2 (0x30) | |
STB2 (0xE0) | |
STB2 (0xB0) | |
Return (Zero) | |
} | |
If ((AVOL > Zero)) | |
{ | |
AVOL-- | |
} | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x30) | |
} | |
Return (Zero) | |
} | |
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 (_Q77, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0xB5) | |
} | |
} | |
Method (_Q78, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x84) | |
} | |
} | |
Method (_Q85, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ATKP) | |
{ | |
^^^^ATKD.IANE (0x5C) | |
} | |
} | |
Method (_Q84, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Local0 = OHWR () | |
If ((Local0 & 0x02)) | |
{ | |
If ((^^^^ATKD.WAPF & 0x04)) | |
{ | |
If (ATKP) | |
{ | |
If ((Local0 & One)) | |
{ | |
^^^^ATKD.IANE (0x80) | |
} | |
Else | |
{ | |
^^^^ATKD.IANE (0x81) | |
} | |
} | |
} | |
Else | |
{ | |
If ((^^^^ATKD.WAPF & One)) | |
{ | |
If ((Local0 & One)) | |
{ | |
If (WLDP) | |
{ | |
If ((WRPS == One)) | |
{ | |
^^^^ATKD.IANE (0x5E) | |
} | |
Else | |
{ | |
^^^^ATKD.IANE (0x5F) | |
} | |
} | |
If ((WLDP && BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
If (BRPS) | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
Else | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
WRPS = WRST /* \_SB_.WRST */ | |
^^^^ATKD.IANE (0x5F) | |
} | |
If ((WLDP && BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
BRPS = BRST /* \_SB_.BRST */ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If ((Local0 & One)) | |
{ | |
If (WLDP) | |
{ | |
If (WRPS) | |
{ | |
OWLD (One) | |
^^^^ATKD.IANE (0x5E) | |
} | |
Else | |
{ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
} | |
} | |
If ((WLDP && BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
If (BRPS) | |
{ | |
OBTD (One) | |
^^^^ATKD.IANE (0x7D) | |
} | |
Else | |
{ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
Else | |
{ | |
If (WLDP) | |
{ | |
WRPS = WRST /* \_SB_.WRST */ | |
OWLD (Zero) | |
^^^^ATKD.IANE (0x5F) | |
} | |
If ((WLDP && BTDP)) | |
{ | |
Sleep (0x0DAC) | |
} | |
If (BTDP) | |
{ | |
BRPS = BRST /* \_SB_.BRST */ | |
OBTD (Zero) | |
^^^^ATKD.IANE (0x7E) | |
} | |
} | |
} | |
} | |
} | |
} | |
Method (_QB0, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (\_TZ.THRM, 0x80) // Thermal Status Change | |
} | |
Method (_QA0, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If (ACPS ()) | |
{ | |
ACPF = One | |
Local0 = 0x58 | |
} | |
Else | |
{ | |
ACPF = Zero | |
Local0 = 0x57 | |
} | |
If ((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) | |
{ | |
SMBF = One | |
CDFG = Zero | |
} | |
If (ALFG) | |
{ | |
ALFG = Zero | |
} | |
} | |
Method (_QB3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
^^^^ATKD.IANE (0x6D) | |
} | |
Method (ECRS, 2, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
ADD2 = Arg0 | |
CMD2 = Arg1 | |
PRT2 = 0x07 | |
Local0 = 0x7F | |
While (PRT2) | |
{ | |
Sleep (One) | |
Local0-- | |
} | |
If (Local0) | |
{ | |
Local0 = DA20 /* \_SB_.PCI0.SBRG.EC0_.DA20 */ | |
} | |
Else | |
{ | |
Local0 = Ones | |
} | |
Release (MUEC) | |
} | |
Return (Local0) | |
} | |
Method (ECWS, 3, Serialized) | |
{ | |
If (ECAV ()) | |
{ | |
Acquire (MUEC, 0xFFFF) | |
ADD2 = Arg0 | |
CMD2 = Arg1 | |
DA20 = Arg2 | |
PRT2 = 0x06 | |
Local0 = 0x07FF | |
While (PRT2) | |
{ | |
Sleep (One) | |
Local0-- | |
} | |
Release (MUEC) | |
} | |
Return (Local0) | |
} | |
Method (_QAC, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Local0 = ST8E (0x28, Zero) | |
If (((Local0 & One) == One)) | |
{ | |
Notify (BAT0, 0x80) // Status Change | |
} | |
} | |
Method (_QD3, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
} | |
Method (_QD4, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
If ((F8FG == One)) | |
{ | |
F8FG = Zero | |
STB2 (0xE0) | |
STB2 (0xDB) | |
} | |
} | |
} | |
Scope (_SB) | |
{ | |
Device (LID) | |
{ | |
Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID | |
Method (_LID, 0, NotSerialized) // _LID: Lid Status | |
{ | |
Local0 = One | |
Local0 = ^^PCI0.SBRG.EC0.RPIN (0x11) | |
If ((Local0 == Ones)) | |
{ | |
Local0 = One | |
} | |
If ((VGAF & One)) | |
{ | |
^^PCI0.GFX0.CLID = One | |
} | |
Return (Local0) | |
} | |
} | |
} | |
Scope (_GPE) | |
{ | |
} | |
Scope (_SB.PCI0.SBRG.EC0) | |
{ | |
Method (_Q83, 0, NotSerialized) // _Qxx: EC Query | |
{ | |
Notify (LID, 0x80) // Status Change | |
If ((VGAF & One)) | |
{ | |
Local0 = GLID () | |
LIDS = Local0 | |
If (CondRefOf (\_SB.PCI0.GFX0.GLID)) | |
{ | |
^^^GFX0.GLID (LIDS) | |
} | |
} | |
} | |
} | |
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.ATKD) | |
{ | |
Method (FSMI, 1, NotSerialized) | |
{ | |
FSFN = Arg0 | |
Local0 = (Arg0 | 0xA0) | |
ISMI (0x90) | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
Method (FLSH, 1, NotSerialized) | |
{ | |
FSTA = Arg0 | |
FSMI (Zero) | |
} | |
Method (FINI, 1, NotSerialized) | |
{ | |
FADR = Arg0 | |
Return (FSMI (One)) | |
} | |
Method (FERS, 1, NotSerialized) | |
{ | |
FSTA = Arg0 | |
Return (FSMI (0x02)) | |
} | |
Method (FWRI, 1, NotSerialized) | |
{ | |
FADR = Arg0 | |
FSIZ = 0x1000 | |
Return ((0x1000 - FSMI (0x03))) | |
} | |
Method (FCPW, 1, NotSerialized) | |
{ | |
FADR = Arg0 | |
FSIZ = 0x1000 | |
Return (FSMI (0x0D)) | |
} | |
Method (FCPP, 0, NotSerialized) | |
{ | |
FSIZ = Zero | |
Return (FSMI (0x0D)) | |
} | |
Method (FWRP, 0, NotSerialized) | |
{ | |
FSIZ = Zero | |
Return ((0x1000 - FSMI (0x03))) | |
} | |
Method (FEBW, 1, NotSerialized) | |
{ | |
FADR = Arg0 | |
Return (FSMI (0x04)) | |
} | |
Method (FEBR, 1, NotSerialized) | |
{ | |
FADR = Arg0 | |
Return (FSMI (0x05)) | |
} | |
Method (FEDW, 0, NotSerialized) | |
{ | |
Return (FSMI (0x06)) | |
} | |
Method (ECSR, 1, NotSerialized) | |
{ | |
FSTA = Arg0 | |
Return (FSMI (0x07)) | |
} | |
Method (FLSC, 1, NotSerialized) | |
{ | |
FSTA = Arg0 | |
Return (FSMI (0x08)) | |
} | |
Method (FIME, 1, NotSerialized) | |
{ | |
FSTA = Arg0 | |
If (((Arg0 == 0x04) | (Arg0 == 0x05))) | |
{ | |
FSMI (0x09) | |
If ((Arg0 == 0x04)) | |
{ | |
ULCK = FADR /* \_SB_.FADR */ | |
} | |
FSTA = Zero | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
If ((Arg0 == 0x8000)) | |
{ | |
FSIZ = 0x1000 | |
FSMI (0x09) | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
Return (FSMI (0x09)) | |
} | |
Method (FREC, 1, NotSerialized) | |
{ | |
If ((Arg0 == 0x8000)) | |
{ | |
FSTA = Arg0 | |
FSMI (0x0A) | |
FSIZ = 0x1000 | |
Return (FSTA) /* \_SB_.FSTA */ | |
} | |
FSTA = Arg0 | |
Return (FSMI (0x0A)) | |
} | |
Name (ULCK, Zero) | |
} | |
Scope (\) | |
{ | |
Method (LIMT, 0, NotSerialized) | |
{ | |
Local0 = (\_SB.CPUP - \_SB.SLMT) | |
Return (Local0) | |
} | |
Method (NCPS, 1, Serialized) | |
{ | |
Notify (\_PR.CPU0, Arg0) | |
Notify (\_PR.CPU1, Arg0) | |
If ((\_SB.CPUN >= 0x04)) | |
{ | |
Notify (\_PR.CPU2, Arg0) | |
Notify (\_PR.CPU3, Arg0) | |
} | |
If ((\_SB.CPUN >= 0x08)) {} | |
} | |
Name (LCDB, Zero) | |
Method (PPRJ, 1, Serialized) | |
{ | |
} | |
Method (PRJS, 1, Serialized) | |
{ | |
} | |
Method (PRJW, 1, Serialized) | |
{ | |
KINI () | |
\_SB.PCI0.SBRG.EC0.STBR () | |
} | |
Method (GLID, 0, Serialized) | |
{ | |
Return (\_SB.PCI0.SBRG.EC0.RPIN (0x11)) | |
} | |
Method (TLID, 0, Serialized) | |
{ | |
} | |
Method (TGAC, 0, Serialized) | |
{ | |
} | |
Method (TGDC, 1, Serialized) | |
{ | |
} | |
Method (FCTR, 3, Serialized) | |
{ | |
} | |
Method (OWGD, 1, Serialized) | |
{ | |
} | |
Method (OWGS, 0, Serialized) | |
{ | |
Return (Zero) | |
} | |
Method (OWLD, 1, Serialized) | |
{ | |
If (\_SB.WLDP) | |
{ | |
\_SB.WRST = Arg0 | |
} | |
Arg0 ^= One | |
If (((\_SB.ATKD.WAPF && 0x05) == Zero)) {} | |
} | |
Method (OBTD, 1, Serialized) | |
{ | |
If (\_SB.BTDP) | |
{ | |
\_SB.BRST = Arg0 | |
} | |
Arg0 ^= One | |
} | |
Method (OHWS, 0, Serialized) | |
{ | |
Return (Zero) | |
} | |
Method (OHWR, 0, Serialized) | |
{ | |
Local0 = Zero | |
If ((OHWS () == Zero)) | |
{ | |
Local0 &= 0xFFFE | |
} | |
Else | |
{ | |
Local0 |= One | |
} | |
If (\_SB.PCI0.RP01.WLAN.MPDP ()) | |
{ | |
Local0 |= 0x80 | |
} | |
If (\_SB.BTDP) | |
{ | |
Local0 |= 0x0100 | |
} | |
Return (Local0) | |
} | |
Method (ORST, 0, Serialized) | |
{ | |
Local0 = Zero | |
If (\_SB.WRST) | |
{ | |
Local0 |= One | |
} | |
If (\_SB.BRST) | |
{ | |
Local0 |= 0x02 | |
} | |
Return (Local0) | |
} | |
Method (GBTL, 0, Serialized) | |
{ | |
} | |
Method (SBTL, 1, Serialized) | |
{ | |
} | |
Method (BL2C, 0, NotSerialized) | |
{ | |
Return (Zero) | |
} | |
Method (STCF, 1, Serialized) | |
{ | |
If ((Arg0 == One)) | |
{ | |
\_SB.PCI0.SBRG.EC0.FNCT (0x84, Zero) | |
} | |
} | |
Method (OTGB, 0, Serialized) | |
{ | |
Local0 = One | |
Return (Local0) | |
} | |
Method (DCPS, 1, Serialized) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.RPIN (0x26) | |
Local0 ^= One | |
Return (Local0) | |
} | |
Method (ACPS, 0, Serialized) | |
{ | |
Local0 = \_SB.PCI0.SBRG.EC0.RPIN (0x10) | |
Local0 ^= One | |
Return (Local0) | |
} | |
Method (KINI, 0, Serialized) | |
{ | |
If ((MSOS () >= OSW8)) | |
{ | |
\_SB.PCI0.SBRG.EC0.STB1 (0x02) | |
\_SB.PCI0.SBRG.EC0.STB1 (0x04) | |
\_SB.FNIV = Zero | |
} | |
Else | |
{ | |
\_SB.PCI0.SBRG.EC0.STB1 (0x02) | |
\_SB.PCI0.SBRG.EC0.STB1 (0x03) | |
\_SB.FNIV = Zero | |
} | |
} | |
} | |
Scope (_GPE) | |
{ | |
} | |
Scope (_SB.PCI0.SBRG.EC0) | |
{ | |
} | |
Scope (_SB.PCI0.XHC1.RHUB.SS05) | |
{ | |
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.XHC1.RHUB.SS05.CAPD */ | |
} | |
} | |
} | |
Scope (_SB.PCI0.SBRG) | |
{ | |
Device (PS2K) | |
{ | |
Name (_HID, EisaId ("ATK3001")) // _HID: Hardware ID | |
Name (_CID, EisaId ("PNP030B")) // _CID: Compatible ID | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((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 () | |
}) | |
} | |
} | |
Scope (_SB.PCI0.I2C4) | |
{ | |
Device (ITPD) | |
{ | |
Name (_ADR, One) // _ADR: Address | |
Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
{ | |
If (ELAN) | |
{ | |
Return ("ELAN1000") | |
} | |
If (FOLT) | |
{ | |
Return ("FTE1000") | |
} | |
Return ("ELAN1010") | |
} | |
Name (_CID, "PNP0C50" /* HID Protocol Device (I2C bus) */) // _CID: Compatible ID | |
Name (_UID, One) // _UID: Unique ID | |
Name (_S0W, 0x03) // _S0W: S0 Device Wake State | |
Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
{ | |
If ((Arg0 == ToUUID ("3cdff6f7-4267-4555-ad05-b30a3d8938de") /* HID I2C Device */)) | |
{ | |
If ((Arg2 == Zero)) | |
{ | |
If ((Arg1 == One)) | |
{ | |
Return (Buffer (One) | |
{ | |
0x03 /* . */ | |
}) | |
} | |
Else | |
{ | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
If ((Arg2 == One)) | |
{ | |
Return (One) | |
} | |
} | |
Else | |
{ | |
Return (Buffer (One) | |
{ | |
0x00 /* . */ | |
}) | |
} | |
} | |
Method (_STA, 0, NotSerialized) // _STA: Status | |
{ | |
If ((DSYN & One)) | |
{ | |
Return (Zero) | |
} | |
Return (0x0F) | |
} | |
Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
{ | |
Name (SBFI, ResourceTemplate () | |
{ | |
I2cSerialBus (0x0015, ControllerInitiated, 0x00061A80, | |
AddressingMode7Bit, "\\_SB.PCI0.I2C4", | |
0x00, ResourceConsumer, , | |
) | |
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000, | |
"\\_SB.GPO1", 0x00, ResourceConsumer, , | |
) | |
{ // Pin list | |
0x0015 | |
} | |
}) | |
Return (SBFI) /* \_SB_.PCI0.I2C4.ITPD._CRS.SBFI */ | |
} | |
} | |
} | |
Scope (_SB.PCI0.RP01) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP01.PXSX) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP02) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP02.PXSX) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP03) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP03.PXSX) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP04) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
Scope (_SB.PCI0.RP04.PXSX) | |
{ | |
Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
{ | |
Return (GPRW (0x09, 0x04)) | |
} | |
} | |
} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment