Created
February 18, 2020 16:05
-
-
Save macromorgan/640addff8577ec732efcb610ee0a00a6 to your computer and use it in GitHub Desktop.
DSDT Comparison Between Stock T440P w/ dGPU and Coreboot
This file contains hidden or 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 20180105 (64-bit version) | |
| * Copyright (c) 2000 - 2018 Intel Corporation | |
| * | |
| * Disassembling to symbolic ASL+ operators | |
| * | |
| * Disassembly of dsdt.dat, Wed Feb 12 10:49:16 2020 | |
| * | |
| * Original Table Header: | |
| * Signature "DSDT" | |
| * Length 0x00003839 (14393) | |
| * Revision 0x02 | |
| * Checksum 0x30 | |
| * OEM ID "COREv4" | |
| * OEM Table ID "COREBOOT" | |
| * OEM Revision 0x20141018 (538185752) | |
| * Compiler ID "INTL" | |
| * Compiler Version 0x20190703 (538511107) | |
| */ | |
| DefinitionBlock ("", "DSDT", 2, "COREv4", "COREBOOT", 0x20141018) | |
| { | |
| External (_PR_.CNOT, MethodObj) // 1 Arguments | |
| External (_PR_.CP00._PSS, UnknownObj) | |
| External (_SB_.PCI0.GFX0.LCD0, DeviceObj) | |
| External (_TZ_.SKIN, UnknownObj) | |
| External (HBDC, IntObj) | |
| External (HKBL, IntObj) | |
| External (HUWB, IntObj) | |
| External (HWAN, IntObj) | |
| External (NVSA, UnknownObj) | |
| External (PPKG, MethodObj) // 0 Arguments | |
| Scope (\) | |
| { | |
| Name (NVSA, 0x7CF84000) | |
| } | |
| Method (_WAK, 1, NotSerialized) // _WAK: Wake | |
| { | |
| \_TZ.MEB1 = Zero | |
| \_TZ.MEB2 = Zero | |
| Return (Package (0x02) | |
| { | |
| Zero, | |
| Zero | |
| }) | |
| } | |
| Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep | |
| { | |
| \_SB.PCI0.LPCB.EC.RADI (Zero) | |
| } | |
| Method (PNOT, 0, NotSerialized) | |
| { | |
| \_PR.CNOT (0x81) | |
| } | |
| Method (PPCN, 0, NotSerialized) | |
| { | |
| \_PR.CNOT (0x80) | |
| } | |
| Method (TNOT, 0, NotSerialized) | |
| { | |
| \_PR.CNOT (0x82) | |
| } | |
| OperationRegion (APMP, SystemIO, 0xB2, 0x02) | |
| Field (APMP, ByteAcc, NoLock, Preserve) | |
| { | |
| APMC, 8, | |
| APMS, 8 | |
| } | |
| OperationRegion (POST, SystemIO, 0x80, One) | |
| Field (POST, ByteAcc, Lock, Preserve) | |
| { | |
| DBG0, 8 | |
| } | |
| Method (TRAP, 1, Serialized) | |
| { | |
| SMIF = Arg0 | |
| TRP0 = Zero | |
| Return (SMIF) /* \SMIF */ | |
| } | |
| Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model | |
| { | |
| PICM = Arg0 | |
| } | |
| Method (GOS, 0, NotSerialized) | |
| { | |
| OSYS = 0x07D0 | |
| If (CondRefOf (_OSI)) | |
| { | |
| If (_OSI ("Windows 2001")) | |
| { | |
| OSYS = 0x07D1 | |
| } | |
| If (_OSI ("Windows 2001 SP1")) | |
| { | |
| OSYS = 0x07D1 | |
| } | |
| If (_OSI ("Windows 2001.1")) | |
| { | |
| OSYS = 0x07D1 | |
| } | |
| If (_OSI ("Windows 2001.1 SP1")) | |
| { | |
| OSYS = 0x07D1 | |
| } | |
| If (_OSI ("Windows 2001 SP2")) | |
| { | |
| OSYS = 0x07D2 | |
| } | |
| If (_OSI ("Windows 2006")) | |
| { | |
| OSYS = 0x07D6 | |
| } | |
| If (_OSI ("Windows 2006 SP1")) | |
| { | |
| OSYS = 0x07D6 | |
| } | |
| If (_OSI ("Windows 2006.1")) | |
| { | |
| OSYS = 0x07D6 | |
| } | |
| If (_OSI ("Windows 2009")) | |
| { | |
| OSYS = 0x07D9 | |
| } | |
| If (_OSI ("Windows 2012")) | |
| { | |
| OSYS = 0x07DC | |
| } | |
| } | |
| } | |
| Name (PICM, Zero) | |
| Name (DSEN, One) | |
| OperationRegion (GNVS, SystemMemory, NVSA, 0x0F00) | |
| Field (GNVS, ByteAcc, NoLock, Preserve) | |
| { | |
| OSYS, 16, | |
| SMIF, 8, | |
| PRM0, 8, | |
| PRM1, 8, | |
| SCIF, 8, | |
| PRM2, 8, | |
| PRM3, 8, | |
| LCKF, 8, | |
| PRM4, 8, | |
| PRM5, 8, | |
| P80D, 32, | |
| LIDS, 8, | |
| PWRS, 8, | |
| TLVL, 8, | |
| FLVL, 8, | |
| TCRT, 8, | |
| TPSV, 8, | |
| TMAX, 8, | |
| F0OF, 8, | |
| F0ON, 8, | |
| F0PW, 8, | |
| F1OF, 8, | |
| F1ON, 8, | |
| F1PW, 8, | |
| F2OF, 8, | |
| F2ON, 8, | |
| F2PW, 8, | |
| F3OF, 8, | |
| F3ON, 8, | |
| F3PW, 8, | |
| F4OF, 8, | |
| F4ON, 8, | |
| F4PW, 8, | |
| TMPS, 8, | |
| Offset (0x28), | |
| APIC, 8, | |
| MPEN, 8, | |
| PCP0, 8, | |
| PCP1, 8, | |
| PPCM, 8, | |
| PCNT, 8, | |
| Offset (0x32), | |
| NATP, 8, | |
| S5U0, 8, | |
| S5U1, 8, | |
| S3U0, 8, | |
| S3U1, 8, | |
| S33G, 8, | |
| CMEM, 32, | |
| IGDS, 8, | |
| TLST, 8, | |
| CADL, 8, | |
| PADL, 8, | |
| CSTE, 16, | |
| NSTE, 16, | |
| SSTE, 16, | |
| NDID, 8, | |
| DID1, 32, | |
| DID2, 32, | |
| DID3, 32, | |
| DID4, 32, | |
| DID5, 32, | |
| TPMP, 8, | |
| TPME, 8, | |
| Offset (0x60), | |
| S0B0, 32, | |
| S1B0, 32, | |
| S2B0, 32, | |
| S3B0, 32, | |
| S4B0, 32, | |
| S5B0, 32, | |
| S6B0, 32, | |
| S7B0, 32, | |
| S0B1, 32, | |
| S1B1, 32, | |
| S2B1, 32, | |
| S3B1, 32, | |
| S4B1, 32, | |
| S5B1, 32, | |
| S6B1, 32, | |
| S7B1, 32, | |
| CBMC, 32, | |
| Offset (0xB4), | |
| ASLB, 32, | |
| IBTT, 8, | |
| IPAT, 8, | |
| ITVF, 8, | |
| ITVM, 8, | |
| IPSC, 8, | |
| IBLC, 8, | |
| IBIA, 8, | |
| ISSC, 8, | |
| I409, 8, | |
| I509, 8, | |
| I609, 8, | |
| I709, 8, | |
| IDMM, 8, | |
| IDMS, 8, | |
| IF1E, 8, | |
| HVCO, 8, | |
| NXD1, 32, | |
| NXD2, 32, | |
| NXD3, 32, | |
| NXD4, 32, | |
| NXD5, 32, | |
| NXD6, 32, | |
| NXD7, 32, | |
| NXD8, 32, | |
| ISCI, 8, | |
| PAVP, 8, | |
| Offset (0xEB), | |
| OSCC, 8, | |
| NPCE, 8, | |
| PLFL, 8, | |
| BREV, 8, | |
| DPBM, 8, | |
| DPCM, 8, | |
| DPDM, 8, | |
| ALFP, 8, | |
| IMON, 8, | |
| MMIO, 8, | |
| Offset (0x100), | |
| VBT0, 32, | |
| VBT1, 32, | |
| VBT2, 32, | |
| VBT3, 16, | |
| VBT4, 2048, | |
| VBT5, 512, | |
| VBT6, 512, | |
| VBT7, 32, | |
| VBT8, 32, | |
| VBT9, 32, | |
| CHVD, 24576, | |
| VBTA, 32, | |
| MEHH, 256, | |
| RMOB, 32, | |
| RMOL, 32, | |
| ROVP, 32, | |
| ROVL, 32, | |
| RWVP, 32, | |
| RWVL, 32 | |
| } | |
| Method (S3UE, 0, NotSerialized) | |
| { | |
| S3U0 = One | |
| S3U1 = One | |
| } | |
| Method (S3UD, 0, NotSerialized) | |
| { | |
| S3U0 = Zero | |
| S3U1 = Zero | |
| } | |
| Method (S5UE, 0, NotSerialized) | |
| { | |
| S5U0 = One | |
| S5U1 = One | |
| } | |
| Method (S5UD, 0, NotSerialized) | |
| { | |
| S5U0 = Zero | |
| S5U1 = Zero | |
| } | |
| Method (S3GE, 0, NotSerialized) | |
| { | |
| S33G = One | |
| } | |
| Method (S3GD, 0, NotSerialized) | |
| { | |
| S33G = Zero | |
| } | |
| Method (TZUP, 0, NotSerialized) | |
| { | |
| If (CondRefOf (\_TZ.SKIN)) | |
| { | |
| Notify (\_TZ.SKIN, 0x81) // Information Change | |
| } | |
| } | |
| Method (F0UT, 2, NotSerialized) | |
| { | |
| F0OF = Arg0 | |
| F0ON = Arg1 | |
| TZUP () | |
| } | |
| Method (F1UT, 2, NotSerialized) | |
| { | |
| F1OF = Arg0 | |
| F1ON = Arg1 | |
| TZUP () | |
| } | |
| Method (F2UT, 2, NotSerialized) | |
| { | |
| F2OF = Arg0 | |
| F2ON = Arg1 | |
| TZUP () | |
| } | |
| Method (F3UT, 2, NotSerialized) | |
| { | |
| F3OF = Arg0 | |
| F3ON = Arg1 | |
| TZUP () | |
| } | |
| Method (F4UT, 2, NotSerialized) | |
| { | |
| F4OF = Arg0 | |
| F4ON = Arg1 | |
| TZUP () | |
| } | |
| Method (TMPU, 1, NotSerialized) | |
| { | |
| TMPS = Arg0 | |
| TZUP () | |
| } | |
| 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 | |
| }) | |
| Device (_SB.PCI0) | |
| { | |
| Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID | |
| Name (_BBN, Zero) // _BBN: BIOS Bus Number | |
| Device (MCHC) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| OperationRegion (MCHP, PCI_Config, Zero, 0x0100) | |
| Field (MCHP, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x40), | |
| EPEN, 1, | |
| , 11, | |
| EPBR, 24, | |
| Offset (0x48), | |
| MHEN, 1, | |
| , 13, | |
| MHBR, 22, | |
| Offset (0x54), | |
| DVEN, 32, | |
| Offset (0x60), | |
| PXEN, 1, | |
| PXSZ, 2, | |
| , 23, | |
| PXBR, 10, | |
| Offset (0x68), | |
| DMEN, 1, | |
| , 11, | |
| DMBR, 24, | |
| Offset (0x70), | |
| MEBA, 64, | |
| Offset (0x80), | |
| , 4, | |
| PM0H, 2, | |
| Offset (0x81), | |
| PM1L, 2, | |
| , 2, | |
| PM1H, 2, | |
| Offset (0x82), | |
| PM2L, 2, | |
| , 2, | |
| PM2H, 2, | |
| Offset (0x83), | |
| PM3L, 2, | |
| , 2, | |
| PM3H, 2, | |
| Offset (0x84), | |
| PM4L, 2, | |
| , 2, | |
| PM4H, 2, | |
| Offset (0x85), | |
| PM5L, 2, | |
| , 2, | |
| PM5H, 2, | |
| Offset (0x86), | |
| PM6L, 2, | |
| , 2, | |
| PM6H, 2, | |
| Offset (0x87), | |
| Offset (0xA0), | |
| TOM, 64, | |
| Offset (0xBC), | |
| TLUD, 32 | |
| } | |
| Mutex (CTCM, 0x01) | |
| Name (CTCC, Zero) | |
| Name (CTCN, Zero) | |
| Name (CTCD, One) | |
| Name (CTCU, 0x02) | |
| Name (SPL1, Zero) | |
| OperationRegion (MCHB, SystemMemory, 0xFED15000, 0x1000) | |
| Field (MCHB, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x930), | |
| CTDN, 15, | |
| Offset (0x938), | |
| PUNI, 4, | |
| Offset (0x939), | |
| EUNI, 5, | |
| Offset (0x93A), | |
| TUNI, 4, | |
| Offset (0x958), | |
| Offset (0x95D), | |
| LFM, 8, | |
| Offset (0x9A0), | |
| PL1V, 15, | |
| PL1E, 1, | |
| PL1C, 1, | |
| PL1T, 7, | |
| Offset (0x9A4), | |
| PL2V, 15, | |
| PL2E, 1, | |
| PL2C, 1, | |
| PL2T, 7, | |
| Offset (0xF3C), | |
| TARN, 8, | |
| Offset (0xF40), | |
| CTDD, 15, | |
| Offset (0xF42), | |
| TARD, 8, | |
| Offset (0xF48), | |
| CTDU, 15, | |
| Offset (0xF4A), | |
| TARU, 8, | |
| Offset (0xF50), | |
| CTCS, 2, | |
| Offset (0xF54), | |
| TARS, 8 | |
| } | |
| Method (PSSS, 1, NotSerialized) | |
| { | |
| Local0 = One | |
| Local1 = SizeOf (\_PR.CP00._PSS) | |
| While ((Local0 < Local1)) | |
| { | |
| Local2 = (DerefOf (DerefOf (\_PR.CP00._PSS [Local0]) [0x04]) >> 0x08) | |
| If ((Local2 == Arg0)) | |
| { | |
| Return ((Local0 - One)) | |
| } | |
| Local0++ | |
| } | |
| Return (Zero) | |
| } | |
| Method (CPL2, 1, NotSerialized) | |
| { | |
| If (ISLP ()) | |
| { | |
| Return (0xC8) | |
| } | |
| Else | |
| { | |
| Return (((Arg0 * 0x7D) / 0x64)) | |
| } | |
| } | |
| Method (STND, 0, Serialized) | |
| { | |
| If (Acquire (CTCM, 0x0064)) | |
| { | |
| Return (Zero) | |
| } | |
| If ((CTCD == CTCC)) | |
| { | |
| Release (CTCM) | |
| Return (Zero) | |
| } | |
| Debug = "Set TDP Down" | |
| CTCS = CTCD /* \_SB_.PCI0.MCHC.CTCD */ | |
| TARS = TARD /* \_SB_.PCI0.MCHC.TARD */ | |
| PPCM = PSSS (TARD) | |
| PPCN () | |
| PL2V = CPL2 (CTDD) | |
| PL1V = CTDD /* \_SB_.PCI0.MCHC.CTDD */ | |
| CTCC = CTCD /* \_SB_.PCI0.MCHC.CTCD */ | |
| Release (CTCM) | |
| Return (One) | |
| } | |
| Method (STDN, 0, Serialized) | |
| { | |
| If (Acquire (CTCM, 0x0064)) | |
| { | |
| Return (Zero) | |
| } | |
| If ((CTCN == CTCC)) | |
| { | |
| Release (CTCM) | |
| Return (Zero) | |
| } | |
| Debug = "Set TDP Nominal" | |
| PL1V = CTDN /* \_SB_.PCI0.MCHC.CTDN */ | |
| PL2V = CPL2 (CTDN) | |
| PPCM = PSSS (TARN) | |
| PPCN () | |
| TARS = TARN /* \_SB_.PCI0.MCHC.TARN */ | |
| CTCS = CTCN /* \_SB_.PCI0.MCHC.CTCN */ | |
| CTCC = CTCN /* \_SB_.PCI0.MCHC.CTCN */ | |
| Release (CTCM) | |
| Return (One) | |
| } | |
| Method (TDPP, 1, NotSerialized) | |
| { | |
| Return ((((PUNI - One) << 0x02) * Arg0)) | |
| } | |
| Method (CTLE, 1, Serialized) | |
| { | |
| If (Acquire (CTCM, 0x0064)) | |
| { | |
| Return (Zero) | |
| } | |
| Debug = "Enable PL1 Limit" | |
| Local0 = PSSS (LFM) | |
| PPCM = (Local0 + One) | |
| PPCN () | |
| TARS = (LFM - One) | |
| SPL1 = PL1V /* \_SB_.PCI0.MCHC.PL1V */ | |
| PL1V = TDPP (Arg0) | |
| PL1C = One | |
| Release (CTCM) | |
| Return (One) | |
| } | |
| Method (CTLD, 0, Serialized) | |
| { | |
| If (Acquire (CTCM, 0x0064)) | |
| { | |
| Return (Zero) | |
| } | |
| Debug = "Disable PL1 Limit" | |
| PL1C = Zero | |
| PL1V = SPL1 /* \_SB_.PCI0.MCHC.SPL1 */ | |
| TARS = Zero | |
| PPCM = Zero | |
| PPCN () | |
| Release (CTCM) | |
| Return (One) | |
| } | |
| } | |
| Name (MCRS, ResourceTemplate () | |
| { | |
| WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, | |
| 0x0000, // Granularity | |
| 0x0000, // Range Minimum | |
| 0x00FF, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0x0100, // Length | |
| ,, ) | |
| DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
| 0x00000000, // Granularity | |
| 0x00000000, // Range Minimum | |
| 0x00000CF7, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00000CF8, // Length | |
| ,, , TypeStatic, DenseTranslation) | |
| IO (Decode16, | |
| 0x0CF8, // Range Minimum | |
| 0x0CF8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| ) | |
| DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
| 0x00000000, // Granularity | |
| 0x00000D00, // Range Minimum | |
| 0x0000FFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x0000F300, // Length | |
| ,, , TypeStatic, DenseTranslation) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000A0000, // Range Minimum | |
| 0x000BFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00020000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C0000, // Range Minimum | |
| 0x000C3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C4000, // Range Minimum | |
| 0x000C7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C8000, // Range Minimum | |
| 0x000CBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000CC000, // Range Minimum | |
| 0x000CFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D0000, // Range Minimum | |
| 0x000D3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D4000, // Range Minimum | |
| 0x000D7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D8000, // Range Minimum | |
| 0x000DBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000DC000, // Range Minimum | |
| 0x000DFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E0000, // Range Minimum | |
| 0x000E3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E4000, // Range Minimum | |
| 0x000E7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E8000, // Range Minimum | |
| 0x000EBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000EC000, // Range Minimum | |
| 0x000EFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000F0000, // Range Minimum | |
| 0x000FFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00010000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x00000000, // Range Minimum | |
| 0x00000000, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00000000, // Length | |
| ,, _Y00, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFED40000, // Range Minimum | |
| 0xFED44FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00005000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| CreateDWordField (MCRS, \_SB.PCI0._Y00._MIN, PMIN) // _MIN: Minimum Base Address | |
| CreateDWordField (MCRS, \_SB.PCI0._Y00._MAX, PMAX) // _MAX: Maximum Base Address | |
| CreateDWordField (MCRS, \_SB.PCI0._Y00._LEN, PLEN) // _LEN: Length | |
| Local0 = ^MCHC.TLUD /* \_SB_.PCI0.MCHC.TLUD */ | |
| Local1 = ^MCHC.MEBA /* \_SB_.PCI0.MCHC.MEBA */ | |
| If ((Local0 == Local1)) | |
| { | |
| Local0 = ^MCHC.TOM /* \_SB_.PCI0.MCHC.TOM_ */ | |
| } | |
| PMIN = Local0 | |
| PMAX = 0xEFFFFFFF | |
| PLEN = ((PMAX - PMIN) + One) | |
| Return (MCRS) /* \_SB_.PCI0.MCRS */ | |
| } | |
| Device (PEGP) | |
| { | |
| Name (_ADR, 0x00010000) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return ((((^^MCHC.DVEN >> 0x03) & One) * 0x0F)) | |
| } | |
| Device (DEV0) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (PEG1) | |
| { | |
| Name (_ADR, 0x00010001) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return ((((^^MCHC.DVEN >> 0x02) & One) * 0x0F)) | |
| } | |
| Device (DEV0) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (PEG2) | |
| { | |
| Name (_ADR, 0x00010002) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return ((((^^MCHC.DVEN >> One) & One) * 0x0F)) | |
| } | |
| Device (DEV0) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (PDRC) | |
| { | |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (PDRS, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadWrite, | |
| 0xFED1C000, // Address Base | |
| 0x00004000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED10000, // Address Base | |
| 0x00008000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED18000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED19000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xF0000000, // Address Base | |
| 0x04000000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED20000, // Address Base | |
| 0x00020000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED40000, // Address Base | |
| 0x00005000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED45000, // Address Base | |
| 0x0004B000, // Address Length | |
| ) | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Return (PDRS) /* \_SB_.PCI0.PDRC.PDRS */ | |
| } | |
| } | |
| Device (GFX0) | |
| { | |
| Name (_ADR, 0x00020000) // _ADR: Address | |
| OperationRegion (GFXC, PCI_Config, Zero, 0x0100) | |
| Field (GFXC, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x10), | |
| BAR0, 64, | |
| Offset (0xE4), | |
| ASLE, 32, | |
| Offset (0xFC), | |
| ASLS, 32 | |
| } | |
| OperationRegion (GFRG, SystemMemory, (BAR0 & 0xFFFFFFFFFFFFFFF0), 0x00400000) | |
| Field (GFRG, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x48254), | |
| BCLV, 16, | |
| Offset (0xC8256), | |
| BCLM, 16 | |
| } | |
| Device (BOX3) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| OperationRegion (OPRG, SystemMemory, ASLS, 0x2000) | |
| Field (OPRG, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x58), | |
| MBOX, 32, | |
| Offset (0x300), | |
| ARDY, 1, | |
| Offset (0x304), | |
| ASLC, 32, | |
| TCHE, 32, | |
| ALSI, 32, | |
| BCLP, 32, | |
| PFIT, 32, | |
| CBLV, 32 | |
| } | |
| Method (XBCM, 1, Serialized) | |
| { | |
| If ((ASLS == Zero)) | |
| { | |
| Return (Ones) | |
| } | |
| If (((MBOX & 0x04) == Zero)) | |
| { | |
| Return (Ones) | |
| } | |
| Local1 = ((Arg0 * 0xFF) / 0x64) | |
| If ((Local1 > 0xFF)) | |
| { | |
| Local1 = 0xFF | |
| } | |
| BCLP = (Local1 | 0x80000000) | |
| If ((ARDY == Zero)) | |
| { | |
| Return (Ones) | |
| } | |
| ASLC = 0x02 | |
| ASLE = One | |
| Local0 = 0x20 | |
| While ((Local0 > Zero)) | |
| { | |
| Sleep (One) | |
| If (((ASLC & 0x02) == Zero)) | |
| { | |
| Local1 = ((ASLC >> 0x0C) & 0x03) | |
| If ((Local1 == Zero)) | |
| { | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Ones) | |
| } | |
| } | |
| Local0-- | |
| } | |
| Return (Ones) | |
| } | |
| } | |
| Device (LEGA) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Method (DRCL, 2, NotSerialized) | |
| { | |
| Return (((Arg0 + (Arg1 / 0x02)) / Arg1)) | |
| } | |
| Method (XBCM, 1, NotSerialized) | |
| { | |
| BCLV = DRCL ((Arg0 * BCLM), 0x64) | |
| } | |
| Method (XBQC, 0, NotSerialized) | |
| { | |
| Local0 = DRCL ((BCLV * 0x64), BCLM) | |
| Local1 = 0x02 | |
| While ((Local1 < (SizeOf (BRIG) - One))) | |
| { | |
| Local2 = DerefOf (BRIG [Local1]) | |
| Local3 = DerefOf (BRIG [(Local1 + One)]) | |
| If ((Local0 < Local3)) | |
| { | |
| If (((Local0 < Local2) || ((Local0 - Local2) < (Local3 - | |
| Local0)))) | |
| { | |
| Return (Local2) | |
| } | |
| Else | |
| { | |
| Return (Local3) | |
| } | |
| } | |
| Local1++ | |
| } | |
| Return (Local3) | |
| } | |
| } | |
| Method (XBCM, 1, NotSerialized) | |
| { | |
| If ((^BOX3.XBCM (Arg0) == Ones)) | |
| { | |
| ^LEGA.XBCM (Arg0) | |
| } | |
| } | |
| Method (XBQC, 0, NotSerialized) | |
| { | |
| Return (^LEGA.XBQC ()) | |
| } | |
| Name (BRCT, Zero) | |
| Method (BRID, 1, NotSerialized) | |
| { | |
| Local0 = Match (BRIG, MEQ, Arg0, MTR, Zero, 0x02) | |
| If ((Local0 == Ones)) | |
| { | |
| Return ((SizeOf (BRIG) - One)) | |
| } | |
| Return (Local0) | |
| } | |
| Method (XBCL, 0, NotSerialized) | |
| { | |
| BRCT = One | |
| Return (BRIG) /* \_SB_.PCI0.GFX0.BRIG */ | |
| } | |
| Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
| { | |
| DSEN = (Arg0 & 0x07) | |
| } | |
| Method (DECB, 0, NotSerialized) | |
| { | |
| If (BRCT) | |
| { | |
| Notify (LCD0, 0x87) // Device-Specific | |
| } | |
| Else | |
| { | |
| Local0 = BRID (XBQC ()) | |
| If ((Local0 != 0x02)) | |
| { | |
| Local0-- | |
| } | |
| XBCM (DerefOf (BRIG [Local0])) | |
| } | |
| } | |
| Method (INCB, 0, NotSerialized) | |
| { | |
| If (BRCT) | |
| { | |
| Notify (LCD0, 0x86) // Device-Specific | |
| } | |
| Else | |
| { | |
| Local0 = BRID (XBQC ()) | |
| If ((Local0 != (SizeOf (BRIG) - One))) | |
| { | |
| Local0++ | |
| } | |
| XBCM (DerefOf (BRIG [Local0])) | |
| } | |
| } | |
| Method (XDCS, 1, NotSerialized) | |
| { | |
| TRAP (One) | |
| If ((CSTE & (One << Arg0))) | |
| { | |
| Return (0x1F) | |
| } | |
| Return (0x1D) | |
| } | |
| Method (XDGS, 1, NotSerialized) | |
| { | |
| If ((NSTE & (One << Arg0))) | |
| { | |
| Return (One) | |
| } | |
| Return (Zero) | |
| } | |
| Method (XDSS, 1, NotSerialized) | |
| { | |
| If (((Arg0 & 0xC0000000) == 0xC0000000)) | |
| { | |
| CSTE = NSTE /* \NSTE */ | |
| } | |
| } | |
| } | |
| Scope (GFX0) | |
| { | |
| Name (BRIG, Package (0x12) | |
| { | |
| 0x64, | |
| 0x64, | |
| 0x02, | |
| 0x04, | |
| 0x05, | |
| 0x07, | |
| 0x09, | |
| 0x0B, | |
| 0x0D, | |
| 0x12, | |
| 0x14, | |
| 0x18, | |
| 0x1D, | |
| 0x21, | |
| 0x28, | |
| 0x32, | |
| 0x43, | |
| 0x64 | |
| }) | |
| } | |
| Scope (\) | |
| { | |
| Method (ISLP, 0, NotSerialized) | |
| { | |
| If ((\_SB.PCI0.LPCB.DIDH == 0x9C)) | |
| { | |
| Return (One) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| OperationRegion (IO_T, SystemIO, 0x0800, 0x10) | |
| Field (IO_T, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x08), | |
| TRP0, 8 | |
| } | |
| OperationRegion (RCRB, SystemMemory, 0xFED1C000, 0x4000) | |
| Field (RCRB, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x1000), | |
| Offset (0x3000), | |
| Offset (0x3404), | |
| HPAS, 2, | |
| , 5, | |
| HPTE, 1, | |
| Offset (0x3418), | |
| , 1, | |
| PCID, 1, | |
| SA1D, 1, | |
| SMBD, 1, | |
| HDAD, 1, | |
| , 8, | |
| EH2D, 1, | |
| LPBD, 1, | |
| EH1D, 1, | |
| RP1D, 1, | |
| RP2D, 1, | |
| RP3D, 1, | |
| RP4D, 1, | |
| RP5D, 1, | |
| RP6D, 1, | |
| RP7D, 1, | |
| RP8D, 1, | |
| TTRD, 1, | |
| SA2D, 1, | |
| Offset (0x3428), | |
| BDFD, 1, | |
| ME1D, 1, | |
| ME2D, 1, | |
| IDRD, 1, | |
| KTCT, 1 | |
| } | |
| } | |
| Device (HDEF) | |
| { | |
| Name (_ADR, 0x001B0000) // _ADR: Address | |
| Name (PRWH, Package (0x02) | |
| { | |
| 0x0D, | |
| 0x03 | |
| }) | |
| Name (PRWL, Package (0x02) | |
| { | |
| 0x6D, | |
| 0x03 | |
| }) | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If (ISLP ()) | |
| { | |
| Return (PRWL) /* \_SB_.PCI0.HDEF.PRWL */ | |
| } | |
| Else | |
| { | |
| Return (PRWH) /* \_SB_.PCI0.HDEF.PRWH */ | |
| } | |
| } | |
| } | |
| Method (IRQM, 1, Serialized) | |
| { | |
| Name (IQAA, 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 (IQAP, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| ^LPCB.LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| ^LPCB.LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| ^LPCB.LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| ^LPCB.LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (IQBA, 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 (IQBP, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| ^LPCB.LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| ^LPCB.LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| ^LPCB.LNKD, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| ^LPCB.LNKA, | |
| Zero | |
| } | |
| }) | |
| Name (IQCA, 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 (IQCP, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| ^LPCB.LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| ^LPCB.LNKD, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| ^LPCB.LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| ^LPCB.LNKB, | |
| Zero | |
| } | |
| }) | |
| Name (IQDA, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x12 | |
| } | |
| }) | |
| Name (IQDP, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| ^LPCB.LNKD, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| ^LPCB.LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| ^LPCB.LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| ^LPCB.LNKC, | |
| Zero | |
| } | |
| }) | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (Package (0x02) | |
| { | |
| One, | |
| 0x05 | |
| } | |
| ) | |
| { | |
| If (PICM) | |
| { | |
| Return (IQAA) /* \_SB_.PCI0.IRQM.IQAA */ | |
| } | |
| Else | |
| { | |
| Return (IQAP) /* \_SB_.PCI0.IRQM.IQAP */ | |
| } | |
| } | |
| Case (Package (0x02) | |
| { | |
| 0x02, | |
| 0x06 | |
| } | |
| ) | |
| { | |
| If (PICM) | |
| { | |
| Return (IQBA) /* \_SB_.PCI0.IRQM.IQBA */ | |
| } | |
| Else | |
| { | |
| Return (IQBP) /* \_SB_.PCI0.IRQM.IQBP */ | |
| } | |
| } | |
| Case (Package (0x02) | |
| { | |
| 0x03, | |
| 0x07 | |
| } | |
| ) | |
| { | |
| If (PICM) | |
| { | |
| Return (IQCA) /* \_SB_.PCI0.IRQM.IQCA */ | |
| } | |
| Else | |
| { | |
| Return (IQCP) /* \_SB_.PCI0.IRQM.IQCP */ | |
| } | |
| } | |
| Case (Package (0x02) | |
| { | |
| 0x04, | |
| 0x08 | |
| } | |
| ) | |
| { | |
| If (PICM) | |
| { | |
| Return (IQDA) /* \_SB_.PCI0.IRQM.IQDA */ | |
| } | |
| Else | |
| { | |
| Return (IQDP) /* \_SB_.PCI0.IRQM.IQDP */ | |
| } | |
| } | |
| Default | |
| { | |
| If (PICM) | |
| { | |
| Return (IQDA) /* \_SB_.PCI0.IRQM.IQDA */ | |
| } | |
| Else | |
| { | |
| Return (IQDP) /* \_SB_.PCI0.IRQM.IQDP */ | |
| } | |
| } | |
| } | |
| } | |
| Device (RP01) | |
| { | |
| Name (_ADR, 0x001C0000) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP02) | |
| { | |
| Name (_ADR, 0x001C0001) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP03) | |
| { | |
| Name (_ADR, 0x001C0002) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP04) | |
| { | |
| Name (_ADR, 0x001C0003) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP05) | |
| { | |
| Name (_ADR, 0x001C0004) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP06) | |
| { | |
| Name (_ADR, 0x001C0005) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP07) | |
| { | |
| Name (_ADR, 0x001C0006) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (RP08) | |
| { | |
| Name (_ADR, 0x001C0007) // _ADR: Address | |
| OperationRegion (RPCS, PCI_Config, Zero, 0xFF) | |
| Field (RPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x4C), | |
| Offset (0x4F), | |
| RPPN, 8, | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1 | |
| } | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| Return (IRQM (RPPN)) | |
| } | |
| } | |
| Device (EHCI) | |
| { | |
| Name (_ADR, 0x001D0000) // _ADR: Address | |
| Name (PRWH, Package (0x02) | |
| { | |
| 0x0D, | |
| 0x03 | |
| }) | |
| Name (PRWL, Package (0x02) | |
| { | |
| 0x6D, | |
| 0x03 | |
| }) | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If (ISLP ()) | |
| { | |
| Return (PRWL) /* \_SB_.PCI0.EHCI.PRWL */ | |
| } | |
| Else | |
| { | |
| Return (PRWH) /* \_SB_.PCI0.EHCI.PRWH */ | |
| } | |
| } | |
| Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State | |
| { | |
| Return (0x02) | |
| } | |
| Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State | |
| { | |
| Return (0x02) | |
| } | |
| Device (HUB7) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Device (PRT1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| } | |
| Device (PRT3) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| } | |
| Device (PRT4) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| } | |
| Device (PRT5) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| } | |
| Device (PRT6) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| } | |
| } | |
| } | |
| Device (XHCI) | |
| { | |
| Name (_ADR, 0x00140000) // _ADR: Address | |
| Name (PLSD, 0x05) | |
| Name (PLSP, 0x07) | |
| OperationRegion (XPRT, PCI_Config, Zero, 0x0100) | |
| Field (XPRT, AnyAcc, NoLock, Preserve) | |
| { | |
| DVID, 16, | |
| Offset (0x10), | |
| Offset (0x12), | |
| XMEM, 16, | |
| Offset (0x74), | |
| D0D3, 2, | |
| Offset (0x75), | |
| PMEE, 1, | |
| , 6, | |
| PMES, 1, | |
| Offset (0xB0), | |
| , 13, | |
| MB13, 1, | |
| MB14, 1, | |
| Offset (0xD0), | |
| PR2R, 32, | |
| PR2M, 32, | |
| PR3R, 32, | |
| PR3M, 32 | |
| } | |
| Method (LPCL, 0, Serialized) | |
| { | |
| OperationRegion (XREG, SystemMemory, (XMEM << 0x10), 0x0600) | |
| Field (XREG, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x510), | |
| PSC0, 32, | |
| Offset (0x520), | |
| PSC1, 32, | |
| Offset (0x530), | |
| PSC2, 32, | |
| Offset (0x540), | |
| PSC3, 32 | |
| } | |
| Name (PEDB, 0x02) | |
| Name (CHST, 0x00FE0000) | |
| Local0 = (PSC0 & ~PEDB) | |
| PSC0 = (Local0 | CHST) /* \_SB_.PCI0.XHCI.LPCL.CHST */ | |
| Local0 = (PSC1 & ~PEDB) | |
| PSC1 = (Local0 | CHST) /* \_SB_.PCI0.XHCI.LPCL.CHST */ | |
| Local0 = (PSC2 & ~PEDB) | |
| PSC2 = (Local0 | CHST) /* \_SB_.PCI0.XHCI.LPCL.CHST */ | |
| Local0 = (PSC3 & ~PEDB) | |
| PSC3 = (Local0 | CHST) /* \_SB_.PCI0.XHCI.LPCL.CHST */ | |
| } | |
| Method (LPS0, 0, Serialized) | |
| { | |
| OperationRegion (XREG, SystemMemory, (XMEM << 0x10), 0x0600) | |
| Field (XREG, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x510), | |
| , 5, | |
| PLS1, 4, | |
| PPR1, 1, | |
| , 7, | |
| CSC1, 1, | |
| , 1, | |
| WRC1, 1, | |
| , 11, | |
| WPR1, 1, | |
| Offset (0x520), | |
| , 5, | |
| PLS2, 4, | |
| PPR2, 1, | |
| , 7, | |
| CSC2, 1, | |
| , 1, | |
| WRC2, 1, | |
| , 11, | |
| WPR2, 1, | |
| Offset (0x530), | |
| , 5, | |
| PLS3, 4, | |
| PPR3, 1, | |
| , 7, | |
| CSC3, 1, | |
| , 1, | |
| WRC3, 1, | |
| , 11, | |
| WPR3, 1, | |
| Offset (0x540), | |
| , 5, | |
| PLS4, 4, | |
| PPR4, 1, | |
| , 7, | |
| CSC4, 1, | |
| , 1, | |
| WRC4, 1, | |
| , 11, | |
| WPR4, 1 | |
| } | |
| Local0 = 0x0A | |
| While (((((PPR1 == One) && (PLS1 == PLSP)) || (( | |
| PPR2 == One) && (PLS2 == PLSP))) || (((PPR3 == One) && (PLS3 == PLSP)) || | |
| ((PPR4 == One) && (PLS4 == PLSP))))) | |
| { | |
| If ((Local0 == Zero)) | |
| { | |
| Break | |
| } | |
| Local0-- | |
| Stall (0x0A) | |
| } | |
| Local1 = Zero | |
| Local2 = Zero | |
| Local3 = Zero | |
| Local4 = Zero | |
| If (((PLS1 == PLSD) && ((CSC1 == Zero) && (PPR1 == One)))) | |
| { | |
| WPR1 = One | |
| Local1 = One | |
| } | |
| If (((PLS2 == PLSD) && ((CSC2 == Zero) && (PPR2 == One)))) | |
| { | |
| WPR2 = One | |
| Local2 = One | |
| } | |
| If (((PLS3 == PLSD) && ((CSC3 == Zero) && (PPR3 == One)))) | |
| { | |
| WPR3 = One | |
| Local3 = One | |
| } | |
| If (((PLS4 == PLSD) && ((CSC4 == Zero) && (PPR4 == One)))) | |
| { | |
| WPR4 = One | |
| Local4 = One | |
| } | |
| Local0 = 0x0A | |
| While (((((Local1 == One) && (WRC1 == Zero)) || (( | |
| Local2 == One) && (WRC2 == Zero))) || (((Local3 == One) && (WRC3 == Zero)) || | |
| ((Local4 == One) && (WRC4 == Zero))))) | |
| { | |
| If ((Local0 == Zero)) | |
| { | |
| Break | |
| } | |
| Local0-- | |
| Stall (0x0A) | |
| } | |
| LPCL () | |
| } | |
| Method (_PSC, 0, NotSerialized) // _PSC: Power State Current | |
| { | |
| Return (D0D3) /* \_SB_.PCI0.XHCI.D0D3 */ | |
| } | |
| Method (_PS0, 0, Serialized) // _PS0: Power State 0 | |
| { | |
| If ((DVID == 0xFFFF)) | |
| { | |
| Return (Zero) | |
| } | |
| If (((XMEM == 0xFFFF) || (XMEM == Zero))) | |
| { | |
| Return (Zero) | |
| } | |
| OperationRegion (XREG, SystemMemory, ((XMEM << 0x10) + 0x8000), 0x0200) | |
| Field (XREG, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0xE0), | |
| , 15, | |
| AX15, 1, | |
| Offset (0x154), | |
| , 31, | |
| CLK2, 1, | |
| Offset (0x16C), | |
| , 2, | |
| CLK0, 1, | |
| , 11, | |
| CLK1, 1 | |
| } | |
| Local0 = D0D3 /* \_SB_.PCI0.XHCI.D0D3 */ | |
| If ((Local0 == 0x03)) | |
| { | |
| D0D3 = Zero | |
| } | |
| If (ISLP ()) | |
| { | |
| MB13 = Zero | |
| MB14 = Zero | |
| CLK0 = Zero | |
| CLK1 = Zero | |
| } | |
| CLK2 = One | |
| If (ISLP ()) | |
| { | |
| LPS0 () | |
| AX15 = One | |
| } | |
| Return (Zero) | |
| } | |
| Method (_PS3, 0, Serialized) // _PS3: Power State 3 | |
| { | |
| If ((DVID == 0xFFFF)) | |
| { | |
| Return (Zero) | |
| } | |
| If (((XMEM == 0xFFFF) || (XMEM == Zero))) | |
| { | |
| Return (Zero) | |
| } | |
| OperationRegion (XREG, SystemMemory, ((XMEM << 0x10) + 0x8000), 0x0200) | |
| Field (XREG, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0xE0), | |
| , 15, | |
| AX15, 1, | |
| Offset (0x154), | |
| , 31, | |
| CLK2, 1, | |
| Offset (0x16C), | |
| , 2, | |
| CLK0, 1, | |
| , 11, | |
| CLK1, 1 | |
| } | |
| PMES = One | |
| PMEE = One | |
| Local0 = D0D3 /* \_SB_.PCI0.XHCI.D0D3 */ | |
| If ((Local0 == 0x03)) | |
| { | |
| D0D3 = Zero | |
| } | |
| If (ISLP ()) | |
| { | |
| MB13 = One | |
| MB14 = One | |
| CLK0 = One | |
| CLK1 = One | |
| } | |
| CLK2 = Zero | |
| If (ISLP ()) | |
| { | |
| AX15 = Zero | |
| } | |
| D0D3 = 0x03 | |
| Return (Zero) | |
| } | |
| Name (PRWH, Package (0x02) | |
| { | |
| 0x0D, | |
| 0x03 | |
| }) | |
| Name (PRWL, Package (0x02) | |
| { | |
| 0x6D, | |
| 0x03 | |
| }) | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If (ISLP ()) | |
| { | |
| Return (PRWL) /* \_SB_.PCI0.XHCI.PRWL */ | |
| } | |
| Else | |
| { | |
| Return (PRWH) /* \_SB_.PCI0.XHCI.PRWH */ | |
| } | |
| } | |
| Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State | |
| { | |
| Return (0x03) | |
| } | |
| Method (_S4D, 0, NotSerialized) // _S4D: S4 Device State | |
| { | |
| Return (0x03) | |
| } | |
| Device (HUB7) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Method (GPLD, 1, Serialized) | |
| { | |
| Name (PCKG, Package (0x01) | |
| { | |
| Buffer (0x10){} | |
| }) | |
| CreateField (DerefOf (PCKG [Zero]), Zero, 0x07, REV) | |
| REV = 0x02 | |
| CreateField (DerefOf (PCKG [Zero]), 0x40, One, VISI) | |
| VISI = Arg0 | |
| Return (PCKG) /* \_SB_.PCI0.XHCI.HUB7.GPLD.PCKG */ | |
| } | |
| Device (PRT1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| } | |
| Device (PRT3) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| } | |
| Device (PRT4) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| } | |
| Device (PRT5) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| } | |
| Device (PRT6) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| } | |
| Device (PRT7) | |
| { | |
| Name (_ADR, 0x07) // _ADR: Address | |
| } | |
| Device (SSP1) | |
| { | |
| Name (_ADR, 0x0A) // _ADR: Address | |
| } | |
| Device (SSP2) | |
| { | |
| Name (_ADR, 0x0B) // _ADR: Address | |
| } | |
| Device (SSP3) | |
| { | |
| Name (_ADR, 0x0C) // _ADR: Address | |
| } | |
| Device (SSP4) | |
| { | |
| Name (_ADR, 0x0D) // _ADR: Address | |
| } | |
| } | |
| } | |
| Device (LPCB) | |
| { | |
| Name (_ADR, 0x001F0000) // _ADR: Address | |
| OperationRegion (LPC0, PCI_Config, Zero, 0x0100) | |
| Field (LPC0, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x03), | |
| DIDH, 8, | |
| Offset (0x40), | |
| PMBS, 16, | |
| Offset (0x48), | |
| GPBS, 16, | |
| Offset (0x60), | |
| PRTA, 8, | |
| PRTB, 8, | |
| PRTC, 8, | |
| PRTD, 8, | |
| Offset (0x68), | |
| PRTE, 8, | |
| PRTF, 8, | |
| PRTG, 8, | |
| PRTH, 8, | |
| Offset (0x80), | |
| IOD0, 8, | |
| IOD1, 8, | |
| Offset (0xF0), | |
| RCEN, 1, | |
| , 13, | |
| RCBA, 18 | |
| } | |
| 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 | |
| { | |
| PRTA = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,10,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLA, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLA, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTA & 0x0F)) | |
| Return (RTLA) /* \_SB_.PCI0.LPCB.LNKA._CRS.RTLA */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTA = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTA & 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 | |
| { | |
| PRTB = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,11,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLB, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLB, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTB & 0x0F)) | |
| Return (RTLB) /* \_SB_.PCI0.LPCB.LNKB._CRS.RTLB */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTB = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTB & 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 | |
| { | |
| PRTC = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,10,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLC, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLC, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTC & 0x0F)) | |
| Return (RTLC) /* \_SB_.PCI0.LPCB.LNKC._CRS.RTLC */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTC = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTC & 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 | |
| { | |
| PRTD = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,11,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLD, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLD, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTD & 0x0F)) | |
| Return (RTLD) /* \_SB_.PCI0.LPCB.LNKD._CRS.RTLD */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTD = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTD & 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 | |
| { | |
| PRTE = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,10,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLE, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLE, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTE & 0x0F)) | |
| Return (RTLE) /* \_SB_.PCI0.LPCB.LNKE._CRS.RTLE */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTE = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTE & 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 | |
| { | |
| PRTF = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,11,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLF, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLF, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTF & 0x0F)) | |
| Return (RTLF) /* \_SB_.PCI0.LPCB.LNKF._CRS.RTLF */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTF = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTF & 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 | |
| { | |
| PRTG = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,10,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLG, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLG, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTG & 0x0F)) | |
| Return (RTLG) /* \_SB_.PCI0.LPCB.LNKG._CRS.RTLG */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTG = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTG & 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 | |
| { | |
| PRTH = 0x80 | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,11,12,14,15} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RTLH, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {} | |
| }) | |
| CreateWordField (RTLH, One, IRQ0) | |
| IRQ0 = Zero | |
| IRQ0 = (One << (PRTH & 0x0F)) | |
| Return (RTLH) /* \_SB_.PCI0.LPCB.LNKH._CRS.RTLH */ | |
| } | |
| Method (_SRS, 1, Serialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRQ0) | |
| FindSetRightBit (IRQ0, Local0) | |
| Local0-- | |
| PRTH = Local0 | |
| } | |
| Method (_STA, 0, Serialized) // _STA: Status | |
| { | |
| If ((PRTH & 0x80)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| } | |
| Device (EC) | |
| { | |
| Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_GPE, 0x11) // _GPE: General Purpose Events | |
| Mutex (ECLK, 0x00) | |
| OperationRegion (ERAM, EmbeddedControl, Zero, 0x0100) | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x02), | |
| DKR1, 1, | |
| Offset (0x05), | |
| HSPA, 1, | |
| Offset (0x0C), | |
| LEDS, 8, | |
| Offset (0x0F), | |
| , 7, | |
| TBSW, 1, | |
| Offset (0x1A), | |
| DKR2, 1, | |
| Offset (0x2A), | |
| EVNT, 8, | |
| Offset (0x2F), | |
| , 6, | |
| FAND, 1, | |
| FANA, 1, | |
| , 6, | |
| ALMT, 1, | |
| Offset (0x31), | |
| , 2, | |
| UWBE, 1, | |
| Offset (0x3A), | |
| AMUT, 1, | |
| , 3, | |
| BTEB, 1, | |
| WLEB, 1, | |
| WWEB, 1, | |
| Offset (0x3B), | |
| , 1, | |
| KBLT, 1, | |
| , 2, | |
| USPW, 1, | |
| Offset (0x48), | |
| HPPI, 1, | |
| GSTS, 1, | |
| Offset (0x4E), | |
| WAKE, 16, | |
| Offset (0x78), | |
| TMP0, 8, | |
| TMP1, 8, | |
| Offset (0x81), | |
| PAGE, 8, | |
| Offset (0xFE), | |
| , 4, | |
| DKR3, 1 | |
| } | |
| Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
| { | |
| If ((Arg1 == One)) | |
| { | |
| If ((^HKEY.INIT == Zero)) | |
| { | |
| ^HKEY.WBDC = BTEB /* \_SB_.PCI0.LPCB.EC__.BTEB */ | |
| ^HKEY.WWAN = WWEB /* \_SB_.PCI0.LPCB.EC__.WWEB */ | |
| ^HKEY.INIT = One | |
| } | |
| } | |
| } | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (ECMD, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0062, // Range Minimum | |
| 0x0062, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0066, // Range Minimum | |
| 0x0066, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| }) | |
| Return (ECMD) /* \_SB_.PCI0.LPCB.EC__._CRS.ECMD */ | |
| } | |
| Method (TLED, 1, NotSerialized) | |
| { | |
| LEDS = Arg0 | |
| } | |
| Method (LED, 2, NotSerialized) | |
| { | |
| TLED ((Arg0 | Arg1)) | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| } | |
| Method (MUTE, 1, NotSerialized) | |
| { | |
| AMUT = Arg0 | |
| } | |
| Method (RADI, 1, NotSerialized) | |
| { | |
| WLEB = Arg0 | |
| WWEB = Arg0 | |
| BTEB = Arg0 | |
| } | |
| Method (USBP, 1, NotSerialized) | |
| { | |
| USPW = Arg0 | |
| } | |
| Method (LGHT, 1, NotSerialized) | |
| { | |
| KBLT = Arg0 | |
| } | |
| Method (_Q13, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (SLPB, 0x80) // Status Change | |
| } | |
| Method (_Q14, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^^^GFX0.INCB () | |
| } | |
| Method (_Q15, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^^^GFX0.DECB () | |
| } | |
| Method (_Q16, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (GFX0, 0x82) // Device-Specific Change | |
| } | |
| Method (_Q26, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (AC, 0x80) // Status Change | |
| PNOT () | |
| } | |
| Method (_Q27, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (AC, 0x80) // Status Change | |
| EVNT = 0x50 | |
| PNOT () | |
| } | |
| Method (_Q2A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (LID, 0x80) // Status Change | |
| } | |
| Method (_Q2B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (LID, 0x80) // Status Change | |
| } | |
| Method (_Q10, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (One) | |
| } | |
| Method (_Q11, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x02) | |
| } | |
| Method (_Q12, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x03) | |
| } | |
| Method (_Q64, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x05) | |
| } | |
| Method (_Q65, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x06) | |
| } | |
| Method (_Q17, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x08) | |
| } | |
| Method (_Q66, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0A) | |
| } | |
| Method (_Q6A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x1B) | |
| } | |
| Method (_Q1A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0B) | |
| } | |
| Method (_Q1B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0C) | |
| } | |
| Method (_Q62, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0D) | |
| } | |
| Method (_Q60, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0E) | |
| } | |
| Method (_Q61, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x0F) | |
| } | |
| Method (_Q1F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x12) | |
| } | |
| Method (_Q67, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x13) | |
| } | |
| Method (_Q63, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x14) | |
| } | |
| Method (_Q19, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x18) | |
| } | |
| Method (_Q1C, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x19) | |
| } | |
| Method (_Q1D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RHK (0x1A) | |
| } | |
| Method (_Q5C, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RTAB (0x0B) | |
| } | |
| Method (_Q5D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RTAB (0x0C) | |
| } | |
| Method (_Q5E, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RTAB (0x09) | |
| } | |
| Method (_Q5F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| ^HKEY.RTAB (0x0A) | |
| } | |
| Method (FANE, 1, Serialized) | |
| { | |
| If (Arg0) | |
| { | |
| FAND = One | |
| FANA = Zero | |
| } | |
| Else | |
| { | |
| FAND = Zero | |
| FANA = One | |
| } | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x46), | |
| , 4, | |
| HPAC, 1 | |
| } | |
| Device (AC) | |
| { | |
| Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
| { | |
| _SB | |
| }) | |
| Method (_PSR, 0, NotSerialized) // _PSR: Power Source | |
| { | |
| Local0 = HPAC /* \_SB_.PCI0.LPCB.EC__.HPAC */ | |
| PWRS = Local0 | |
| PNOT () | |
| Return (Local0) | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x38), | |
| B0ST, 4, | |
| , 1, | |
| B0CH, 1, | |
| B0DI, 1, | |
| B0PR, 1, | |
| B1ST, 4, | |
| , 1, | |
| B1CH, 1, | |
| B1DI, 1, | |
| B1PR, 1 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| BARC, 16, | |
| BAFC, 16, | |
| Offset (0xA8), | |
| BAPR, 16, | |
| BAVO, 16 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| , 15, | |
| BAMA, 1 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| BADC, 16, | |
| BADV, 16, | |
| Offset (0xA6), | |
| Offset (0xA8), | |
| Offset (0xAA), | |
| BASN, 16 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| BATY, 32 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| BAOE, 128 | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| BANA, 128 | |
| } | |
| Method (BPAG, 1, NotSerialized) | |
| { | |
| PAGE = Arg0 | |
| } | |
| Method (BSTA, 4, NotSerialized) | |
| { | |
| Acquire (ECLK, 0xFFFF) | |
| Local0 = Zero | |
| BPAG ((One | Arg0)) | |
| Local1 = BAMA /* \_SB_.PCI0.LPCB.EC__.BAMA */ | |
| BPAG (Arg0) | |
| Local2 = BAPR /* \_SB_.PCI0.LPCB.EC__.BAPR */ | |
| If (Arg2) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (Arg3) | |
| { | |
| Local0 |= One | |
| Local2 = (0x00010000 - Local2) | |
| } | |
| Else | |
| { | |
| Local2 = Zero | |
| } | |
| If ((Local2 >= 0x8000)) | |
| { | |
| Local2 = Zero | |
| } | |
| Arg1 [Zero] = Local0 | |
| If (Local1) | |
| { | |
| Arg1 [0x02] = (BARC * 0x0A) | |
| Local2 *= BAVO /* \_SB_.PCI0.LPCB.EC__.BAVO */ | |
| Arg1 [One] = (Local2 / 0x03E8) | |
| } | |
| Else | |
| { | |
| Arg1 [0x02] = BARC /* \_SB_.PCI0.LPCB.EC__.BARC */ | |
| Arg1 [One] = Local2 | |
| } | |
| Arg1 [0x03] = BAVO /* \_SB_.PCI0.LPCB.EC__.BAVO */ | |
| Release (ECLK) | |
| Return (Arg1) | |
| } | |
| Method (BINF, 2, Serialized) | |
| { | |
| Acquire (ECLK, 0xFFFF) | |
| BPAG ((One | Arg1)) | |
| Arg0 [Zero] = (BAMA ^ One) | |
| Local0 = BAMA /* \_SB_.PCI0.LPCB.EC__.BAMA */ | |
| BPAG (Arg1) | |
| Local2 = BAFC /* \_SB_.PCI0.LPCB.EC__.BAFC */ | |
| BPAG ((0x02 | Arg1)) | |
| Local1 = BADC /* \_SB_.PCI0.LPCB.EC__.BADC */ | |
| If (Local0) | |
| { | |
| Local1 *= 0x0A | |
| Local2 *= 0x0A | |
| } | |
| Arg0 [One] = Local1 | |
| Arg0 [0x02] = Local2 | |
| Arg0 [0x04] = BADV /* \_SB_.PCI0.LPCB.EC__.BADV */ | |
| Divide (Local2, 0x14, Local0, Arg0 [0x05]) | |
| Local0 = BASN /* \_SB_.PCI0.LPCB.EC__.BASN */ | |
| Name (SERN, Buffer (0x06) | |
| { | |
| " " | |
| }) | |
| Local1 = 0x04 | |
| While (Local0) | |
| { | |
| Divide (Local0, 0x0A, Local2, Local0) | |
| SERN [Local1] = (Local2 + 0x30) | |
| Local1-- | |
| } | |
| Arg0 [0x0A] = SERN /* \_SB_.PCI0.LPCB.EC__.BINF.SERN */ | |
| BPAG ((0x04 | Arg1)) | |
| Name (TYPE, Buffer (0x05) | |
| { | |
| 0x00, 0x00, 0x00, 0x00, 0x00 // ..... | |
| }) | |
| TYPE = BATY /* \_SB_.PCI0.LPCB.EC__.BATY */ | |
| Arg0 [0x0B] = TYPE /* \_SB_.PCI0.LPCB.EC__.BINF.TYPE */ | |
| BPAG ((0x05 | Arg1)) | |
| Arg0 [0x0C] = BAOE /* \_SB_.PCI0.LPCB.EC__.BAOE */ | |
| BPAG ((0x06 | Arg1)) | |
| Arg0 [0x09] = BANA /* \_SB_.PCI0.LPCB.EC__.BANA */ | |
| Release (ECLK) | |
| Return (Arg0) | |
| } | |
| 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 | |
| { | |
| _SB | |
| }) | |
| Name (BATS, Package (0x0D) | |
| { | |
| Zero, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| One, | |
| 0x2A30, | |
| Zero, | |
| 0xC8, | |
| One, | |
| One, | |
| "", | |
| "", | |
| "", | |
| "" | |
| }) | |
| Method (_BIF, 0, NotSerialized) // _BIF: Battery Information | |
| { | |
| Return (BINF (BATS, Zero)) | |
| } | |
| Name (BATI, Package (0x04) | |
| { | |
| Zero, | |
| Zero, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
| { | |
| If (B0PR) | |
| { | |
| Return (BSTA (Zero, BATI, B0CH, B0DI)) | |
| } | |
| Else | |
| { | |
| Return (Package (0x04) | |
| { | |
| Zero, | |
| Zero, | |
| Zero, | |
| Zero | |
| }) | |
| } | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (B0PR) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| } | |
| Device (BAT1) | |
| { | |
| Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
| { | |
| _SB | |
| }) | |
| Name (BATS, Package (0x0D) | |
| { | |
| Zero, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| One, | |
| 0x2A30, | |
| Zero, | |
| 0xC8, | |
| One, | |
| One, | |
| "", | |
| "", | |
| "", | |
| "" | |
| }) | |
| Method (_BIF, 0, NotSerialized) // _BIF: Battery Information | |
| { | |
| Return (BINF (BATS, 0x10)) | |
| } | |
| Name (BATI, Package (0x04) | |
| { | |
| Zero, | |
| Zero, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
| { | |
| If (B1PR) | |
| { | |
| Return (BSTA (0x10, BATI, B1CH, B1DI)) | |
| } | |
| Else | |
| { | |
| Return (Package (0x04) | |
| { | |
| Zero, | |
| Zero, | |
| Zero, | |
| Zero | |
| }) | |
| } | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (B1PR) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| } | |
| Method (_Q24, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT0, 0x80) // Status Change | |
| } | |
| Method (_Q25, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT1, 0x80) // Status Change | |
| } | |
| Method (_Q4A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT0, 0x81) // Information Change | |
| } | |
| Method (_Q4B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT0, 0x80) // Status Change | |
| } | |
| Method (_Q4C, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT1, 0x81) // Information Change | |
| } | |
| Method (_Q4D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (BAT1, 0x80) // Status Change | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x32), | |
| , 4, | |
| WKFN, 1, | |
| Offset (0x83), | |
| FNKY, 8 | |
| } | |
| Device (SLPB) | |
| { | |
| Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */) // _HID: Hardware ID | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (Package (0x02) | |
| { | |
| 0x18, | |
| 0x03 | |
| }) | |
| } | |
| Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake | |
| { | |
| If (Arg0) | |
| { | |
| FNKY = 0x06 | |
| WKFN = One | |
| } | |
| Else | |
| { | |
| FNKY = Zero | |
| WKFN = Zero | |
| } | |
| } | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x32), | |
| , 2, | |
| WKLD, 1, | |
| Offset (0x46), | |
| , 2, | |
| LIDS, 1 | |
| } | |
| Device (LID) | |
| { | |
| Name (_HID, "PNP0C0D" /* Lid Device */) // _HID: Hardware ID | |
| Method (_LID, 0, NotSerialized) // _LID: Lid Status | |
| { | |
| Return (LIDS) /* \_SB_.PCI0.LPCB.EC__.LIDS */ | |
| } | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (Package (0x02) | |
| { | |
| 0x18, | |
| 0x03 | |
| }) | |
| } | |
| Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake | |
| { | |
| If (Arg0) | |
| { | |
| WKLD = One | |
| } | |
| Else | |
| { | |
| WKLD = Zero | |
| } | |
| } | |
| } | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x06), | |
| SNDS, 8 | |
| } | |
| Method (BEEP, 1, NotSerialized) | |
| { | |
| SNDS = Arg0 | |
| } | |
| Scope (\_TZ) | |
| { | |
| Name (MEB1, Zero) | |
| Name (MEB2, Zero) | |
| Method (C2K, 1, NotSerialized) | |
| { | |
| Local0 = (Arg0 * 0x0A) | |
| Local0 += 0x0AAC | |
| If ((Local0 <= 0x0AAC)) | |
| { | |
| Return (0x0BB8) | |
| } | |
| If ((Local0 > 0x0FAC)) | |
| { | |
| Return (0x0BB8) | |
| } | |
| Return (Local0) | |
| } | |
| ThermalZone (THM0) | |
| { | |
| Name (_TZP, 0x64) // _TZP: Thermal Zone Polling | |
| Name (_TSP, 0x64) // _TSP: Thermal Sampling Period | |
| Name (_TC1, 0x02) // _TC1: Thermal Constant 1 | |
| Name (_TC2, 0x05) // _TC2: Thermal Constant 2 | |
| Method (_PSL, 0, Serialized) // _PSL: Passive List | |
| { | |
| Return (PPKG ()) | |
| } | |
| Method (GCRT, 0, NotSerialized) | |
| { | |
| Local0 = TCRT /* \TCRT */ | |
| If ((Local0 > Zero)) | |
| { | |
| Return (Local0) | |
| } | |
| Return (0x7F) | |
| } | |
| Method (GPSV, 0, NotSerialized) | |
| { | |
| Local0 = TPSV /* \TPSV */ | |
| If ((Local0 > Zero)) | |
| { | |
| Return (Local0) | |
| } | |
| Return (0x5F) | |
| } | |
| Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature | |
| { | |
| Return (C2K (GCRT ())) | |
| } | |
| Method (_PSV, 0, NotSerialized) // _PSV: Passive Temperature | |
| { | |
| Return (C2K (GPSV ())) | |
| } | |
| Method (_TMP, 0, NotSerialized) // _TMP: Temperature | |
| { | |
| If ((!MEB1 && (\_SB.PCI0.LPCB.EC.TMP0 == 0x80))) | |
| { | |
| Return (C2K (0x28)) | |
| } | |
| MEB1 = One | |
| Return (C2K (\_SB.PCI0.LPCB.EC.TMP0)) | |
| } | |
| Method (_AC0, 0, NotSerialized) // _ACx: Active Cooling | |
| { | |
| Local0 = GPSV () | |
| Local0 -= 0x0A | |
| If (FLVL) | |
| { | |
| Local0 -= 0x05 | |
| } | |
| Return (C2K (Local0)) | |
| } | |
| Name (_AL0, Package (0x01) // _ALx: Active List | |
| { | |
| FAN | |
| }) | |
| PowerResource (FPWR, 0x00, 0x0000) | |
| { | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (FLVL) /* \FLVL */ | |
| } | |
| Method (_ON, 0, NotSerialized) // _ON_: Power On | |
| { | |
| \_SB.PCI0.LPCB.EC.FANE (One) | |
| FLVL = One | |
| Notify (THM0, 0x81) // Thermal Trip Point Change | |
| } | |
| Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
| { | |
| \_SB.PCI0.LPCB.EC.FANE (Zero) | |
| FLVL = Zero | |
| Notify (THM0, 0x81) // Thermal Trip Point Change | |
| } | |
| } | |
| Device (FAN) | |
| { | |
| Name (_HID, EisaId ("PNP0C0B") /* Fan (Thermal Solution) */) // _HID: Hardware ID | |
| Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
| { | |
| FPWR | |
| }) | |
| } | |
| } | |
| ThermalZone (THM1) | |
| { | |
| Name (_TZP, 0x64) // _TZP: Thermal Zone Polling | |
| Name (_TSP, 0x64) // _TSP: Thermal Sampling Period | |
| Name (_TC1, 0x02) // _TC1: Thermal Constant 1 | |
| Name (_TC2, 0x05) // _TC2: Thermal Constant 2 | |
| Method (_PSL, 0, Serialized) // _PSL: Passive List | |
| { | |
| Return (PPKG ()) | |
| } | |
| Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature | |
| { | |
| Return (C2K (0x63)) | |
| } | |
| Method (_PSV, 0, NotSerialized) // _PSV: Passive Temperature | |
| { | |
| Return (C2K (0x5E)) | |
| } | |
| Method (_TMP, 0, NotSerialized) // _TMP: Temperature | |
| { | |
| If ((!MEB2 && (\_SB.PCI0.LPCB.EC.TMP1 == 0x80))) | |
| { | |
| Return (C2K (0x28)) | |
| } | |
| MEB2 = One | |
| Return (C2K (\_SB.PCI0.LPCB.EC.TMP1)) | |
| } | |
| } | |
| } | |
| Scope (\_SI) | |
| { | |
| Method (_SST, 1, NotSerialized) // _SST: System Status | |
| { | |
| If ((Arg0 == Zero)) | |
| { | |
| \_SB.PCI0.LPCB.EC.TLED (Zero) | |
| \_SB.PCI0.LPCB.EC.TLED (0x07) | |
| } | |
| If ((Arg0 == One)) | |
| { | |
| \_SB.PCI0.LPCB.EC.TLED (0x80) | |
| \_SB.PCI0.LPCB.EC.TLED (0x07) | |
| } | |
| If ((Arg0 == 0x02)) | |
| { | |
| \_SB.PCI0.LPCB.EC.TLED (0x80) | |
| \_SB.PCI0.LPCB.EC.TLED (0xC7) | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| \_SB.PCI0.LPCB.EC.TLED (0xA0) | |
| \_SB.PCI0.LPCB.EC.TLED (0x87) | |
| } | |
| } | |
| } | |
| Device (HKEY) | |
| { | |
| Name (_HID, EisaId ("IBM0068")) // _HID: Hardware ID | |
| Name (BTN, Zero) | |
| Name (BTAB, Zero) | |
| Name (DHKN, 0x080C) | |
| Name (EMSK, Zero) | |
| Name (ETAB, Zero) | |
| Name (EN, Zero) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Method (MHKP, 0, NotSerialized) | |
| { | |
| Local0 = BTN /* \_SB_.PCI0.LPCB.EC__.HKEY.BTN_ */ | |
| If ((Local0 != Zero)) | |
| { | |
| BTN = Zero | |
| Local0 += 0x1000 | |
| Return (Local0) | |
| } | |
| Local0 = BTAB /* \_SB_.PCI0.LPCB.EC__.HKEY.BTAB */ | |
| If ((Local0 != Zero)) | |
| { | |
| BTAB = Zero | |
| Local0 += 0x5000 | |
| Return (Local0) | |
| } | |
| Return (Zero) | |
| } | |
| Method (RHK, 1, NotSerialized) | |
| { | |
| Local0 = (One << (Arg0 - One)) | |
| If ((EMSK & Local0)) | |
| { | |
| BTN = Arg0 | |
| Notify (HKEY, 0x80) // Status Change | |
| } | |
| } | |
| Method (RTAB, 1, NotSerialized) | |
| { | |
| Local0 = (One << (Arg0 - One)) | |
| If ((ETAB & Local0)) | |
| { | |
| BTAB = Arg0 | |
| Notify (HKEY, 0x80) // Status Change | |
| } | |
| } | |
| Method (MHKC, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| EMSK = DHKN /* \_SB_.PCI0.LPCB.EC__.HKEY.DHKN */ | |
| ETAB = Ones | |
| } | |
| Else | |
| { | |
| EMSK = Zero | |
| ETAB = Zero | |
| } | |
| EN = Arg0 | |
| } | |
| Method (MHKM, 2, NotSerialized) | |
| { | |
| If ((Arg0 <= 0x20)) | |
| { | |
| Local0 = (One << (Arg0 - One)) | |
| If (Arg1) | |
| { | |
| DHKN |= Local0 | |
| } | |
| Else | |
| { | |
| DHKN &= ~Local0 | |
| } | |
| If (EN) | |
| { | |
| EMSK = DHKN /* \_SB_.PCI0.LPCB.EC__.HKEY.DHKN */ | |
| } | |
| } | |
| } | |
| Method (MHKA, 0, NotSerialized) | |
| { | |
| Return (0x07FFFFFF) | |
| } | |
| Method (MHKG, 0, NotSerialized) | |
| { | |
| Return ((TBSW << 0x03)) | |
| } | |
| Method (SSMS, 1, NotSerialized) | |
| { | |
| ALMT = Arg0 | |
| } | |
| Method (MMTS, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| TLED (0x8E) | |
| } | |
| Else | |
| { | |
| TLED (0x0E) | |
| } | |
| } | |
| Method (MHKV, 0, NotSerialized) | |
| { | |
| Return (0x0100) | |
| } | |
| Method (WLSW, 0, NotSerialized) | |
| { | |
| Return (GSTS) /* \_SB_.PCI0.LPCB.EC__.GSTS */ | |
| } | |
| Name (INIT, Zero) | |
| Name (HAST, Zero) | |
| Name (WBDC, Zero) | |
| Method (GBDC, 0, NotSerialized) | |
| { | |
| HAST = One | |
| If (HBDC) | |
| { | |
| Local0 = One | |
| If (BTEB) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Local0 |= (WBDC << 0x02) | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (SBDC, 1, NotSerialized) | |
| { | |
| HAST = One | |
| If (HBDC) | |
| { | |
| Local0 = ((Arg0 & 0x02) >> One) | |
| BTEB = Local0 | |
| Local0 = ((Arg0 & 0x04) >> 0x02) | |
| WBDC = Local0 | |
| } | |
| } | |
| Name (WWAN, Zero) | |
| Method (GWAN, 0, NotSerialized) | |
| { | |
| HAST = One | |
| If (HWAN) | |
| { | |
| Local0 = One | |
| If (WWEB) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Local0 |= (WWAN << 0x02) | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (SWAN, 1, NotSerialized) | |
| { | |
| HAST = One | |
| If (HWAN) | |
| { | |
| Local0 = ((Arg0 & 0x02) >> One) | |
| WWEB = Local0 | |
| WWAN = ((Arg0 & 0x04) >> 0x02) | |
| } | |
| } | |
| Method (MLCG, 1, NotSerialized) | |
| { | |
| If (HKBL) | |
| { | |
| Local0 = 0x0200 | |
| Local0 |= KBLT /* \_SB_.PCI0.LPCB.EC__.KBLT */ | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (MLCS, 1, NotSerialized) | |
| { | |
| If (HKBL) | |
| { | |
| WWEB = (Arg0 & One) | |
| } | |
| } | |
| Method (GUWB, 0, NotSerialized) | |
| { | |
| If (HUWB) | |
| { | |
| Local0 = One | |
| If (UWBE) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (SUWB, 1, NotSerialized) | |
| { | |
| If (HUWB) | |
| { | |
| Local0 = ((Arg0 & 0x02) >> One) | |
| UWBE = Local0 | |
| } | |
| } | |
| Method (WAKE, 1, NotSerialized) | |
| { | |
| If (HAST) | |
| { | |
| BTEB = WBDC /* \_SB_.PCI0.LPCB.EC__.HKEY.WBDC */ | |
| WWEB = WWAN /* \_SB_.PCI0.LPCB.EC__.HKEY.WWAN */ | |
| } | |
| } | |
| } | |
| } | |
| Device (DMAC) | |
| { | |
| Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0000, // Range Minimum | |
| 0x0000, // Range Maximum | |
| 0x01, // Alignment | |
| 0x20, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0081, // Range Minimum | |
| 0x0081, // Range Maximum | |
| 0x01, // Alignment | |
| 0x11, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0093, // Range Minimum | |
| 0x0093, // Range Maximum | |
| 0x01, // Alignment | |
| 0x0D, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00C0, // Range Minimum | |
| 0x00C0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x20, // Length | |
| ) | |
| DMA (Compatibility, NotBusMaster, Transfer8_16, ) | |
| {4} | |
| }) | |
| } | |
| Device (FWH) | |
| { | |
| Name (_HID, EisaId ("INT0800") /* Intel 82802 Firmware Hub Device */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| Memory32Fixed (ReadOnly, | |
| 0xFF000000, // Address Base | |
| 0x01000000, // Address Length | |
| ) | |
| }) | |
| } | |
| Device (HPET) | |
| { | |
| Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0C01") /* System Board */) // _CID: Compatible ID | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadOnly, | |
| 0xFED00000, // Address Base | |
| 0x00000400, // Address Length | |
| _Y01) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (HPTE) | |
| { | |
| If ((OSYS >= 0x07D1)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Return (Zero) | |
| } | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| If (HPTE) | |
| { | |
| CreateDWordField (BUF0, \_SB.PCI0.LPCB.HPET._Y01._BAS, HPT0) // _BAS: Base Address | |
| If ((HPAS == One)) | |
| { | |
| HPT0 = 0xFED01000 | |
| } | |
| If ((HPAS == 0x02)) | |
| { | |
| HPT0 = 0xFED02000 | |
| } | |
| If ((HPAS == 0x03)) | |
| { | |
| HPT0 = 0xFED03000 | |
| } | |
| } | |
| Return (BUF0) /* \_SB_.PCI0.LPCB.HPET.BUF0 */ | |
| } | |
| } | |
| Device (PIC) | |
| { | |
| Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0020, // Range Minimum | |
| 0x0020, // Range Maximum | |
| 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 (MATH) | |
| { | |
| Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x00F0, // Range Minimum | |
| 0x00F0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IRQNoFlags () | |
| {13} | |
| }) | |
| } | |
| Device (LDRC) | |
| { | |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x002E, // Range Minimum | |
| 0x002E, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x004E, // Range Minimum | |
| 0x004E, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0061, // Range Minimum | |
| 0x0061, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0063, // Range Minimum | |
| 0x0063, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0065, // Range Minimum | |
| 0x0065, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0067, // Range Minimum | |
| 0x0067, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0080, // Range Minimum | |
| 0x0080, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0092, // Range Minimum | |
| 0x0092, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00B2, // Range Minimum | |
| 0x00B2, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0500, // Range Minimum | |
| 0x0500, // Range Maximum | |
| 0x01, // Alignment | |
| 0xFF, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0000, // Range Minimum | |
| 0x0000, // Range Maximum | |
| 0x01, // Alignment | |
| 0x00, // Length | |
| _Y02) | |
| }) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| If (!ISLP ()) | |
| { | |
| CreateByteField (RBUF, \_SB.PCI0.LPCB.LDRC._Y02._LEN, R1LN) // _LEN: Length | |
| CreateWordField (RBUF, \_SB.PCI0.LPCB.LDRC._Y02._MIN, R1MN) // _MIN: Minimum Base Address | |
| CreateWordField (RBUF, \_SB.PCI0.LPCB.LDRC._Y02._MAX, R1MX) // _MAX: Maximum Base Address | |
| R1MN = 0x0480 | |
| R1MX = 0x0480 | |
| R1LN = 0x80 | |
| } | |
| Return (RBUF) /* \_SB_.PCI0.LPCB.LDRC.RBUF */ | |
| } | |
| } | |
| Device (RTC) | |
| { | |
| Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0070, // Range Minimum | |
| 0x0070, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| ) | |
| }) | |
| } | |
| 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 (PS2K) | |
| { | |
| Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP030B")) // _CID: Compatible ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0060, // Range Minimum | |
| 0x0060, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0064, // Range Minimum | |
| 0x0064, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {1} | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Device (PS2M) | |
| { | |
| Name (_HID, EisaId ("PNP0F13") /* PS/2 Mouse */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {12} | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| } | |
| Device (SATA) | |
| { | |
| Name (_ADR, 0x001F0002) // _ADR: Address | |
| } | |
| Device (SBUS) | |
| { | |
| Name (_ADR, 0x001F0003) // _ADR: Address | |
| } | |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities | |
| { | |
| If ((Arg0 == ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)) | |
| { | |
| Return (Arg3) | |
| } | |
| Else | |
| { | |
| CreateDWordField (Arg3, Zero, CDW1) | |
| CDW1 |= 0x04 | |
| Return (Arg3) | |
| } | |
| } | |
| } | |
| } |
This file contains hidden or 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 20180105 (64-bit version) | |
| * Copyright (c) 2000 - 2018 Intel Corporation | |
| * | |
| * Disassembling to symbolic ASL+ operators | |
| * | |
| * Disassembly of dsdt.dat, Tue Feb 18 09:44:07 2020 | |
| * | |
| * Original Table Header: | |
| * Signature "DSDT" | |
| * Length 0x000119A7 (72103) | |
| * Revision 0x01 **** 32-bit table (V1), no 64-bit math support | |
| * Checksum 0x78 | |
| * OEM ID "LENOVO" | |
| * OEM Table ID "TP-GL " | |
| * OEM Revision 0x00002540 (9536) | |
| * Compiler ID "INTL" | |
| * Compiler Version 0x20120711 (538052369) | |
| */ | |
| DefinitionBlock ("", "DSDT", 1, "LENOVO", "TP-GL ", 0x00002540) | |
| { | |
| /* | |
| * iASL Warning: There were 7 external control methods found during | |
| * disassembly, but only 0 were resolved (7 unresolved). Additional | |
| * ACPI tables may be required to properly disassemble the code. This | |
| * resulting disassembler output file may not compile because the | |
| * disassembler did not know how many arguments to assign to the | |
| * unresolved methods. Note: SSDTs can be dynamically loaded at | |
| * runtime and may or may not be available via the host OS. | |
| * | |
| * To specify the tables needed to resolve external control method | |
| * references, the -e option can be used to specify the filenames. | |
| * Example iASL invocations: | |
| * iasl -e ssdt1.aml ssdt2.aml ssdt3.aml -d dsdt.aml | |
| * iasl -e dsdt.aml ssdt2.aml -d ssdt1.aml | |
| * iasl -e ssdt*.aml -d dsdt.aml | |
| * | |
| * In addition, the -fe option can be used to specify a file containing | |
| * control method external declarations with the associated method | |
| * argument counts. Each line of the file must be of the form: | |
| * External (<method pathname>, MethodObj, <argument count>) | |
| * Invocation: | |
| * iasl -fe refs.txt -d dsdt.aml | |
| * | |
| * The following methods were unresolved and many not compile properly | |
| * because the disassembler had to guess at the number of arguments | |
| * required for each: | |
| */ | |
| External (_PR_.CPU0._PSS, IntObj) | |
| External (_SB_.IAOE.GAOS, UnknownObj) | |
| External (_SB_.IAOE.GSWR, UnknownObj) | |
| External (_SB_.PCCD, UnknownObj) | |
| External (_SB_.PCCD.PENB, UnknownObj) | |
| External (_SB_.PCI0.SAT1.PRIM.GTME, UnknownObj) | |
| External (_SB_.PCI0.SAT1.PRT5, UnknownObj) | |
| External (_SB_.PCI0.SAT1.SCND.GTME, UnknownObj) | |
| External (_SB_.PCI0.SAT1.SCND.MSTR, UnknownObj) | |
| External (_SB_.PCI0.VID_.AINT, MethodObj) // Warning: Unknown method, guessing 2 arguments | |
| External (_SB_.PCI0.VID_.DRDY, IntObj) | |
| External (_SB_.PCI0.VID_.GLIS, MethodObj) // Warning: Unknown method, guessing 1 arguments | |
| External (_SB_.PCI0.VID_.GSCI, MethodObj) // Warning: Unknown method, guessing 0 arguments | |
| External (_SB_.PCI0.VID_.GSSE, MethodObj) // Warning: Unknown method, guessing 1 arguments | |
| External (_SB_.PCI0.VID_.STAT, UnknownObj) | |
| External (_SB_.PCI0.VID_.TCHE, UnknownObj) | |
| External (CADL, UnknownObj) | |
| External (CAL2, UnknownObj) | |
| External (CAL3, UnknownObj) | |
| External (CAL4, UnknownObj) | |
| External (CAL5, UnknownObj) | |
| External (CAL6, UnknownObj) | |
| External (CAL7, UnknownObj) | |
| External (CAL8, UnknownObj) | |
| External (CLID, UnknownObj) | |
| External (CPDL, UnknownObj) | |
| External (CPL2, UnknownObj) | |
| External (CPL3, UnknownObj) | |
| External (CPL4, UnknownObj) | |
| External (CPL5, UnknownObj) | |
| External (CPL6, UnknownObj) | |
| External (CPL7, UnknownObj) | |
| External (CPL8, UnknownObj) | |
| External (DDL2, UnknownObj) | |
| External (DDL3, UnknownObj) | |
| External (DDL4, UnknownObj) | |
| External (DDL5, UnknownObj) | |
| External (DDL6, UnknownObj) | |
| External (DDL7, UnknownObj) | |
| External (DDL8, UnknownObj) | |
| External (DIDL, UnknownObj) | |
| External (GDCK, MethodObj) // Warning: Unknown method, guessing 1 arguments | |
| External (GHDS, MethodObj) // Warning: Unknown method, guessing 1 arguments | |
| External (GNOT, MethodObj) // Warning: Unknown method, guessing 2 arguments | |
| External (NADL, UnknownObj) | |
| External (NDID, UnknownObj) | |
| External (NDL2, UnknownObj) | |
| External (NDL3, UnknownObj) | |
| External (NDL4, UnknownObj) | |
| External (NDL5, UnknownObj) | |
| External (NDL6, UnknownObj) | |
| External (NDL7, UnknownObj) | |
| External (NDL8, UnknownObj) | |
| External (PDC0, UnknownObj) | |
| External (PDC1, UnknownObj) | |
| External (PDC2, UnknownObj) | |
| External (PDC3, UnknownObj) | |
| External (PDC4, UnknownObj) | |
| External (PDC5, UnknownObj) | |
| External (PDC6, UnknownObj) | |
| External (PDC7, UnknownObj) | |
| Scope (\_PR) | |
| { | |
| Processor (CPU0, 0x01, 0x00001810, 0x06){} | |
| Processor (CPU1, 0x02, 0x00001810, 0x06){} | |
| Processor (CPU2, 0x03, 0x00001810, 0x06){} | |
| Processor (CPU3, 0x04, 0x00001810, 0x06){} | |
| Processor (CPU4, 0x05, 0x00001810, 0x06){} | |
| Processor (CPU5, 0x06, 0x00001810, 0x06){} | |
| Processor (CPU6, 0x07, 0x00001810, 0x06){} | |
| Processor (CPU7, 0x08, 0x00001810, 0x06){} | |
| } | |
| Scope (\) | |
| { | |
| Method (PNTF, 1, NotSerialized) | |
| { | |
| If (((Arg0 == 0x80) && !\OSPX)) | |
| { | |
| If ((\PPMF & 0x01)) | |
| { | |
| If (\CPPX) | |
| { | |
| Notify (\_SB.PCCD, 0x82) // Device-Specific Change | |
| } | |
| } | |
| } | |
| ElseIf ((\PPMF & 0x0200)) | |
| { | |
| If ((((PDC0 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC0 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU0, Arg0) | |
| } | |
| If ((((PDC1 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC1 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU1, Arg0) | |
| } | |
| If ((((PDC2 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC2 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU2, Arg0) | |
| } | |
| If ((((PDC3 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC3 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU3, Arg0) | |
| } | |
| If ((((PDC4 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC4 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU4, Arg0) | |
| } | |
| If ((((PDC5 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC5 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU5, Arg0) | |
| } | |
| If ((((PDC6 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC6 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU6, Arg0) | |
| } | |
| If ((((PDC7 & 0x08) && ((Arg0 == 0x80) || ( | |
| Arg0 == 0x82))) || ((PDC7 & 0x10) && (Arg0 == 0x81)))) | |
| { | |
| Notify (\_PR.CPU7, Arg0) | |
| } | |
| } | |
| ElseIf (((Arg0 == 0x80) || ((Arg0 == 0x81) || (Arg0 == | |
| 0x82)))) | |
| { | |
| Notify (\_PR.CPU0, Arg0) | |
| } | |
| } | |
| } | |
| OperationRegion (MNVS, SystemMemory, 0x7CA7D018, 0x1000) | |
| Field (MNVS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0xD00), | |
| GAPA, 32, | |
| GAPL, 32, | |
| DCKI, 32, | |
| DCKS, 32, | |
| VCDL, 1, | |
| VCDC, 1, | |
| VCDT, 1, | |
| VCDD, 1, | |
| , 1, | |
| VCSS, 1, | |
| VCDB, 1, | |
| VCIN, 1, | |
| VVPO, 8, | |
| BRTN, 8, | |
| BRLV, 8, | |
| CDFL, 8, | |
| CDAH, 8, | |
| PMOD, 2, | |
| PDIR, 1, | |
| PDMA, 1, | |
| Offset (0xD17), | |
| LFDC, 1, | |
| Offset (0xD18), | |
| C2NA, 1, | |
| C3NA, 1, | |
| C4NA, 1, | |
| C6NA, 1, | |
| C7NA, 1, | |
| Offset (0xD19), | |
| Offset (0xD1A), | |
| , 2, | |
| , 1, | |
| NHPS, 1, | |
| NPME, 1, | |
| Offset (0xD1B), | |
| UOPT, 8, | |
| BTID, 32, | |
| DPP0, 1, | |
| DPP1, 1, | |
| DPP2, 1, | |
| DPP3, 1, | |
| DPP4, 1, | |
| DPP5, 1, | |
| Offset (0xD21), | |
| Offset (0xD22), | |
| TCRT, 16, | |
| TPSV, 16, | |
| TTC1, 16, | |
| TTC2, 16, | |
| TTSP, 16, | |
| SRAH, 8, | |
| SRHE, 8, | |
| SRE1, 8, | |
| SRE2, 8, | |
| SRE3, 8, | |
| SRE4, 8, | |
| SRE5, 8, | |
| SRE6, 8, | |
| SRU1, 8, | |
| SRU2, 8, | |
| SRU3, 8, | |
| SRU7, 8, | |
| SRU4, 8, | |
| SRU5, 8, | |
| SRU8, 8, | |
| SRPB, 8, | |
| SRLP, 8, | |
| SRSA, 8, | |
| SRSM, 8, | |
| CWAC, 1, | |
| CWAS, 1, | |
| CWUE, 1, | |
| CWUS, 1, | |
| Offset (0xD40), | |
| CWAP, 16, | |
| CWAT, 16, | |
| DBGC, 1, | |
| Offset (0xD45), | |
| FS1L, 16, | |
| FS1M, 16, | |
| FS1H, 16, | |
| FS2L, 16, | |
| FS2M, 16, | |
| FS2H, 16, | |
| FS3L, 16, | |
| FS3M, 16, | |
| FS3H, 16, | |
| TATC, 1, | |
| , 6, | |
| TATL, 1, | |
| TATW, 8, | |
| TNFT, 4, | |
| TNTT, 4, | |
| TDFA, 4, | |
| TDTA, 4, | |
| TDFD, 4, | |
| TDTD, 4, | |
| TCFA, 4, | |
| TCTA, 4, | |
| TCFD, 4, | |
| TCTD, 4, | |
| TSFT, 4, | |
| TSTT, 4, | |
| TIT0, 8, | |
| TCR0, 16, | |
| TPS0, 16, | |
| TIT1, 8, | |
| TCR1, 16, | |
| TPS1, 16, | |
| TIT2, 8, | |
| TCR2, 16, | |
| TPS2, 16, | |
| TIF0, 8, | |
| TIF1, 8, | |
| TIF2, 8, | |
| Offset (0xD78), | |
| BTHI, 1, | |
| Offset (0xD79), | |
| HDIR, 1, | |
| HDEH, 1, | |
| HDSP, 1, | |
| HDPP, 1, | |
| HDUB, 1, | |
| HDMC, 1, | |
| NFCF, 1, | |
| Offset (0xD7A), | |
| TPME, 8, | |
| BIDE, 4, | |
| IDET, 4, | |
| , 1, | |
| DTSE, 1, | |
| Offset (0xD7D), | |
| DTS0, 8, | |
| DTS1, 8, | |
| DT00, 1, | |
| DT01, 1, | |
| DT02, 1, | |
| DT03, 1, | |
| Offset (0xD80), | |
| LIDB, 1, | |
| C4WR, 1, | |
| C4AC, 1, | |
| ODDX, 1, | |
| CMPR, 1, | |
| ILNF, 1, | |
| PLUX, 1, | |
| Offset (0xD81), | |
| Offset (0xD8C), | |
| , 4, | |
| , 1, | |
| IDMM, 1, | |
| Offset (0xD8D), | |
| , 3, | |
| , 1, | |
| , 1, | |
| LIDS, 1, | |
| Offset (0xD8E), | |
| Offset (0xD8F), | |
| , 4, | |
| Offset (0xD90), | |
| TCG0, 1, | |
| TCG1, 1, | |
| Offset (0xD91), | |
| SWGP, 8, | |
| IPMS, 8, | |
| IPMB, 120, | |
| IPMR, 24, | |
| IPMO, 24, | |
| IPMA, 8, | |
| VIGD, 1, | |
| VDSC, 1, | |
| VMSH, 1, | |
| , 1, | |
| VDSP, 1, | |
| Offset (0xDAA), | |
| Offset (0xDAD), | |
| ASFT, 8, | |
| PL1L, 8, | |
| PL1M, 8, | |
| CHKC, 32, | |
| CHKE, 32, | |
| ATRB, 32, | |
| Offset (0xDBD), | |
| PPCR, 8, | |
| TPCR, 5, | |
| Offset (0xDBF), | |
| Offset (0xDCE), | |
| CTDP, 8, | |
| PPCA, 8, | |
| TPCA, 5, | |
| Offset (0xDD1), | |
| BFWB, 296, | |
| OSPX, 1, | |
| OSC4, 1, | |
| CPPX, 1, | |
| Offset (0xDF7), | |
| SPEN, 1, | |
| SCRM, 1, | |
| GFPL, 1, | |
| ETAU, 1, | |
| IHBC, 1, | |
| APMD, 1, | |
| APMF, 1, | |
| Offset (0xDF8), | |
| FTPS, 8, | |
| HIST, 8, | |
| LPST, 8, | |
| LWST, 8, | |
| Offset (0xDFF), | |
| MTAU, 8, | |
| Offset (0xE20), | |
| HPET, 32, | |
| PKLI, 16, | |
| VLCX, 16, | |
| VNIT, 8, | |
| VBD0, 8, | |
| VBDT, 128, | |
| VBPL, 16, | |
| VBPH, 16, | |
| VBML, 8, | |
| VBMH, 8, | |
| VEDI, 1024, | |
| PDCI, 16, | |
| ISCG, 32, | |
| ISSP, 1, | |
| ISWK, 2, | |
| Offset (0xEC7), | |
| SHA1, 160, | |
| FFDT, 1, | |
| Offset (0xEDC), | |
| LWCP, 1, | |
| LWEN, 1, | |
| IOCP, 1, | |
| IOEN, 1, | |
| IOST, 1, | |
| Offset (0xEDD), | |
| USBR, 1, | |
| Offset (0xEDE), | |
| Offset (0xEDF), | |
| Offset (0xEE1), | |
| BT2T, 1, | |
| Offset (0xEE2), | |
| TPPP, 8, | |
| TPPC, 8, | |
| WKRS, 8, | |
| FNWK, 8, | |
| USBC, 8, | |
| XHCC, 8, | |
| ODDF, 8 | |
| } | |
| Field (MNVS, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xB00), | |
| WITM, 8, | |
| WSEL, 8, | |
| WLS0, 8, | |
| WLS1, 8, | |
| WLS2, 8, | |
| WLS3, 8, | |
| WLS4, 8, | |
| WLS5, 8, | |
| WLS6, 8, | |
| WLS7, 8, | |
| WLS8, 8, | |
| WLS9, 8, | |
| WLSA, 8, | |
| WLSB, 8, | |
| WLSC, 8, | |
| WLSD, 8, | |
| WENC, 8, | |
| WKBD, 8, | |
| WPTY, 8, | |
| WPAS, 1032, | |
| WPNW, 1032, | |
| WSPM, 8, | |
| WSPS, 8, | |
| WSMN, 8, | |
| WSMX, 8, | |
| WSEN, 8, | |
| WSKB, 8, | |
| WASB, 8, | |
| WASI, 16, | |
| WASD, 8, | |
| WASS, 32 | |
| } | |
| Field (MNVS, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA00), | |
| DBGS, 1024 | |
| } | |
| OperationRegion (GNVS, SystemMemory, 0x7C97BC18, 0x02B0) | |
| Field (GNVS, AnyAcc, Lock, Preserve) | |
| { | |
| OSYS, 16, | |
| SMIF, 8, | |
| PRM0, 8, | |
| PRM1, 8, | |
| Offset (0x0F), | |
| PWRS, 8, | |
| Offset (0x1E), | |
| Offset (0x25), | |
| REVN, 8, | |
| IFFS, 8, | |
| Offset (0x28), | |
| APIC, 8, | |
| TCNT, 8, | |
| PCP0, 8, | |
| PCP1, 8, | |
| PPCM, 8, | |
| PPMF, 32, | |
| C67L, 8, | |
| Offset (0x47), | |
| TPMP, 8, | |
| MORD, 8, | |
| TCGP, 8, | |
| PPRP, 32, | |
| PPRQ, 8, | |
| LPPR, 8, | |
| GTF0, 56, | |
| GTF2, 56, | |
| IDEM, 8, | |
| GTF1, 56, | |
| BID, 16, | |
| PLID, 8, | |
| ECTG, 8, | |
| ISCT, 8, | |
| SLDR, 32, | |
| WAKR, 8, | |
| OSCC, 8, | |
| NEXP, 8, | |
| SBV1, 8, | |
| SBV2, 8, | |
| Offset (0x7A), | |
| DSEN, 8, | |
| ECON, 8, | |
| Offset (0x7D), | |
| CTYP, 8, | |
| L01C, 8, | |
| VFN0, 8, | |
| VFN1, 8, | |
| VFN2, 8, | |
| VFN3, 8, | |
| VFN4, 8, | |
| VFN5, 8, | |
| VFN6, 8, | |
| VFN7, 8, | |
| VFN8, 8, | |
| VFN9, 8, | |
| Offset (0x8F), | |
| ATMC, 8, | |
| PTMC, 8, | |
| ATRA, 8, | |
| PTRA, 8, | |
| PNHM, 32, | |
| TBAB, 32, | |
| TBAH, 32, | |
| RTIP, 8, | |
| TSOD, 8, | |
| ATPC, 8, | |
| PTPC, 8, | |
| PFLV, 8, | |
| BREV, 8, | |
| PDTS, 8, | |
| PKGA, 8, | |
| PAMT, 8, | |
| AC0F, 8, | |
| AC1F, 8, | |
| DTS3, 8, | |
| DTS4, 8, | |
| Offset (0xB0), | |
| LTR1, 8, | |
| LTR2, 8, | |
| LTR3, 8, | |
| LTR4, 8, | |
| LTR5, 8, | |
| LTR6, 8, | |
| LTR7, 8, | |
| LTR8, 8, | |
| OBF1, 8, | |
| OBF2, 8, | |
| OBF3, 8, | |
| OBF4, 8, | |
| OBF5, 8, | |
| OBF6, 8, | |
| OBF7, 8, | |
| OBF8, 8, | |
| XHCI, 8, | |
| XTUB, 32, | |
| XTUS, 32, | |
| XMPB, 32, | |
| DDRF, 8, | |
| RTD3, 8, | |
| PEP0, 8, | |
| PEP3, 8, | |
| DPTF, 8, | |
| SADE, 8, | |
| SACR, 8, | |
| SAHT, 8, | |
| PCHD, 8, | |
| PCHC, 8, | |
| PCHH, 8, | |
| Offset (0xDB), | |
| ECEU, 8, | |
| TGFG, 16, | |
| MEMD, 8, | |
| MEMC, 8, | |
| MEMH, 8, | |
| FND1, 8, | |
| FND2, 8, | |
| AMBD, 8, | |
| AMAT, 8, | |
| AMPT, 8, | |
| AMCT, 8, | |
| AMHT, 8, | |
| SKDE, 8, | |
| SKAT, 8, | |
| SKPT, 8, | |
| SKCT, 8, | |
| SKHT, 8, | |
| EFDE, 8, | |
| EFAT, 8, | |
| EFPT, 8, | |
| EFCT, 8, | |
| EFHT, 8, | |
| VRDE, 8, | |
| VRAT, 8, | |
| VRPT, 8, | |
| VRCT, 8, | |
| VRHT, 8, | |
| DPAP, 8, | |
| DPPP, 8, | |
| DPCP, 8, | |
| DCMP, 8, | |
| TRTV, 8, | |
| LPOE, 8, | |
| LPOP, 8, | |
| LPOS, 8, | |
| LPOW, 8, | |
| LPER, 8, | |
| PPSZ, 32, | |
| DISE, 8, | |
| PFMA, 64, | |
| PFMS, 8, | |
| PFIA, 16, | |
| ICNF, 8, | |
| DSP0, 32, | |
| DSP1, 32, | |
| NFCE, 8, | |
| CODS, 8, | |
| SNHE, 8, | |
| S0ID, 8, | |
| CTDB, 8, | |
| Offset (0x121), | |
| TBTE, 8, | |
| Offset (0x207), | |
| PWRE, 8, | |
| PWRP, 8, | |
| XHPR, 8, | |
| SDS0, 8, | |
| SDS1, 16, | |
| SDS2, 8, | |
| SDS3, 8, | |
| SDS4, 8, | |
| SDS5, 8, | |
| Offset (0x212), | |
| RIC0, 8, | |
| PEPY, 8, | |
| DVS0, 8, | |
| DVS1, 8, | |
| DVS2, 8, | |
| DVS3, 8, | |
| GBSX, 8, | |
| IUBE, 8, | |
| IUCE, 8, | |
| IUDE, 8, | |
| ECNO, 8, | |
| AUDD, 16, | |
| DSPD, 16, | |
| IC0D, 16, | |
| IC1D, 16, | |
| IC1S, 16, | |
| VRRD, 16, | |
| PSCP, 8, | |
| RWAG, 8, | |
| I20D, 16, | |
| I21D, 16, | |
| Offset (0x231), | |
| RCG0, 8, | |
| ECDB, 8, | |
| P2ME, 8, | |
| SSH0, 16, | |
| SSL0, 16, | |
| SSD0, 16, | |
| FMH0, 16, | |
| FML0, 16, | |
| FMD0, 16, | |
| FPH0, 16, | |
| FPL0, 16, | |
| FPD0, 16, | |
| SSH1, 16, | |
| SSL1, 16, | |
| SSD1, 16, | |
| FMH1, 16, | |
| FML1, 16, | |
| FMD1, 16, | |
| FPH1, 16, | |
| FPL1, 16, | |
| FPD1, 16, | |
| M0C0, 16, | |
| M1C0, 16, | |
| M2C0, 16, | |
| M0C1, 16, | |
| M1C1, 16, | |
| M2C1, 16, | |
| M0C2, 16, | |
| M1C2, 16, | |
| M0C3, 16, | |
| M1C3, 16, | |
| M0C4, 16, | |
| M1C4, 16, | |
| M0C5, 16, | |
| M1C5, 16, | |
| TBSF, 8, | |
| GIRQ, 32, | |
| DMTP, 8, | |
| DMTD, 8, | |
| DMSH, 8, | |
| LANP, 8, | |
| Offset (0x27E), | |
| SHSB, 8, | |
| PLCS, 8, | |
| PLVL, 16, | |
| GN1E, 8, | |
| G1AT, 8, | |
| G1PT, 8, | |
| G1CT, 8, | |
| G1HT, 8, | |
| GN2E, 8, | |
| G2AT, 8, | |
| G2PT, 8, | |
| G2CT, 8, | |
| G2HT, 8, | |
| WWSD, 8, | |
| CVSD, 8, | |
| SSDD, 8, | |
| INLD, 8, | |
| IFAT, 8, | |
| IFPT, 8, | |
| IFCT, 8, | |
| IFHT, 8, | |
| DOSD, 8, | |
| USBH, 8, | |
| BCV4, 8, | |
| WTV0, 8, | |
| WTV1, 8, | |
| APFU, 8, | |
| SOHP, 8, | |
| NOHP, 8, | |
| TBSE, 8, | |
| WKFN, 8, | |
| PEPC, 16, | |
| VRSD, 16, | |
| PB1E, 8, | |
| WAND, 8, | |
| WWAT, 8, | |
| WWPT, 8, | |
| WWCT, 8, | |
| WWHT, 8, | |
| Offset (0x2AD), | |
| MPLT, 16, | |
| GR13, 8 | |
| } | |
| Name (XWMB, 0x7FA00000) | |
| Scope (\_SB) | |
| { | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| If (CondRefOf (\_OSI, Local0)) | |
| { | |
| If (\_OSI ("Windows 2001")) | |
| { | |
| \WNTF = 0x01 | |
| \WXPF = 0x01 | |
| \WSPV = 0x00 | |
| OSYS = 0x07D1 | |
| } | |
| If (\_OSI ("Windows 2001 SP1")) | |
| { | |
| \WSPV = 0x01 | |
| OSYS = 0x07D1 | |
| } | |
| If (\_OSI ("Windows 2001 SP2")) | |
| { | |
| \WSPV = 0x02 | |
| OSYS = 0x07D2 | |
| } | |
| If (\_OSI ("Windows 2006")) | |
| { | |
| \WVIS = 0x01 | |
| OSYS = 0x07D6 | |
| } | |
| If (\_OSI ("Windows 2009")) | |
| { | |
| \WIN7 = 0x01 | |
| OSYS = 0x07D9 | |
| } | |
| If (\_OSI ("Windows 2012")) | |
| { | |
| \WIN8 = 0x01 | |
| OSYS = 0x07DC | |
| } | |
| If (\_OSI ("Windows 2013")) | |
| { | |
| \WIN8 = 0x01 | |
| OSYS = 0x07DD | |
| } | |
| If (\_OSI ("Windows 2015")) | |
| { | |
| \WIN8 = 0x01 | |
| OSYS = 0x07DF | |
| } | |
| If (\_OSI ("Linux")) | |
| { | |
| \LNUX = 0x01 | |
| OSYS = 0x03E8 | |
| } | |
| If (\_OSI ("FreeBSD")) | |
| { | |
| \LNUX = 0x01 | |
| OSYS = 0x03E8 | |
| } | |
| } | |
| ElseIf ((\SCMP (\_OS, "Microsoft Windows NT") == Zero)) | |
| { | |
| \WNTF = 0x01 | |
| } | |
| If ((\_REV >= 0x02)) | |
| { | |
| \H8DR = 0x01 | |
| } | |
| \OSIF = 0x01 | |
| \PWRS = \_SB.PCI0.LPC.EC.AC._PSR () | |
| \_SB.PCI0.LPC.MOU.MHID () | |
| If (\LNUX) | |
| { | |
| \_SB.PCI0.LPC.EC.SAUM (0x02) | |
| \UCMS (0x1C) | |
| } | |
| \_SB.PCI0.RID = \SRAH | |
| If (VIGD) | |
| { | |
| \_SB.PCI0.VID.RID = \SRHE | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.PEG.RID = \SRHE | |
| } | |
| \_SB.PCI0.EXP1.RID = \SRE1 | |
| \_SB.PCI0.EXP2.RID = \SRE2 | |
| \_SB.PCI0.EXP3.RID = \SRE3 | |
| \_SB.PCI0.EXP6.RID = \SRE4 | |
| \_SB.PCI0.EHC1.RID = \SRU7 | |
| \_SB.PCI0.LPC.RID = \SRLP | |
| \_SB.PCI0.SAT1.RID = \SRSA | |
| \_SB.PCI0.SMBU.RID = \SRSM | |
| \UCMS (0x1D) | |
| } | |
| Method (_OSC, 4, Serialized) // _OSC: Operating System Capabilities | |
| { | |
| CreateDWordField (Arg3, 0x00, STS0) | |
| CreateDWordField (Arg3, 0x04, CAP0) | |
| If ((Arg0 == ToUUID ("0811b06e-4a27-44f9-8d60-3cbbc22e7b48") /* Platform-wide Capabilities */)) | |
| { | |
| If ((Arg1 == One)) | |
| { | |
| If ((CAP0 & 0x04)) | |
| { | |
| If (!VMSH) | |
| { | |
| If ((RTD3 == 0x00)) | |
| { | |
| CAP0 &= 0x3B | |
| STS0 |= 0x10 | |
| } | |
| } | |
| } | |
| If ((CAP0 & 0x20)) | |
| { | |
| If (CondRefOf (\_SB.PCCD.PENB)) | |
| { | |
| If ((\_SB.PCCD.PENB == 0x00)) | |
| { | |
| CAP0 &= 0x1F | |
| STS0 |= 0x10 | |
| } | |
| If ((\_SB.PCCD.PENB == 0x01)) | |
| { | |
| \CPPX = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| CAP0 &= 0x1F | |
| STS0 |= 0x10 | |
| } | |
| } | |
| } | |
| Else | |
| { | |
| STS0 &= 0xFFFFFF00 | |
| STS0 |= 0x0A | |
| } | |
| } | |
| Else | |
| { | |
| STS0 &= 0xFFFFFF00 | |
| STS0 |= 0x06 | |
| } | |
| Return (Arg3) | |
| } | |
| Device (LNKA) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x01) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRA)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRA |= 0x80 | |
| } | |
| Name (BUFA, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y00) | |
| {} | |
| }) | |
| CreateWordField (BUFA, \_SB.LNKA._Y00._INT, IRA1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRA & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRA1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRA1 = 0x00 | |
| } | |
| Return (BUFA) /* \_SB_.LNKA.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRA2) | |
| FindSetRightBit (IRA2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRA & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRA = Local1 | |
| } | |
| } | |
| Device (LNKB) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRB)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRB |= 0x80 | |
| } | |
| Name (BUFB, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y01) | |
| {} | |
| }) | |
| CreateWordField (BUFB, \_SB.LNKB._Y01._INT, IRB1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRB & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRB1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRB1 = 0x00 | |
| } | |
| Return (BUFB) /* \_SB_.LNKB.BUFB */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRB2) | |
| FindSetRightBit (IRB2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRB & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRB = Local1 | |
| } | |
| } | |
| Device (LNKC) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRC)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRC |= 0x80 | |
| } | |
| Name (BUFC, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y02) | |
| {} | |
| }) | |
| CreateWordField (BUFC, \_SB.LNKC._Y02._INT, IRC1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRC & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRC1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRC1 = 0x00 | |
| } | |
| Return (BUFC) /* \_SB_.LNKC.BUFC */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRC2) | |
| FindSetRightBit (IRC2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRC & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRC = Local1 | |
| } | |
| } | |
| Device (LNKD) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRD)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRD |= 0x80 | |
| } | |
| Name (BUFD, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y03) | |
| {} | |
| }) | |
| CreateWordField (BUFD, \_SB.LNKD._Y03._INT, IRD1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRD & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRD1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRD1 = 0x00 | |
| } | |
| Return (BUFD) /* \_SB_.LNKD.BUFD */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRD2) | |
| FindSetRightBit (IRD2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRD & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRD = Local1 | |
| } | |
| } | |
| Device (LNKE) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x05) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRE)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRE |= 0x80 | |
| } | |
| Name (BUFE, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y04) | |
| {} | |
| }) | |
| CreateWordField (BUFE, \_SB.LNKE._Y04._INT, IRE1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRE & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRE1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRE1 = 0x00 | |
| } | |
| Return (BUFE) /* \_SB_.LNKE.BUFE */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRE2) | |
| FindSetRightBit (IRE2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRE & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRE = Local1 | |
| } | |
| } | |
| Device (LNKF) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x06) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRF)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRF |= 0x80 | |
| } | |
| Name (BUFF, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y05) | |
| {} | |
| }) | |
| CreateWordField (BUFF, \_SB.LNKF._Y05._INT, IRF1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRF & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRF1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRF1 = 0x00 | |
| } | |
| Return (BUFF) /* \_SB_.LNKF.BUFF */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRF2) | |
| FindSetRightBit (IRF2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRF & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRF = Local1 | |
| } | |
| } | |
| Device (LNKG) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x07) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRG)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRG |= 0x80 | |
| } | |
| Name (BUFG, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y06) | |
| {} | |
| }) | |
| CreateWordField (BUFG, \_SB.LNKG._Y06._INT, IRG1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRG & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRG1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRG1 = 0x00 | |
| } | |
| Return (BUFG) /* \_SB_.LNKG.BUFG */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRG2) | |
| FindSetRightBit (IRG2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRG & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRG = Local1 | |
| } | |
| } | |
| Device (LNKH) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x08) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (!VPIR (\_SB.PCI0.LPC.PIRH)) | |
| { | |
| Return (0x09) | |
| } | |
| Else | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,4,5,6,7,9,10,11} | |
| }) | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| \_SB.PCI0.LPC.PIRH |= 0x80 | |
| } | |
| Name (BUFH, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, _Y07) | |
| {} | |
| }) | |
| CreateWordField (BUFH, \_SB.LNKH._Y07._INT, IRH1) // _INT: Interrupts | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.LPC.PIRH & 0x8F) | |
| If (VPIR (Local0)) | |
| { | |
| IRH1 = (0x01 << Local0) | |
| } | |
| Else | |
| { | |
| IRH1 = 0x00 | |
| } | |
| Return (BUFH) /* \_SB_.LNKH.BUFH */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, 0x01, IRH2) | |
| FindSetRightBit (IRH2, Local0) | |
| Local1 = (\_SB.PCI0.LPC.PIRH & 0x70) | |
| Local1 |= Local0-- | |
| \_SB.PCI0.LPC.PIRH = Local1 | |
| } | |
| } | |
| Method (VPIR, 1, NotSerialized) | |
| { | |
| Local0 = 0x01 | |
| If ((Arg0 & 0x80)) | |
| { | |
| Local0 = 0x00 | |
| } | |
| Else | |
| { | |
| Local1 = (Arg0 & 0x0F) | |
| If ((Local1 < 0x03)) | |
| { | |
| Local0 = 0x00 | |
| } | |
| ElseIf (((Local1 == 0x08) || (Local1 == 0x0D))) | |
| { | |
| Local0 = 0x00 | |
| } | |
| } | |
| Return (Local0) | |
| } | |
| Device (MEM) | |
| { | |
| Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID | |
| Name (MEMS, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadWrite, | |
| 0x00000000, // Address Base | |
| 0x000A0000, // Address Length | |
| ) | |
| Memory32Fixed (ReadOnly, | |
| 0x000C0000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y08) | |
| Memory32Fixed (ReadOnly, | |
| 0x000C4000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y09) | |
| Memory32Fixed (ReadOnly, | |
| 0x000C8000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0A) | |
| Memory32Fixed (ReadOnly, | |
| 0x000CC000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0B) | |
| Memory32Fixed (ReadOnly, | |
| 0x000D0000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0C) | |
| Memory32Fixed (ReadOnly, | |
| 0x000D4000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0D) | |
| Memory32Fixed (ReadOnly, | |
| 0x000D8000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0E) | |
| Memory32Fixed (ReadOnly, | |
| 0x000DC000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y0F) | |
| Memory32Fixed (ReadOnly, | |
| 0x000E0000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y10) | |
| Memory32Fixed (ReadOnly, | |
| 0x000E4000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y11) | |
| Memory32Fixed (ReadOnly, | |
| 0x000E8000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y12) | |
| Memory32Fixed (ReadOnly, | |
| 0x000EC000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y13) | |
| Memory32Fixed (ReadOnly, | |
| 0x000F0000, // Address Base | |
| 0x00010000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0x00100000, // Address Base | |
| 0x01EE0000, // Address Length | |
| _Y14) | |
| Memory32Fixed (ReadOnly, | |
| 0xFEC00000, // Address Base | |
| 0x00140000, // Address Length | |
| _Y15) | |
| Memory32Fixed (ReadOnly, | |
| 0xFED4C000, // Address Base | |
| 0x012B4000, // Address Length | |
| _Y16) | |
| }) | |
| CreateDWordField (MEMS, \_SB.MEM._Y08._LEN, MC0L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y09._LEN, MC4L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0A._LEN, MC8L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0B._LEN, MCCL) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0C._LEN, MD0L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0D._LEN, MD4L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0E._LEN, MD8L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y0F._LEN, MDCL) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y10._LEN, ME0L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y11._LEN, ME4L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y12._LEN, ME8L) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y13._LEN, MECL) // _LEN: Length | |
| CreateBitField (MEMS, \_SB.MEM._Y08._RW, MC0W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y09._RW, MC4W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0A._RW, MC8W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0B._RW, MCCW) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0C._RW, MD0W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0D._RW, MD4W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0E._RW, MD8W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y0F._RW, MDCW) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y10._RW, ME0W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y11._RW, ME4W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y12._RW, ME8W) // _RW_: Read-Write Status | |
| CreateBitField (MEMS, \_SB.MEM._Y13._RW, MECW) // _RW_: Read-Write Status | |
| CreateDWordField (MEMS, \_SB.MEM._Y14._BAS, MEB1) // _BAS: Base Address | |
| CreateDWordField (MEMS, \_SB.MEM._Y14._LEN, MEL1) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y15._LEN, MEL2) // _LEN: Length | |
| CreateDWordField (MEMS, \_SB.MEM._Y16._LEN, MEL3) // _LEN: Length | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Local0 = (\_SB.PCI0.PAM1 & 0x03) | |
| If (Local0) | |
| { | |
| MC0L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| MC0W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM1 & 0x30) | |
| If (Local0) | |
| { | |
| MC4L = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| MC4W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM2 & 0x03) | |
| If (Local0) | |
| { | |
| MC8L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| MC8W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM2 & 0x30) | |
| If (Local0) | |
| { | |
| MCCL = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| MCCW = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM3 & 0x03) | |
| If (Local0) | |
| { | |
| MD0L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| MD0W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM3 & 0x30) | |
| If (Local0) | |
| { | |
| MD4L = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| MD4W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM4 & 0x03) | |
| If (Local0) | |
| { | |
| MD8L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| MD8W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM4 & 0x30) | |
| If (Local0) | |
| { | |
| MDCL = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| MDCW = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM5 & 0x03) | |
| If (Local0) | |
| { | |
| ME0L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| ME0W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM5 & 0x30) | |
| If (Local0) | |
| { | |
| ME4L = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| ME4W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM6 & 0x03) | |
| If (Local0) | |
| { | |
| ME8L = 0x4000 | |
| If ((Local0 & 0x02)) | |
| { | |
| ME8W = 0x01 | |
| } | |
| } | |
| Local0 = (\_SB.PCI0.PAM6 & 0x30) | |
| If (Local0) | |
| { | |
| MECL = 0x4000 | |
| If ((Local0 & 0x20)) | |
| { | |
| MECW = 0x01 | |
| } | |
| } | |
| MEL1 = (\MEMX - MEB1) /* \_SB_.MEM_.MEB1 */ | |
| If ((\_SB.PCI0.LPC.TPM._STA () != 0x0F)) | |
| { | |
| MEL2 = 0x01400000 | |
| MEL3 = 0x00 | |
| } | |
| Return (MEMS) /* \_SB_.MEM_.MEMS */ | |
| } | |
| } | |
| Device (LID) | |
| { | |
| Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID | |
| Method (_LID, 0, NotSerialized) // _LID: Lid Status | |
| { | |
| If (((\ILNF == 0x00) && (\PLUX == 0x00))) | |
| { | |
| If (\H8DR) | |
| { | |
| Return (\_SB.PCI0.LPC.EC.HPLD) | |
| } | |
| ElseIf ((\RBEC (0x46) & 0x04)) | |
| { | |
| Return (0x01) | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Else | |
| { | |
| Return (0x01) | |
| } | |
| } | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If (\LWCP) | |
| { | |
| Return (Package (0x02) | |
| { | |
| 0x1D, | |
| 0x04 | |
| }) | |
| } | |
| Else | |
| { | |
| Return (Package (0x02) | |
| { | |
| 0x1D, | |
| 0x03 | |
| }) | |
| } | |
| } | |
| Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake | |
| { | |
| If (\H8DR) | |
| { | |
| If (Arg0) | |
| { | |
| \_SB.PCI0.LPC.EC.HWLO = 0x01 | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HWLO = 0x00 | |
| } | |
| } | |
| ElseIf (Arg0) | |
| { | |
| \MBEC (0x32, 0xFF, 0x04) | |
| } | |
| Else | |
| { | |
| \MBEC (0x32, 0xFB, 0x00) | |
| } | |
| If (\LWCP) | |
| { | |
| If (Arg0) | |
| { | |
| \LWEN = 0x01 | |
| } | |
| Else | |
| { | |
| \LWEN = 0x00 | |
| } | |
| } | |
| } | |
| } | |
| Device (SLPB) | |
| { | |
| Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */) // _HID: Hardware ID | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (Package (0x02) | |
| { | |
| 0x1D, | |
| 0x03 | |
| }) | |
| } | |
| Method (_PSW, 1, NotSerialized) // _PSW: Power State Wake | |
| { | |
| If (\H8DR) | |
| { | |
| If (Arg0) | |
| { | |
| \_SB.PCI0.LPC.EC.HWFN = 0x01 | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HWFN = 0x00 | |
| } | |
| } | |
| ElseIf (Arg0) | |
| { | |
| \MBEC (0x32, 0xFF, 0x10) | |
| } | |
| Else | |
| { | |
| \MBEC (0x32, 0xEF, 0x00) | |
| } | |
| } | |
| } | |
| Scope (\) | |
| { | |
| Name (UPC0, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD0, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x99, 0x11, 0x80, 0x00, 0x03, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD1, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x91, 0x12, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| Name (UPC2, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD2, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x69, 0x0C, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 // i....... | |
| }) | |
| Name (UPC4, Package (0x04) | |
| { | |
| 0xFF, | |
| 0xFF, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD4, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x30, 0x1C, 0x80, 0x01, 0x03, 0x00, 0x00, 0x00 // 0....... | |
| }) | |
| Name (UPC5, Package (0x04) | |
| { | |
| 0x00, | |
| 0x02, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD5, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x48, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // H....... | |
| }) | |
| Name (UPCN, Package (0x04) | |
| { | |
| 0x00, | |
| 0xFF, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLDN, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 0....... | |
| }) | |
| Name (UPC9, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLD9, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x59, 0x12, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 // Y....... | |
| }) | |
| Name (UPCI, Package (0x04) | |
| { | |
| 0x00, | |
| 0xFF, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (PLDI, Buffer (0x10) | |
| { | |
| /* 0000 */ 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x30, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 0....... | |
| }) | |
| Name (PLDC, Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x24, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // $....... | |
| /* 0010 */ 0xDD, 0x00, 0x95, 0x00 // .... | |
| }) | |
| } | |
| Name (XWMB, 0xFFFFFFFF) | |
| Device (PCI0) | |
| { | |
| Name (_BBN, 0x00) // _BBN: BIOS Bus Number | |
| Name (_ADR, 0x00) // _ADR: Address | |
| Name (RID, 0x00) | |
| Name (_S3D, 0x02) // _S3D: S3 Device State | |
| Name (LRRT, Package (0x17) | |
| { | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0003FFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x01, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x02, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x03, | |
| \_SB.LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0019FFFF, | |
| 0x00, | |
| \_SB.LNKE, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001AFFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001BFFFF, | |
| 0x00, | |
| \_SB.LNKG, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x01, | |
| \_SB.LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x02, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x03, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x00, | |
| \_SB.LNKH, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x01, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x02, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x03, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x00, | |
| \_SB.LNKF, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x01, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x02, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x03, | |
| \_SB.LNKA, | |
| 0x00 | |
| } | |
| }) | |
| Name (ARRT, Package (0x17) | |
| { | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0003FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x01, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x02, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0016FFFF, | |
| 0x03, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0019FFFF, | |
| 0x00, | |
| 0x00, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001AFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001BFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001CFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x17 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001DFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x15 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x001FFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x10 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (ARRT) /* \_SB_.PCI0.ARRT */ | |
| } | |
| Else | |
| { | |
| Return (LRRT) /* \_SB_.PCI0.LRRT */ | |
| } | |
| } | |
| Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID | |
| OperationRegion (MHCS, PCI_Config, 0x40, 0xC0) | |
| Field (MHCS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x40), | |
| PAM0, 8, | |
| PAM1, 8, | |
| PAM2, 8, | |
| PAM3, 8, | |
| PAM4, 8, | |
| PAM5, 8, | |
| PAM6, 8, | |
| Offset (0x7C), | |
| , 20, | |
| TLUD, 12 | |
| } | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, | |
| 0x0000, // Granularity | |
| 0x0000, // Range Minimum | |
| 0x00FF, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0x0100, // Length | |
| ,, _Y25) | |
| IO (Decode16, | |
| 0x0CF8, // Range Minimum | |
| 0x0CF8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| ) | |
| WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
| 0x0000, // Granularity | |
| 0x0000, // Range Minimum | |
| 0x0CF7, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0x0CF8, // Length | |
| ,, , TypeStatic, DenseTranslation) | |
| WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
| 0x0000, // Granularity | |
| 0x0D00, // Range Minimum | |
| 0xFFFF, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0xF300, // Length | |
| ,, , TypeStatic, DenseTranslation) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000A0000, // Range Minimum | |
| 0x000BFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00020000, // Length | |
| ,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C0000, // Range Minimum | |
| 0x000C3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y17, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C4000, // Range Minimum | |
| 0x000C7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y18, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000C8000, // Range Minimum | |
| 0x000CBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y19, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000CC000, // Range Minimum | |
| 0x000CFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1A, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D0000, // Range Minimum | |
| 0x000D3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1B, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D4000, // Range Minimum | |
| 0x000D7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1C, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D8000, // Range Minimum | |
| 0x000DBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1D, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000DC000, // Range Minimum | |
| 0x000DFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1E, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E0000, // Range Minimum | |
| 0x000E3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y1F, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E4000, // Range Minimum | |
| 0x000E7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y20, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E8000, // Range Minimum | |
| 0x000EBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y21, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000EC000, // Range Minimum | |
| 0x000EFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| ,, _Y22, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x00100000, // Range Minimum | |
| 0xFEBFFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0xFEB00000, // Length | |
| ,, _Y23, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFED40000, // Range Minimum | |
| 0xFED4BFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x0000C000, // Length | |
| ,, _Y24, AddressRangeMemory, TypeStatic) | |
| }) | |
| CreateDWordField (_CRS, \_SB.PCI0._Y17._LEN, C0LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y18._LEN, C4LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y19._LEN, C8LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1A._LEN, CCLN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1B._LEN, D0LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1C._LEN, D4LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1D._LEN, D8LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1E._LEN, DCLN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y1F._LEN, E0LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y20._LEN, E4LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y21._LEN, E8LN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y22._LEN, ECLN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y23._MIN, XXMN) // _MIN: Minimum Base Address | |
| CreateDWordField (_CRS, \_SB.PCI0._Y23._MAX, XXMX) // _MAX: Maximum Base Address | |
| CreateDWordField (_CRS, \_SB.PCI0._Y23._LEN, XXLN) // _LEN: Length | |
| CreateDWordField (_CRS, \_SB.PCI0._Y24._MIN, F4MN) // _MIN: Minimum Base Address | |
| CreateDWordField (_CRS, \_SB.PCI0._Y24._MAX, F4MX) // _MAX: Maximum Base Address | |
| CreateDWordField (_CRS, \_SB.PCI0._Y24._LEN, F4LN) // _LEN: Length | |
| CreateWordField (_CRS, \_SB.PCI0._Y25._MAX, B0MX) // _MAX: Maximum Base Address | |
| CreateWordField (_CRS, \_SB.PCI0._Y25._LEN, B0LN) // _LEN: Length | |
| Method (_INI, 0, Serialized) // _INI: Initialize | |
| { | |
| B0MX = 0x3F | |
| B0LN = (0x3F + 0x01) | |
| If (!\OSIF) | |
| { | |
| \_SB._INI () | |
| } | |
| Local0 = (TLUD << 0x14) | |
| \MEMX = Local0 | |
| XXMN = Local0 | |
| XXLN = ((XXMX - XXMN) + 0x01) | |
| If ((\TPMP == 0x00)) | |
| { | |
| F4LN = 0x00 | |
| } | |
| If ((PAM1 & 0x03)) | |
| { | |
| C0LN = 0x00 | |
| } | |
| If ((PAM1 & 0x30)) | |
| { | |
| C4LN = 0x00 | |
| } | |
| If ((PAM2 & 0x03)) | |
| { | |
| C8LN = 0x00 | |
| } | |
| If ((PAM2 & 0x30)) | |
| { | |
| CCLN = 0x00 | |
| } | |
| If ((PAM3 & 0x03)) | |
| { | |
| D0LN = 0x00 | |
| } | |
| If ((PAM3 & 0x30)) | |
| { | |
| D4LN = 0x00 | |
| } | |
| If ((PAM4 & 0x03)) | |
| { | |
| D8LN = 0x00 | |
| } | |
| If ((PAM4 & 0x30)) | |
| { | |
| DCLN = 0x00 | |
| } | |
| If ((PAM5 & 0x03)) | |
| { | |
| E0LN = 0x00 | |
| } | |
| If ((PAM5 & 0x30)) | |
| { | |
| E4LN = 0x00 | |
| } | |
| If ((PAM6 & 0x03)) | |
| { | |
| E8LN = 0x00 | |
| } | |
| If ((PAM6 & 0x30)) | |
| { | |
| ECLN = 0x00 | |
| } | |
| } | |
| Name (SUPP, 0x00) | |
| Name (CTRL, 0x00) | |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities | |
| { | |
| CreateDWordField (Arg3, 0x00, CDW1) | |
| CreateDWordField (Arg3, 0x04, CDW2) | |
| CreateDWordField (Arg3, 0x08, CDW3) | |
| If (\_SB.PCI0.XHCI.CUID (Arg0)) | |
| { | |
| Return (\_SB.PCI0.XHCI.POSC (Arg1, Arg2, Arg3)) | |
| } | |
| If ((Arg0 == ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)) | |
| { | |
| SUPP = CDW2 /* \_SB_.PCI0._OSC.CDW2 */ | |
| CTRL = CDW3 /* \_SB_.PCI0._OSC.CDW3 */ | |
| CTRL &= 0x0D | |
| If (!(CDW1 & 0x01)) | |
| { | |
| If ((CTRL & 0x01)) | |
| { | |
| If (!\VIGD) | |
| { | |
| \_SB.PCI0.PEG.HPGP = 0x00 | |
| \_SB.PCI0.PEG.GMGP = 0x00 | |
| } | |
| \_SB.PCI0.EXP6.HPCE = 0x00 | |
| \_SB.PCI0.EXP6.HPCS = 0x01 | |
| \_SB.PCI0.EXP6.PDC = 0x01 | |
| \NHPS = 0x01 | |
| } | |
| If ((CTRL & 0x04)) | |
| { | |
| If (!\VIGD) | |
| { | |
| \_SB.PCI0.PEG.PMGP = 0x00 | |
| \_SB.PCI0.PEG.GMGP = 0x00 | |
| } | |
| If (\_SB.PCI0.EXP1.PMCE) | |
| { | |
| \_SB.PCI0.EXP1.PMCE = 0x00 | |
| \_SB.PCI0.EXP1.PMCS = 0x01 | |
| } | |
| If (\_SB.PCI0.EXP2.PMCE) | |
| { | |
| \_SB.PCI0.EXP2.PMCE = 0x00 | |
| \_SB.PCI0.EXP2.PMCS = 0x01 | |
| } | |
| If (\_SB.PCI0.EXP3.PMCE) | |
| { | |
| \_SB.PCI0.EXP3.PMCE = 0x00 | |
| \_SB.PCI0.EXP3.PMCS = 0x01 | |
| } | |
| If (\_SB.PCI0.EXP6.PMCE) | |
| { | |
| \_SB.PCI0.EXP6.PMCE = 0x00 | |
| \_SB.PCI0.EXP6.PMCS = 0x01 | |
| } | |
| \_SB.PCI0.LPC.EXPE = 0x00 | |
| \NPME = 0x01 | |
| } | |
| } | |
| If ((Arg1 != 0x01)) | |
| { | |
| CDW1 |= 0x0A | |
| } | |
| If ((CDW3 != CTRL)) | |
| { | |
| CDW1 |= 0x10 | |
| } | |
| CDW3 = CTRL /* \_SB_.PCI0.CTRL */ | |
| } | |
| Else | |
| { | |
| CDW1 |= 0x06 | |
| } | |
| Return (Arg3) | |
| } | |
| Mutex (MDGS, 0x07) | |
| Name (VDEE, 0x01) | |
| Name (VDDA, Buffer (0x02){}) | |
| CreateBitField (VDDA, 0x00, VUPC) | |
| CreateBitField (VDDA, 0x01, VQDL) | |
| CreateBitField (VDDA, 0x02, VQDC) | |
| CreateBitField (VDDA, 0x03, VQD0) | |
| CreateBitField (VDDA, 0x04, VQD1) | |
| CreateBitField (VDDA, 0x05, VQD2) | |
| CreateBitField (VDDA, 0x06, VSDL) | |
| CreateBitField (VDDA, 0x07, VSDC) | |
| CreateBitField (VDDA, 0x08, VSD0) | |
| CreateBitField (VDDA, 0x09, VSD1) | |
| CreateBitField (VDDA, 0x0A, VSD2) | |
| CreateBitField (VDDA, 0x0B, VSD3) | |
| CreateBitField (VDDA, 0x0C, VSD4) | |
| CreateBitField (VDDA, 0x0D, VSD5) | |
| CreateBitField (VDDA, 0x0E, MSWT) | |
| Device (VID) | |
| { | |
| Name (_ADR, 0x00020000) // _ADR: Address | |
| Name (RID, 0x00) | |
| OperationRegion (VPCG, PCI_Config, 0x00, 0x0100) | |
| Field (VPCG, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x2C), | |
| VSID, 32, | |
| Offset (0xD4), | |
| VPWR, 8 | |
| } | |
| Name (MIDL, 0x0400) | |
| Name (MIDC, 0x0100) | |
| Name (MID0, 0x0300) | |
| Name (MID1, 0x0301) | |
| Name (MID2, 0x0302) | |
| Name (MID3, 0x0303) | |
| Name (MID4, 0x0304) | |
| Name (MID5, 0x0305) | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Method (VRSI, 0, NotSerialized) | |
| { | |
| If ((OSYS >= 0x07DD)) | |
| { | |
| VSID = 0x221D17AA | |
| VMSH = 0x01 | |
| } | |
| Else | |
| { | |
| VSID = 0x220F17AA | |
| VMSH = 0x00 | |
| } | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| VRSI () | |
| CLID = \_SB.LID._LID () | |
| } | |
| Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
| { | |
| Noop | |
| } | |
| Method (_PS1, 0, NotSerialized) // _PS1: Power State 1 | |
| { | |
| Noop | |
| } | |
| Method (_PS2, 0, NotSerialized) // _PS2: Power State 2 | |
| { | |
| Noop | |
| } | |
| Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
| { | |
| Noop | |
| } | |
| Method (VSWT, 0, NotSerialized) | |
| { | |
| GHDS (0x00) | |
| } | |
| Method (VLOC, 1, NotSerialized) | |
| { | |
| If ((Arg0 == \_SB.LID._LID ())) | |
| { | |
| \VSLD (Arg0) | |
| If ((VPWR == 0x00)) | |
| { | |
| CLID = Arg0 | |
| GNOT (0x02, 0x00) | |
| } | |
| } | |
| } | |
| Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
| { | |
| Arg0 &= 0x03 | |
| If ((Arg0 == 0x02)) | |
| { | |
| Local0 = 0x14 | |
| While (Local0) | |
| { | |
| Local0-- | |
| Acquire (MDGS, 0xFFFF) | |
| If ((0x00 == MSWT)) | |
| { | |
| MSWT = 0x01 | |
| Local0 = 0x00 | |
| VDEE = Arg0 | |
| } | |
| Release (MDGS) | |
| Sleep (0xC8) | |
| } | |
| } | |
| Else | |
| { | |
| Acquire (MDGS, 0xFFFF) | |
| If ((VDEE == 0x02)) | |
| { | |
| MSWT = 0x00 | |
| } | |
| If ((Arg0 > 0x02)) | |
| { | |
| VDEE = 0x01 | |
| } | |
| Else | |
| { | |
| VDEE = Arg0 | |
| } | |
| Release (MDGS) | |
| } | |
| } | |
| Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
| { | |
| NDID = 0x00 | |
| If ((DIDL != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL2 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL3 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL4 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL5 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL6 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL7 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((DDL8 != 0x00)) | |
| { | |
| NDID++ | |
| } | |
| If ((NDID == 0x01)) | |
| { | |
| Name (TMP1, Package (0x01) | |
| { | |
| 0xFFFFFFFF | |
| }) | |
| TMP1 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| Return (TMP1) /* \_SB_.PCI0.VID_._DOD.TMP1 */ | |
| } | |
| If ((NDID == 0x02)) | |
| { | |
| Name (TMP2, Package (0x02) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP2 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP2 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| Return (TMP2) /* \_SB_.PCI0.VID_._DOD.TMP2 */ | |
| } | |
| If ((NDID == 0x03)) | |
| { | |
| Name (TMP3, Package (0x03) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP3 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP3 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP3 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| Return (TMP3) /* \_SB_.PCI0.VID_._DOD.TMP3 */ | |
| } | |
| If ((NDID == 0x04)) | |
| { | |
| Name (TMP4, Package (0x04) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP4 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP4 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP4 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| TMP4 [0x03] = (0x80010000 | (0x0F0F & DDL4)) | |
| Return (TMP4) /* \_SB_.PCI0.VID_._DOD.TMP4 */ | |
| } | |
| If ((NDID == 0x05)) | |
| { | |
| Name (TMP5, Package (0x05) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP5 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP5 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP5 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| TMP5 [0x03] = (0x80010000 | (0x0F0F & DDL4)) | |
| TMP5 [0x04] = (0x80010000 | (0x0F0F & DDL5)) | |
| Return (TMP5) /* \_SB_.PCI0.VID_._DOD.TMP5 */ | |
| } | |
| If ((NDID == 0x06)) | |
| { | |
| Name (TMP6, Package (0x06) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP6 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP6 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP6 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| TMP6 [0x03] = (0x80010000 | (0x0F0F & DDL4)) | |
| TMP6 [0x04] = (0x80010000 | (0x0F0F & DDL5)) | |
| TMP6 [0x05] = (0x80010000 | (0x0F0F & DDL6)) | |
| Return (TMP6) /* \_SB_.PCI0.VID_._DOD.TMP6 */ | |
| } | |
| If ((NDID == 0x07)) | |
| { | |
| Name (TMP7, Package (0x07) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP7 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP7 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP7 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| TMP7 [0x03] = (0x80010000 | (0x0F0F & DDL4)) | |
| TMP7 [0x04] = (0x80010000 | (0x0F0F & DDL5)) | |
| TMP7 [0x05] = (0x80010000 | (0x0F0F & DDL6)) | |
| TMP7 [0x06] = (0x80010000 | (0x0F0F & DDL7)) | |
| Return (TMP7) /* \_SB_.PCI0.VID_._DOD.TMP7 */ | |
| } | |
| If ((NDID > 0x07)) | |
| { | |
| Name (TMP8, Package (0x08) | |
| { | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP8 [0x00] = (0x80010000 | (0x0F0F & DIDL)) | |
| TMP8 [0x01] = (0x80010000 | (0x0F0F & DDL2)) | |
| TMP8 [0x02] = (0x80010000 | (0x0F0F & DDL3)) | |
| TMP8 [0x03] = (0x80010000 | (0x0F0F & DDL4)) | |
| TMP8 [0x04] = (0x80010000 | (0x0F0F & DDL5)) | |
| TMP8 [0x05] = (0x80010000 | (0x0F0F & DDL6)) | |
| TMP8 [0x06] = (0x80010000 | (0x0F0F & DDL7)) | |
| TMP8 [0x07] = (0x80010000 | (0x0F0F & DDL8)) | |
| Return (TMP8) /* \_SB_.PCI0.VID_._DOD.TMP8 */ | |
| } | |
| Return (Package (0x01) | |
| { | |
| 0x0400 | |
| }) | |
| } | |
| Method (VDSW, 1, NotSerialized) | |
| { | |
| If ((VPWR == 0x00)) | |
| { | |
| GDCK (Arg0) | |
| } | |
| } | |
| Method (VCAD, 1, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If (((DIDL & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL2 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL3 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL4 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL5 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL6 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL7 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| ElseIf (((DDL8 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 = 0x0D | |
| } | |
| If (((CPDL & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL2 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL3 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL4 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL5 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL6 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL7 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| ElseIf (((CPL8 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x10 | |
| } | |
| If (((CADL & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL2 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL3 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL4 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL5 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL6 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL7 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| ElseIf (((CAL8 & 0x0F0F) == Arg0)) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Return (Local0) | |
| } | |
| Method (NDDS, 1, NotSerialized) | |
| { | |
| If (((NADL & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL2 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL3 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL4 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL5 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL6 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL7 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| ElseIf (((NDL8 & 0x0F0F) == Arg0)) | |
| { | |
| Return (0x01) | |
| } | |
| Return (0x00) | |
| } | |
| Device (LCD0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0400) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MIDL)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MIDL)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSDL = (Arg0 & 0x01) | |
| } | |
| Method (_DDC, 1, NotSerialized) // _DDC: Display Data Current | |
| { | |
| If ((Arg0 == 0x01)) | |
| { | |
| Return (\VEDI) | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| Return (\VEDI) | |
| } | |
| Return (0x00) | |
| } | |
| } | |
| Device (CRT0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0100) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MIDC)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MIDC)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSDC = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0300) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID0)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID0)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD0 = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI1) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0301) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID1)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID1)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD1 = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI2) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0302) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID2)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID2)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD2 = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI3) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0303) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID3)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID3)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD3 = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI4) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0304) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID4)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID4)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD4 = (Arg0 & 0x01) | |
| } | |
| } | |
| Device (DVI5) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0305) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| Return (VCAD (MID5)) | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (NDDS (MID5)) | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD5 = (Arg0 & 0x01) | |
| } | |
| } | |
| } | |
| Device (LPC) | |
| { | |
| Name (_ADR, 0x001F0000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| Device (SIO) | |
| { | |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
| Name (_UID, 0x00) // _UID: Unique ID | |
| Name (SCRS, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0010, // Range Minimum | |
| 0x0010, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0090, // Range Minimum | |
| 0x0090, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // 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, | |
| 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 | |
| 0x06, // 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, | |
| 0x0050, // Range Minimum | |
| 0x0050, // Range Maximum | |
| 0x01, // Alignment | |
| 0x04, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0072, // Range Minimum | |
| 0x0072, // Range Maximum | |
| 0x01, // Alignment | |
| 0x06, // Length | |
| ) | |
| IO (Decode16, | |
| 0x1800, // Range Minimum | |
| 0x1800, // Range Maximum | |
| 0x01, // Alignment | |
| 0x80, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0800, // Range Minimum | |
| 0x0800, // Range Maximum | |
| 0x01, // Alignment | |
| 0x80, // Length | |
| ) | |
| IO (Decode16, | |
| 0x15E0, // Range Minimum | |
| 0x15E0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // Length | |
| ) | |
| IO (Decode16, | |
| 0x1600, // Range Minimum | |
| 0x1600, // Range Maximum | |
| 0x01, // Alignment | |
| 0x80, // Length | |
| ) | |
| IO (Decode16, | |
| 0x1640, // Range Minimum | |
| 0x1640, // Range Maximum | |
| 0x01, // Alignment | |
| 0x20, // Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xF8000000, // Address Base | |
| 0x04000000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0x00000000, // Address Base | |
| 0x00001000, // Address Length | |
| _Y26) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED1C000, // Address Base | |
| 0x00004000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED10000, // Address Base | |
| 0x00004000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED18000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED19000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFED45000, // Address Base | |
| 0x00007000, // Address Length | |
| ) | |
| }) | |
| CreateDWordField (SCRS, \_SB.PCI0.LPC.SIO._Y26._BAS, TRMB) // _BAS: Base Address | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| TRMB = \TBAB | |
| If ((\_SB.PCI0.LPC.TPM._STA () == 0x0F)) | |
| { | |
| Return (SCRS) /* \_SB_.PCI0.LPC_.SIO_.SCRS */ | |
| } | |
| Else | |
| { | |
| Local0 = (SizeOf (SCRS) - 0x02) | |
| Name (BUF0, Buffer (Local0){}) | |
| Local0 += SizeOf (\_SB.PCI0.LPC.TPM.BUF1) | |
| Name (BUF1, Buffer (Local0){}) | |
| BUF0 = SCRS /* \_SB_.PCI0.LPC_.SIO_.SCRS */ | |
| Concatenate (BUF0, \_SB.PCI0.LPC.TPM.BUF1, BUF1) /* \_SB_.PCI0.LPC_.SIO_._CRS.BUF1 */ | |
| Return (BUF1) /* \_SB_.PCI0.LPC_.SIO_._CRS.BUF1 */ | |
| } | |
| } | |
| } | |
| OperationRegion (LPCS, PCI_Config, 0x00, 0x0100) | |
| Field (LPCS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x60), | |
| PIRA, 8, | |
| PIRB, 8, | |
| PIRC, 8, | |
| PIRD, 8, | |
| SERQ, 8, | |
| Offset (0x68), | |
| PIRE, 8, | |
| PIRF, 8, | |
| PIRG, 8, | |
| PIRH, 8, | |
| Offset (0x80), | |
| XU1A, 3, | |
| , 1, | |
| XU2A, 3, | |
| Offset (0x81), | |
| XPA, 2, | |
| , 2, | |
| XFA, 1, | |
| Offset (0x82), | |
| XU1E, 1, | |
| XU2E, 1, | |
| XPE, 1, | |
| XFE, 1, | |
| Offset (0x84), | |
| XG1E, 1, | |
| , 1, | |
| XG1A, 14, | |
| Offset (0x88), | |
| XG2E, 1, | |
| , 1, | |
| XG2A, 14, | |
| Offset (0xA0), | |
| , 2, | |
| CLKR, 1, | |
| , 7, | |
| EXPE, 1, | |
| Offset (0xA2), | |
| Offset (0xAC), | |
| Offset (0xAD), | |
| Offset (0xAE), | |
| XUSB, 1, | |
| Offset (0xB8), | |
| GR00, 2, | |
| , 10, | |
| GR06, 2 | |
| } | |
| OperationRegion (LPIO, SystemIO, 0x0800, 0x80) | |
| Field (LPIO, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x0C), | |
| FBTR, 1, | |
| , 6, | |
| FBCL, 1, | |
| , 3, | |
| NFCI, 1, | |
| Offset (0x0E), | |
| , 1, | |
| GPGD, 1, | |
| , 4, | |
| GLIS, 1, | |
| Offset (0x0F), | |
| Offset (0x10), | |
| Offset (0x2C), | |
| , 6, | |
| XHPD, 1, | |
| Offset (0x38), | |
| , 2, | |
| NFCD, 1, | |
| , 3, | |
| PID2, 1, | |
| PID3, 1, | |
| Offset (0x3A), | |
| PID0, 1, | |
| PID1, 1, | |
| , 4, | |
| NFCP, 1, | |
| Offset (0x48), | |
| DOI0, 1, | |
| DOI1, 1, | |
| DOI2, 1, | |
| DOI3, 1 | |
| } | |
| OperationRegion (PMIO, SystemIO, 0x1800, 0x80) | |
| Field (PMIO, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x2A), | |
| , 6, | |
| XHPE, 1, | |
| Offset (0x42), | |
| , 1, | |
| SWGE, 1, | |
| Offset (0x64), | |
| , 9, | |
| SCIS, 1, | |
| Offset (0x66) | |
| } | |
| Device (PIC) | |
| { | |
| Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0020, // Range Minimum | |
| 0x0020, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00A0, // Range Minimum | |
| 0x00A0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x04D0, // Range Minimum | |
| 0x04D0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IRQNoFlags () | |
| {2} | |
| }) | |
| } | |
| 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 | |
| ) | |
| IRQNoFlags () | |
| {0} | |
| }) | |
| } | |
| Device (HPET) | |
| { | |
| Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((\WNTF && !\WXPF)) | |
| { | |
| Return (0x00) | |
| } | |
| Else | |
| { | |
| Return (0x0F) | |
| } | |
| Return (0x00) | |
| } | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadOnly, | |
| 0xFED00000, // Address Base | |
| 0x00000400, // Address Length | |
| _Y27) | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| CreateDWordField (BUF0, \_SB.PCI0.LPC.HPET._Y27._BAS, HPT0) // _BAS: Base Address | |
| HPT0 = \HPET | |
| Return (BUF0) /* \_SB_.PCI0.LPC_.HPET.BUF0 */ | |
| } | |
| } | |
| Device (DMAC) | |
| { | |
| Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0000, // Range Minimum | |
| 0x0000, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0080, // Range Minimum | |
| 0x0080, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00C0, // Range Minimum | |
| 0x00C0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x20, // Length | |
| ) | |
| DMA (Compatibility, BusMaster, Transfer8_16, ) | |
| {4} | |
| }) | |
| } | |
| Device (SPKR) | |
| { | |
| Name (_HID, EisaId ("PNP0800") /* Microsoft Sound System Compatible Device */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0061, // Range Minimum | |
| 0x0061, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| }) | |
| } | |
| Device (FPU) | |
| { | |
| Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x00F0, // Range Minimum | |
| 0x00F0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IRQNoFlags () | |
| {13} | |
| }) | |
| } | |
| Device (RTC) | |
| { | |
| Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0070, // Range Minimum | |
| 0x0070, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IRQNoFlags () | |
| {8} | |
| }) | |
| } | |
| Device (KBD) | |
| { | |
| Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
| { | |
| If (\WIN8) | |
| { | |
| Return (0x7100AE30) | |
| } | |
| Return (0x0303D041) | |
| } | |
| Name (_CID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _CID: Compatible ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0060, // Range Minimum | |
| 0x0060, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0064, // Range Minimum | |
| 0x0064, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IRQNoFlags () | |
| {1} | |
| }) | |
| } | |
| Device (MOU) | |
| { | |
| Name (_HID, EisaId ("IBM3780")) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0F13") /* PS/2 Mouse */) // _CID: Compatible ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQNoFlags () | |
| {12} | |
| }) | |
| Method (MHID, 0, NotSerialized) | |
| { | |
| If (\_SB.PCI0.LPC.PADD) | |
| { | |
| _HID = 0x80374D24 | |
| } | |
| ElseIf (\_SB.PCI0.LPC.NFCD) | |
| { | |
| _HID = 0x3600AE30 | |
| } | |
| Else | |
| { | |
| _HID = 0x3900AE30 | |
| } | |
| } | |
| } | |
| OperationRegion (IMGA, SystemIO, 0x15E0, 0x10) | |
| Field (IMGA, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x01), | |
| Offset (0x02), | |
| Offset (0x03), | |
| WAKR, 16, | |
| Offset (0x0C), | |
| GAIX, 8, | |
| Offset (0x0E), | |
| GADT, 8, | |
| Offset (0x10) | |
| } | |
| IndexField (GAIX, GADT, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x50), | |
| , 3, | |
| IVPW, 1, | |
| DVPW, 1, | |
| BLPL, 1, | |
| Offset (0x51), | |
| TP4R, 1, | |
| PADR, 1, | |
| BPAD, 1, | |
| , 1, | |
| , 1, | |
| PADD, 1, | |
| Offset (0x60), | |
| EPWG, 1, | |
| , 1, | |
| CSON, 1, | |
| DSCI, 1, | |
| DSCS, 1, | |
| DLAN, 1, | |
| Offset (0xC2), | |
| GAID, 8 | |
| } | |
| Scope (\_SB) | |
| { | |
| Name (TCGP, Buffer (0x08) | |
| { | |
| 0x1F, 0xE0, 0x1F, 0x01, 0x02, 0x04, 0x08, 0xF0 // ........ | |
| }) | |
| CreateByteField (TCGP, 0x00, PPRQ) | |
| CreateByteField (TCGP, 0x01, PPL1) | |
| CreateByteField (TCGP, 0x02, PPRP) | |
| CreateByteField (TCGP, 0x03, TPRS) | |
| CreateByteField (TCGP, 0x04, PPOR) | |
| CreateByteField (TCGP, 0x05, TPMV) | |
| CreateByteField (TCGP, 0x06, MOR) | |
| CreateByteField (TCGP, 0x07, TVEN) | |
| OperationRegion (TCGC, SystemIO, 0x72, 0x02) | |
| Field (TCGC, ByteAcc, Lock, Preserve) | |
| { | |
| TIDX, 8, | |
| TPDA, 8 | |
| } | |
| IndexField (TIDX, TPDA, ByteAcc, Lock, Preserve) | |
| { | |
| Offset (0x40), | |
| TPP1, 8, | |
| PPLO, 8, | |
| TPP3, 8 | |
| } | |
| OperationRegion (SMIP, SystemIO, 0xB2, 0x02) | |
| Field (SMIP, ByteAcc, NoLock, Preserve) | |
| { | |
| SMIT, 8, | |
| SMID, 8 | |
| } | |
| } | |
| Device (TPM) | |
| { | |
| Name (TMPV, 0x00) | |
| Method (_HID, 0, NotSerialized) // _HID: Hardware ID | |
| { | |
| If ((TVID == 0x15D1)) | |
| { | |
| Return (0x0201D824) | |
| } | |
| If (((TVID == 0x1050) || (TVID == 0x100B))) | |
| { | |
| Return (0x0010A35C) | |
| } | |
| If ((TVID == 0x19FA)) | |
| { | |
| Return (0x0435CF4D) | |
| } | |
| If ((TDID == 0x1002)) | |
| { | |
| Return (0x02016D08) | |
| } | |
| If ((TDID == 0x1001)) | |
| { | |
| Return (0x01016D08) | |
| } | |
| If ((TVID == 0x1114)) | |
| { | |
| Return (0x00128D06) | |
| } | |
| If ((TVID == 0x104A)) | |
| { | |
| Return (0x0012AF4D) | |
| } | |
| Return (0x310CD041) | |
| } | |
| Name (_CID, EisaId ("PNP0C31")) // _CID: Compatible ID | |
| Name (_UID, 0x01) // _UID: Unique ID | |
| OperationRegion (TMMB, SystemMemory, 0xFED40000, 0x1000) | |
| Field (TMMB, ByteAcc, Lock, Preserve) | |
| { | |
| ACCS, 8, | |
| Offset (0x18), | |
| TSTA, 8, | |
| TBCA, 8, | |
| Offset (0xF00), | |
| TVID, 16, | |
| TDID, 16 | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((ACCS == 0xFF)) | |
| { | |
| Return (0x00) | |
| } | |
| ElseIf ((TPME == 0x00)) | |
| { | |
| Return (0x00) | |
| } | |
| Return (0x0F) | |
| } | |
| Name (BUF1, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadOnly, | |
| 0xFED40000, // Address Base | |
| 0x00005000, // Address Length | |
| ) | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Return (BUF1) /* \_SB_.PCI0.LPC_.TPM_.BUF1 */ | |
| } | |
| Method (UCMP, 2, NotSerialized) | |
| { | |
| If ((0x10 != SizeOf (Arg0))) | |
| { | |
| Return (0x00) | |
| } | |
| If ((0x10 != SizeOf (Arg1))) | |
| { | |
| Return (0x00) | |
| } | |
| Local0 = 0x00 | |
| While ((Local0 < 0x10)) | |
| { | |
| If ((DerefOf (Arg0 [Local0]) != DerefOf (Arg1 [Local0] | |
| ))) | |
| { | |
| Return (0x00) | |
| } | |
| Local0++ | |
| } | |
| Return (0x01) | |
| } | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| Name (TTMP, Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| CreateByteField (TTMP, 0x00, TMPV) | |
| If ((UCMP (Arg0, ToUUID ("3dddfaa6-361b-4eb4-a424-8d10089d1653") /* Physical Presence Interface */) == 0x01)) | |
| { | |
| If ((Arg2 == 0x00)) | |
| { | |
| Return (Buffer (0x02) | |
| { | |
| 0xFF, 0x01 // .. | |
| }) | |
| } | |
| If ((Arg2 == 0x01)) | |
| { | |
| Return (Buffer (0x04) | |
| { | |
| "1.2" | |
| }) | |
| } | |
| If ((Arg2 == 0x02)) | |
| { | |
| TMPV = TPP3 /* \_SB_.TPP3 */ | |
| If ((TMPV & TPRS)) | |
| { | |
| If ((DerefOf (Arg3 [0x00]) <= 0x0B)) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) >= 0x0E) && ( | |
| DerefOf (Arg3 [0x00]) <= 0x12))) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) == 0x15) || (DerefOf ( | |
| Arg3 [0x00]) == 0x16))) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| Return (0x01) | |
| } | |
| Return (0x02) | |
| } | |
| If ((Arg2 == 0x03)) | |
| { | |
| Name (TMP1, Package (0x02) | |
| { | |
| 0x00, | |
| 0xFFFFFFFF | |
| }) | |
| TMPV = TPP1 /* \_SB_.TPP1 */ | |
| TMP1 [0x01] = TMPV &= PPRQ /* \_SB_.PPRQ */ | |
| Return (TMP1) /* \_SB_.PCI0.LPC_.TPM_._DSM.TMP1 */ | |
| } | |
| If ((Arg2 == 0x04)) | |
| { | |
| Return (0x02) | |
| } | |
| If ((Arg2 == 0x05)) | |
| { | |
| Name (TMP2, Package (0x03) | |
| { | |
| 0x00, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF | |
| }) | |
| TMP2 [0x01] = PPLO /* \_SB_.PPLO */ | |
| TMP2 [0x02] = 0x00 | |
| Return (TMP2) /* \_SB_.PCI0.LPC_.TPM_._DSM.TMP2 */ | |
| } | |
| If ((Arg2 == 0x06)) | |
| { | |
| Return (0x03) | |
| } | |
| If ((Arg2 == 0x07)) | |
| { | |
| TMPV = TPP3 /* \_SB_.TPP3 */ | |
| If ((TMPV & TPRS)) | |
| { | |
| If ((DerefOf (Arg3 [0x00]) <= 0x0B)) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) >= 0x0E) && ( | |
| DerefOf (Arg3 [0x00]) <= 0x12))) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) == 0x15) || (DerefOf ( | |
| Arg3 [0x00]) == 0x16))) | |
| { | |
| TPP1 = DerefOf (Arg3 [0x00]) | |
| Return (0x00) | |
| } | |
| Return (0x01) | |
| } | |
| Return (0x02) | |
| } | |
| If ((Arg2 == 0x08)) | |
| { | |
| Name (PPIP, 0x00) | |
| Name (PPIC, 0x00) | |
| If ((\TPPP == 0x00)) | |
| { | |
| PPIP = 0x01 | |
| } | |
| If ((\TPPC == 0x00)) | |
| { | |
| PPIC = 0x01 | |
| } | |
| If ((DerefOf (Arg3 [0x00]) == 0x05)) | |
| { | |
| If ((PPIC > 0x00)) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x03) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) >= 0x01) && ( | |
| DerefOf (Arg3 [0x00]) <= 0x04))) | |
| { | |
| If ((PPIP > 0x00)) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x03) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) >= 0x06) && ( | |
| DerefOf (Arg3 [0x00]) <= 0x0B))) | |
| { | |
| If ((PPIP > 0x00)) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x03) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) == 0x0E) || (( | |
| DerefOf (Arg3 [0x00]) >= 0x15) && (DerefOf (Arg3 [0x00]) <= | |
| 0x16)))) | |
| { | |
| If (((PPIP > 0x00) && (PPIC > 0x00))) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x03) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) == 0x10) || (DerefOf ( | |
| Arg3 [0x00]) == 0x12))) | |
| { | |
| Return (0x03) | |
| } | |
| If (((DerefOf (Arg3 [0x00]) == 0x00) || ((DerefOf ( | |
| Arg3 [0x00]) == 0x0F) || (DerefOf (Arg3 [0x00]) == 0x11)))) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x00) | |
| } | |
| Return (0x01) | |
| } | |
| If ((UCMP (Arg0, ToUUID ("376054ed-cc13-4675-901c-4756d7f2d45d")) == 0x01)) | |
| { | |
| If ((Arg2 == 0x00)) | |
| { | |
| Return (Buffer (0x01) | |
| { | |
| 0x03 // . | |
| }) | |
| } | |
| If ((Arg2 == 0x01)) | |
| { | |
| TMPV = DerefOf (Arg3 [0x00]) | |
| TMPV &= 0x01 | |
| If ((TMPV == 0x00)) | |
| { | |
| \_SB.MOR = 0x00 | |
| Return (0x00) | |
| } | |
| If ((TMPV == 0x01)) | |
| { | |
| \_SB.MOR = 0x01 | |
| Return (0x00) | |
| } | |
| } | |
| Return (0x01) | |
| } | |
| Return (Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| Method (CMOR, 0, NotSerialized) | |
| { | |
| \_SB.MOR = 0x00 | |
| SMID = 0x80 | |
| SMIT = 0xC1 | |
| } | |
| } | |
| Device (EC) | |
| { | |
| Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID | |
| Name (_UID, 0x00) // _UID: Unique ID | |
| Name (_GPE, 0x11) // _GPE: General Purpose Events | |
| Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
| { | |
| If ((Arg0 == 0x03)) | |
| { | |
| \H8DR = Arg1 | |
| } | |
| } | |
| OperationRegion (ECOR, EmbeddedControl, 0x00, 0x0100) | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| HDBM, 1, | |
| , 1, | |
| , 1, | |
| HFNE, 1, | |
| , 1, | |
| , 1, | |
| HLDM, 1, | |
| Offset (0x01), | |
| BBLS, 1, | |
| BTCM, 1, | |
| , 1, | |
| , 1, | |
| , 1, | |
| HBPR, 1, | |
| BTPC, 1, | |
| Offset (0x02), | |
| HDUE, 1, | |
| , 4, | |
| SNLK, 1, | |
| Offset (0x03), | |
| , 5, | |
| HAUM, 2, | |
| Offset (0x05), | |
| HSPA, 1, | |
| Offset (0x06), | |
| HSUN, 8, | |
| HSRP, 8, | |
| Offset (0x0C), | |
| HLCL, 8, | |
| , 4, | |
| CALM, 1, | |
| Offset (0x0E), | |
| HFNS, 2, | |
| Offset (0x0F), | |
| , 6, | |
| NULS, 1, | |
| Offset (0x10), | |
| HAM0, 8, | |
| HAM1, 8, | |
| HAM2, 8, | |
| HAM3, 8, | |
| HAM4, 8, | |
| HAM5, 8, | |
| HAM6, 8, | |
| HAM7, 8, | |
| HAM8, 8, | |
| HAM9, 8, | |
| HAMA, 8, | |
| HAMB, 8, | |
| HAMC, 8, | |
| HAMD, 8, | |
| HAME, 8, | |
| HAMF, 8, | |
| Offset (0x23), | |
| HANT, 8, | |
| Offset (0x26), | |
| , 2, | |
| HANA, 2, | |
| Offset (0x27), | |
| Offset (0x28), | |
| , 1, | |
| SKEM, 1, | |
| Offset (0x29), | |
| Offset (0x2A), | |
| HATR, 8, | |
| HT0H, 8, | |
| HT0L, 8, | |
| HT1H, 8, | |
| HT1L, 8, | |
| HFSP, 8, | |
| , 6, | |
| HMUT, 1, | |
| Offset (0x31), | |
| , 2, | |
| HUWB, 1, | |
| Offset (0x32), | |
| HWPM, 1, | |
| HWLB, 1, | |
| HWLO, 1, | |
| HWDK, 1, | |
| HWFN, 1, | |
| HWBT, 1, | |
| HWRI, 1, | |
| HWBU, 1, | |
| HWLU, 1, | |
| Offset (0x34), | |
| , 3, | |
| PIBS, 1, | |
| , 3, | |
| HPLO, 1, | |
| Offset (0x36), | |
| HWAC, 16, | |
| HB0S, 7, | |
| HB0A, 1, | |
| HB1S, 7, | |
| HB1A, 1, | |
| HCMU, 1, | |
| , 2, | |
| OVRQ, 1, | |
| DCBD, 1, | |
| DCWL, 1, | |
| DCWW, 1, | |
| HB1I, 1, | |
| , 1, | |
| KBLT, 1, | |
| BTPW, 1, | |
| FNKC, 1, | |
| HUBS, 1, | |
| BDPW, 1, | |
| BDDT, 1, | |
| HUBB, 1, | |
| Offset (0x46), | |
| , 1, | |
| BTWK, 1, | |
| HPLD, 1, | |
| , 1, | |
| HPAC, 1, | |
| BTST, 1, | |
| Offset (0x47), | |
| HPBU, 1, | |
| , 1, | |
| HBID, 1, | |
| , 3, | |
| HBCS, 1, | |
| HPNF, 1, | |
| , 1, | |
| GSTS, 1, | |
| , 2, | |
| HLBU, 1, | |
| DOCD, 1, | |
| HCBL, 1, | |
| Offset (0x49), | |
| SLUL, 1, | |
| Offset (0x4C), | |
| HTMH, 8, | |
| HTML, 8, | |
| HWAK, 16, | |
| HMPR, 8, | |
| , 7, | |
| HMDN, 1, | |
| Offset (0x78), | |
| TMP0, 8, | |
| Offset (0x80), | |
| Offset (0x81), | |
| HIID, 8, | |
| Offset (0x83), | |
| HFNI, 8, | |
| HSPD, 16, | |
| Offset (0x88), | |
| TSL0, 7, | |
| TSR0, 1, | |
| TSL1, 7, | |
| TSR1, 1, | |
| TSL2, 7, | |
| TSR2, 1, | |
| TSL3, 7, | |
| TSR3, 1, | |
| Offset (0x8D), | |
| HDAA, 3, | |
| HDAB, 3, | |
| HDAC, 2, | |
| Offset (0xB0), | |
| HDEN, 32, | |
| HDEP, 32, | |
| HDEM, 8, | |
| HDES, 8, | |
| Offset (0xBB), | |
| PLSL, 8, | |
| PLMS, 8, | |
| PLLS, 8, | |
| PLTU, 8, | |
| Offset (0xC8), | |
| ATMX, 8, | |
| HWAT, 8, | |
| Offset (0xCC), | |
| PWMH, 8, | |
| PWML, 8, | |
| Offset (0xED), | |
| , 4, | |
| HDDD, 1 | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| If (\H8DR) | |
| { | |
| HSPA = 0x00 | |
| } | |
| Else | |
| { | |
| \MBEC (0x05, 0xFE, 0x00) | |
| } | |
| BINI () | |
| \_SB.PCI0.LPC.EC.HKEY.WGIN () | |
| } | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0062, // Range Minimum | |
| 0x0062, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0066, // Range Minimum | |
| 0x0066, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| }) | |
| Method (LED, 2, NotSerialized) | |
| { | |
| Local0 = (Arg0 | Arg1) | |
| If (\H8DR) | |
| { | |
| HLCL = Local0 | |
| } | |
| Else | |
| { | |
| \WBEC (0x0C, Local0) | |
| } | |
| } | |
| Name (BAON, 0x00) | |
| Name (WBON, 0x00) | |
| Method (BEEP, 1, NotSerialized) | |
| { | |
| If ((Arg0 == 0x05)) | |
| { | |
| WBON = 0x00 | |
| } | |
| Local2 = WBON /* \_SB_.PCI0.LPC_.EC__.WBON */ | |
| If (BAON) | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| BAON = 0x00 | |
| If (WBON) | |
| { | |
| Local0 = 0x03 | |
| Local1 = 0x08 | |
| } | |
| Else | |
| { | |
| Local0 = 0x00 | |
| Local1 = 0x00 | |
| } | |
| } | |
| Else | |
| { | |
| Local0 = 0xFF | |
| Local1 = 0xFF | |
| If ((Arg0 == 0x11)) | |
| { | |
| WBON = 0x00 | |
| } | |
| If ((Arg0 == 0x10)) | |
| { | |
| WBON = 0x01 | |
| } | |
| } | |
| } | |
| Else | |
| { | |
| Local0 = Arg0 | |
| Local1 = 0xFF | |
| If ((Arg0 == 0x0F)) | |
| { | |
| Local0 = Arg0 | |
| Local1 = 0x08 | |
| BAON = 0x01 | |
| } | |
| If ((Arg0 == 0x11)) | |
| { | |
| Local0 = 0x00 | |
| Local1 = 0x00 | |
| WBON = 0x00 | |
| } | |
| If ((Arg0 == 0x10)) | |
| { | |
| Local0 = 0x03 | |
| Local1 = 0x08 | |
| WBON = 0x01 | |
| } | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| WBON = 0x00 | |
| If (Local2) | |
| { | |
| Local0 = 0x07 | |
| If (((\SPS == 0x03) || (\SPS == 0x04))) | |
| { | |
| Local2 = 0x00 | |
| Local0 = 0xFF | |
| Local1 = 0xFF | |
| } | |
| } | |
| } | |
| If ((Arg0 == 0x07)) | |
| { | |
| If (Local2) | |
| { | |
| Local2 = 0x00 | |
| Local0 = 0xFF | |
| Local1 = 0xFF | |
| } | |
| } | |
| If (\H8DR) | |
| { | |
| If ((Local2 && !WBON)) | |
| { | |
| HSRP = 0x00 | |
| HSUN = 0x00 | |
| Sleep (0x64) | |
| } | |
| If ((Local1 != 0xFF)) | |
| { | |
| HSRP = Local1 | |
| } | |
| If ((Local0 != 0xFF)) | |
| { | |
| HSUN = Local0 | |
| } | |
| } | |
| Else | |
| { | |
| If ((Local2 && !WBON)) | |
| { | |
| \WBEC (0x07, 0x00) | |
| \WBEC (0x06, 0x00) | |
| Sleep (0x64) | |
| } | |
| If ((Local1 != 0xFF)) | |
| { | |
| \WBEC (0x07, Local1) | |
| } | |
| If ((Local0 != 0xFF)) | |
| { | |
| \WBEC (0x06, Local0) | |
| } | |
| } | |
| If ((Arg0 == 0x03)){} | |
| If ((Arg0 == 0x07)) | |
| { | |
| Sleep (0x01F4) | |
| } | |
| } | |
| Method (EVNT, 1, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| If (Arg0) | |
| { | |
| HAM7 |= 0x01 | |
| HAM5 |= 0x04 | |
| } | |
| Else | |
| { | |
| HAM7 &= 0xFE | |
| HAM5 &= 0xFB | |
| } | |
| } | |
| ElseIf (Arg0) | |
| { | |
| \MBEC (0x17, 0xFF, 0x01) | |
| \MBEC (0x15, 0xFF, 0x04) | |
| } | |
| Else | |
| { | |
| \MBEC (0x17, 0xFE, 0x00) | |
| \MBEC (0x15, 0xFB, 0x00) | |
| } | |
| } | |
| Name (USPS, 0x00) | |
| PowerResource (PUBS, 0x03, 0x0000) | |
| { | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (\H8DR) | |
| { | |
| Local0 = HUBS /* \_SB_.PCI0.LPC_.EC__.HUBS */ | |
| } | |
| Else | |
| { | |
| Local0 = (\RBEC (0x3B) & 0x10) | |
| } | |
| If (Local0) | |
| { | |
| Return (0x01) | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Method (_ON, 0, NotSerialized) // _ON_: Power On | |
| { | |
| Local0 = 0x64 | |
| While ((USPS && Local0)) | |
| { | |
| Sleep (0x01) | |
| Local0-- | |
| } | |
| If (\H8DR) | |
| { | |
| HUBS = 0x01 | |
| } | |
| Else | |
| { | |
| \MBEC (0x3B, 0xFF, 0x10) | |
| } | |
| } | |
| Method (_OFF, 0, NotSerialized) // _OFF: Power Off | |
| { | |
| USPS = 0x01 | |
| If (\H8DR) | |
| { | |
| HUBS = 0x00 | |
| } | |
| Else | |
| { | |
| \MBEC (0x3B, 0xEF, 0x00) | |
| } | |
| Sleep (0x14) | |
| USPS = 0x00 | |
| } | |
| } | |
| Method (CHKS, 0, NotSerialized) | |
| { | |
| Local0 = 0x03E8 | |
| While (HMPR) | |
| { | |
| Sleep (0x01) | |
| Local0-- | |
| If (!Local0) | |
| { | |
| Return (0x8080) | |
| } | |
| } | |
| If (HMDN) | |
| { | |
| Return (Zero) | |
| } | |
| Return (0x8081) | |
| } | |
| Method (LPMD, 0, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| Local1 = 0x00 | |
| Local2 = 0x00 | |
| If (\H8DR) | |
| { | |
| If (HPAC) | |
| { | |
| If (HPLO) | |
| { | |
| Local0 = \LPST | |
| } | |
| ElseIf ((HWAT < 0x5A)) | |
| { | |
| If (HB0A) | |
| { | |
| If (((HB0S & 0x10) || ((HB0S & 0x07) < 0x02))) | |
| { | |
| Local1 = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| Local1 = 0x01 | |
| } | |
| If (HB1A) | |
| { | |
| If (((HB1S & 0x10) || ((HB1S & 0x07) < 0x02))) | |
| { | |
| Local2 = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| Local2 = 0x01 | |
| } | |
| If ((Local1 && Local2)) | |
| { | |
| Local0 = \LPST | |
| } | |
| } | |
| } | |
| } | |
| ElseIf ((\RBEC (0x46) & 0x10)) | |
| { | |
| If ((\RBEC (0x34) & 0x80)) | |
| { | |
| Local0 = \LPST | |
| } | |
| ElseIf ((\RBEC (0xC9) < 0x5A)) | |
| { | |
| Local3 = \RBEC (0x38) | |
| If ((Local3 & 0x80)) | |
| { | |
| If (((Local3 & 0x10) || ((Local3 & 0x07) < 0x02))) | |
| { | |
| Local1 = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| Local2 = 0x01 | |
| } | |
| Local3 = \RBEC (0x39) | |
| If ((Local3 & 0x80)) | |
| { | |
| If (((Local3 & 0x10) || ((Local3 & 0x07) < 0x02))) | |
| { | |
| Local1 = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| Local2 = 0x01 | |
| } | |
| If ((Local1 && Local2)) | |
| { | |
| Local0 = \LPST | |
| } | |
| } | |
| } | |
| Return (Local0) | |
| } | |
| Method (CLPM, 0, NotSerialized) | |
| { | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| Else | |
| { | |
| Local0 = LPMD () | |
| If (Local0) | |
| { | |
| \STEP (0x04) | |
| } | |
| Else | |
| { | |
| \STEP (0x05) | |
| } | |
| } | |
| } | |
| } | |
| Mutex (MCPU, 0x07) | |
| Method (_Q10, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x01)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1001) | |
| } | |
| } | |
| Method (_Q11, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Noop | |
| } | |
| Method (_Q12, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x02)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1002) | |
| } | |
| } | |
| Method (_Q13, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1004) | |
| } | |
| Else | |
| { | |
| Notify (\_SB.SLPB, 0x80) // Status Change | |
| } | |
| } | |
| Method (_Q64, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x10)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1005) | |
| } | |
| } | |
| Method (_Q65, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x20)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1006) | |
| } | |
| } | |
| Method (_Q16, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x40)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1007) | |
| } | |
| Else | |
| { | |
| If ((\VHYB (0x03, 0x00) == 0x03)) | |
| { | |
| Notify (\_SB.PCI0.VID, 0x80) // Status Change | |
| Return (Zero) | |
| } | |
| If (VIGD) | |
| { | |
| \_SB.PCI0.VID.VSWT () | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.PEG.VID.VSWT () | |
| } | |
| } | |
| } | |
| Method (_Q17, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x80)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1008) | |
| } | |
| ElseIf (!\WNTF) | |
| { | |
| VEXP () | |
| } | |
| } | |
| Method (_Q18, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x0100)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1009) | |
| } | |
| Noop | |
| } | |
| Method (_Q1A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x0400)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100B) | |
| } | |
| } | |
| Method (_Q1B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100C) | |
| } | |
| Method (_Q62, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x1000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100D) | |
| } | |
| } | |
| Method (_Q60, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x2000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100E) | |
| } | |
| } | |
| Method (_Q61, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x4000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x100F) | |
| } | |
| } | |
| Method (_Q1F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00020000)) | |
| { | |
| If ((PKLI & 0x0C00)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1012) | |
| } | |
| } | |
| \UCMS (0x0E) | |
| } | |
| Method (_Q1C, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x01000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1019) | |
| } | |
| } | |
| Method (_Q1D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x02000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x101A) | |
| } | |
| } | |
| Method (_Q66, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x10000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x101D) | |
| } | |
| } | |
| Method (_Q67, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x20000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x101E) | |
| } | |
| } | |
| Method (_Q68, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x40000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x101F) | |
| } | |
| } | |
| Method (_Q69, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x80000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1020) | |
| } | |
| } | |
| Method (_Q26, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (VIGD) | |
| { | |
| If (\WVIS) | |
| { | |
| \VBTD () | |
| } | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \UCMS (0x12) | |
| } | |
| Sleep (0x01F4) | |
| Notify (AC, 0x80) // Status Change | |
| Notify (\_TZ.THM0, 0x80) // Thermal Status Change | |
| If (\WXPF) | |
| { | |
| Acquire (MCPU, 0xFFFF) | |
| } | |
| PWRS = 0x01 | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| } | |
| If (\WXPF) | |
| { | |
| Sleep (0x64) | |
| } | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| If (\WXPF) | |
| { | |
| Release (MCPU) | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6040) | |
| ATMC () | |
| } | |
| Method (_Q27, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (VIGD) | |
| { | |
| If (\WVIS) | |
| { | |
| \VBTD () | |
| } | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \UCMS (0x12) | |
| } | |
| If (\_SB.PCI0.PEG.VID.ISOP ()) | |
| { | |
| Notify (\_SB.PCI0.PEG.VID, 0xDF) // Hardware-Specific | |
| } | |
| Sleep (0x01F4) | |
| Notify (AC, 0x80) // Status Change | |
| Notify (\_TZ.THM0, 0x80) // Thermal Status Change | |
| If (\WXPF) | |
| { | |
| Acquire (MCPU, 0xFFFF) | |
| } | |
| PWRS = 0x00 | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| } | |
| If (\WXPF) | |
| { | |
| Sleep (0x64) | |
| } | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| If (\WXPF) | |
| { | |
| Release (MCPU) | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6040) | |
| ATMC () | |
| } | |
| Method (_Q2A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \VCMS (0x01, \_SB.LID._LID ()) | |
| If ((\ILNF == 0x00)) | |
| { | |
| If (\IOST) | |
| { | |
| If (!\ISOC (0x00)) | |
| { | |
| \IOST = 0x00 | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x60D0) | |
| } | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5002) | |
| If ((\PLUX == 0x00)) | |
| { | |
| If (VIGD) | |
| { | |
| \_SB.PCI0.VID.GLIS (0x01) | |
| \_SB.PCI0.VID.VLOC (0x01) | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.PEG.VID.VLOC (0x01) | |
| } | |
| Notify (\_SB.LID, 0x80) // Status Change | |
| } | |
| } | |
| } | |
| } | |
| Method (_Q2B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \UCMS (0x0D) | |
| \VCMS (0x01, \_SB.LID._LID ()) | |
| If ((\ILNF == 0x00)) | |
| { | |
| If ((\IOEN && !\IOST)) | |
| { | |
| If (!\ISOC (0x01)) | |
| { | |
| \IOST = 0x01 | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x60D0) | |
| } | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x5001) | |
| If ((\PLUX == 0x00)) | |
| { | |
| If (VIGD) | |
| { | |
| \_SB.PCI0.VID.GLIS (0x00) | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.PEG.VID.VLOC (0x00) | |
| } | |
| Notify (\_SB.LID, 0x80) // Status Change | |
| } | |
| } | |
| } | |
| } | |
| Method (_Q3D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| } | |
| Method (_Q48, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| Else | |
| { | |
| \STEP (0x04) | |
| } | |
| \_SB.PCI0.LPC.EC.CALM = 0x01 | |
| } | |
| } | |
| Method (_Q49, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| Else | |
| { | |
| \STEP (0x05) | |
| } | |
| } | |
| } | |
| Method (_Q7F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Fatal (0x01, 0x80010000, 0x1FD2) | |
| } | |
| Method (_Q4E, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6011) | |
| } | |
| Method (_Q4F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6012) | |
| } | |
| Method (_Q46, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6012) | |
| } | |
| Method (_Q22, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| CLPM () | |
| If (HB0A) | |
| { | |
| Notify (BAT0, 0x80) // Status Change | |
| } | |
| } | |
| Method (_Q4A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| CLPM () | |
| Notify (BAT0, 0x81) // Information Change | |
| } | |
| Method (_Q4B, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| CLPM () | |
| Notify (BAT0, 0x80) // Status Change | |
| } | |
| Method (_Q24, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| CLPM () | |
| Notify (BAT0, 0x80) // Status Change | |
| } | |
| Method (BATW, 1, NotSerialized) | |
| { | |
| If (\BT2T){} | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBRC, 16, | |
| SBFC, 16, | |
| SBAE, 16, | |
| SBRS, 16, | |
| SBAC, 16, | |
| SBVO, 16, | |
| SBAF, 16, | |
| SBBS, 16 | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBBM, 16, | |
| SBMD, 16, | |
| SBCC, 16 | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBDC, 16, | |
| SBDV, 16, | |
| SBOM, 16, | |
| SBSI, 16, | |
| SBDT, 16, | |
| SBSN, 16 | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBCH, 32 | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBMN, 128 | |
| } | |
| Field (ECOR, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| SBDN, 128 | |
| } | |
| Mutex (BATM, 0x07) | |
| Method (GBIF, 3, NotSerialized) | |
| { | |
| Acquire (BATM, 0xFFFF) | |
| If (Arg2) | |
| { | |
| HIID = (Arg0 | 0x01) | |
| Local7 = SBBM /* \_SB_.PCI0.LPC_.EC__.SBBM */ | |
| Local7 >>= 0x0F | |
| Arg1 [0x00] = (Local7 ^ 0x01) | |
| HIID = Arg0 | |
| If (Local7) | |
| { | |
| Local1 = (SBFC * 0x0A) | |
| } | |
| Else | |
| { | |
| Local1 = SBFC /* \_SB_.PCI0.LPC_.EC__.SBFC */ | |
| } | |
| Arg1 [0x02] = Local1 | |
| HIID = (Arg0 | 0x02) | |
| If (Local7) | |
| { | |
| Local0 = (SBDC * 0x0A) | |
| } | |
| Else | |
| { | |
| Local0 = SBDC /* \_SB_.PCI0.LPC_.EC__.SBDC */ | |
| } | |
| Arg1 [0x01] = Local0 | |
| Divide (Local1, 0x14, Local2, Arg1 [0x05]) | |
| If (Local7) | |
| { | |
| Arg1 [0x06] = 0xC8 | |
| } | |
| ElseIf (SBDV) | |
| { | |
| Divide (0x00030D40, SBDV, Local2, Arg1 [0x06]) | |
| } | |
| Else | |
| { | |
| Arg1 [0x06] = 0x00 | |
| } | |
| Arg1 [0x04] = SBDV /* \_SB_.PCI0.LPC_.EC__.SBDV */ | |
| Local0 = SBSN /* \_SB_.PCI0.LPC_.EC__.SBSN */ | |
| Name (SERN, Buffer (0x06) | |
| { | |
| " " | |
| }) | |
| Local2 = 0x04 | |
| While (Local0) | |
| { | |
| Divide (Local0, 0x0A, Local1, Local0) | |
| SERN [Local2] = (Local1 + 0x30) | |
| Local2-- | |
| } | |
| Arg1 [0x0A] = SERN /* \_SB_.PCI0.LPC_.EC__.GBIF.SERN */ | |
| HIID = (Arg0 | 0x06) | |
| Arg1 [0x09] = SBDN /* \_SB_.PCI0.LPC_.EC__.SBDN */ | |
| HIID = (Arg0 | 0x04) | |
| Name (BTYP, Buffer (0x05) | |
| { | |
| 0x00, 0x00, 0x00, 0x00, 0x00 // ..... | |
| }) | |
| BTYP = SBCH /* \_SB_.PCI0.LPC_.EC__.SBCH */ | |
| Arg1 [0x0B] = BTYP /* \_SB_.PCI0.LPC_.EC__.GBIF.BTYP */ | |
| HIID = (Arg0 | 0x05) | |
| Arg1 [0x0C] = SBMN /* \_SB_.PCI0.LPC_.EC__.SBMN */ | |
| } | |
| Else | |
| { | |
| Arg1 [0x01] = 0xFFFFFFFF | |
| Arg1 [0x05] = 0x00 | |
| Arg1 [0x06] = 0x00 | |
| Arg1 [0x02] = 0xFFFFFFFF | |
| } | |
| Release (BATM) | |
| Return (Arg1) | |
| } | |
| Method (GBST, 4, NotSerialized) | |
| { | |
| Acquire (BATM, 0xFFFF) | |
| If ((Arg1 & 0x20)) | |
| { | |
| Local0 = 0x02 | |
| } | |
| ElseIf ((Arg1 & 0x40)) | |
| { | |
| Local0 = 0x01 | |
| } | |
| Else | |
| { | |
| Local0 = 0x00 | |
| } | |
| If ((Arg1 & 0x07)){} | |
| Else | |
| { | |
| Local0 |= 0x04 | |
| } | |
| If (((Arg1 & 0x07) == 0x07)) | |
| { | |
| Local0 = 0x04 | |
| Local1 = 0x00 | |
| Local2 = 0x00 | |
| Local3 = 0x00 | |
| } | |
| Else | |
| { | |
| HIID = Arg0 | |
| Local3 = SBVO /* \_SB_.PCI0.LPC_.EC__.SBVO */ | |
| If (Arg2) | |
| { | |
| Local2 = (SBRC * 0x0A) | |
| } | |
| Else | |
| { | |
| Local2 = SBRC /* \_SB_.PCI0.LPC_.EC__.SBRC */ | |
| } | |
| Local1 = SBAC /* \_SB_.PCI0.LPC_.EC__.SBAC */ | |
| If ((Local1 >= 0x8000)) | |
| { | |
| If ((Local0 & 0x01)) | |
| { | |
| Local1 = (0x00010000 - Local1) | |
| } | |
| Else | |
| { | |
| Local1 = 0x00 | |
| } | |
| } | |
| ElseIf (!(Local0 & 0x02)) | |
| { | |
| Local1 = 0x00 | |
| } | |
| If (Arg2) | |
| { | |
| Local1 *= Local3 | |
| Divide (Local1, 0x03E8, Local7, Local1) | |
| } | |
| } | |
| Arg3 [0x00] = Local0 | |
| Arg3 [0x01] = Local1 | |
| Arg3 [0x02] = Local2 | |
| Arg3 [0x03] = Local3 | |
| Release (BATM) | |
| Return (Arg3) | |
| } | |
| Device (BAT0) | |
| { | |
| Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID | |
| Name (_UID, 0x00) // _UID: Unique ID | |
| Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
| { | |
| \_SB | |
| }) | |
| Name (B0ST, 0x00) | |
| Name (BT0I, Package (0x0D) | |
| { | |
| 0x00, | |
| 0xFFFFFFFF, | |
| 0xFFFFFFFF, | |
| 0x01, | |
| 0x2A30, | |
| 0x00, | |
| 0x00, | |
| 0x01, | |
| 0x01, | |
| "", | |
| "", | |
| "", | |
| "" | |
| }) | |
| Name (BT0P, Package (0x04){}) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (\H8DR) | |
| { | |
| B0ST = HB0A /* \_SB_.PCI0.LPC_.EC__.HB0A */ | |
| } | |
| ElseIf ((\RBEC (0x38) & 0x80)) | |
| { | |
| B0ST = 0x01 | |
| } | |
| Else | |
| { | |
| B0ST = 0x00 | |
| } | |
| If (B0ST) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Method (_BIF, 0, NotSerialized) // _BIF: Battery Information | |
| { | |
| Local7 = 0x00 | |
| Local6 = 0x0A | |
| While ((!Local7 && Local6)) | |
| { | |
| If (HB0A) | |
| { | |
| If (((HB0S & 0x07) == 0x07)) | |
| { | |
| Sleep (0x03E8) | |
| Local6-- | |
| } | |
| Else | |
| { | |
| Local7 = 0x01 | |
| } | |
| } | |
| Else | |
| { | |
| Local6 = 0x00 | |
| } | |
| } | |
| Return (GBIF (0x00, BT0I, Local7)) | |
| } | |
| Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
| { | |
| Local0 = (DerefOf (BT0I [0x00]) ^ 0x01) | |
| Return (GBST (0x00, HB0S, Local0, BT0P)) | |
| } | |
| Method (_BTP, 1, NotSerialized) // _BTP: Battery Trip Point | |
| { | |
| HAM4 &= 0xEF | |
| If (Arg0) | |
| { | |
| Local1 = Arg0 | |
| If (!DerefOf (BT0I [0x00])) | |
| { | |
| Divide (Local1, 0x0A, Local0, Local1) | |
| } | |
| HT0L = (Local1 & 0xFF) | |
| HT0H = ((Local1 >> 0x08) & 0xFF) | |
| HAM4 |= 0x10 | |
| } | |
| } | |
| } | |
| Device (AC) | |
| { | |
| Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID | |
| Name (_UID, 0x00) // _UID: Unique ID | |
| Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
| { | |
| \_SB | |
| }) | |
| Method (_PSR, 0, NotSerialized) // _PSR: Power Source | |
| { | |
| If (\H8DR) | |
| { | |
| Return (HPAC) /* \_SB_.PCI0.LPC_.EC__.HPAC */ | |
| } | |
| ElseIf ((\RBEC (0x46) & 0x10)) | |
| { | |
| Return (0x01) | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Device (HKEY) | |
| { | |
| Name (_HID, EisaId ("LEN0068")) // _HID: Hardware ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Method (MHKV, 0, NotSerialized) | |
| { | |
| Return (0x0100) | |
| } | |
| Name (DHKC, 0x00) | |
| Name (DHKB, 0x01) | |
| Mutex (XDHK, 0x07) | |
| Name (DHKH, 0x00) | |
| Name (DHKW, 0x00) | |
| Name (DHKS, 0x00) | |
| Name (DHKD, 0x00) | |
| Name (DHKN, 0x0808) | |
| Name (DHKT, 0x00) | |
| Name (DHWW, 0x00) | |
| Method (MHKA, 0, NotSerialized) | |
| { | |
| Return (0xFFFFFFFB) | |
| } | |
| Method (MHKN, 0, NotSerialized) | |
| { | |
| Return (DHKN) /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKN */ | |
| } | |
| Method (MHKK, 1, NotSerialized) | |
| { | |
| If (DHKC) | |
| { | |
| Return ((DHKN & Arg0)) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (MHKM, 2, NotSerialized) | |
| { | |
| Acquire (XDHK, 0xFFFF) | |
| If ((Arg0 > 0x20)) | |
| { | |
| Noop | |
| } | |
| Else | |
| { | |
| Local0 = (One << Arg0--) | |
| If ((Local0 & 0xFFFFFFFB)) | |
| { | |
| If (Arg1) | |
| { | |
| DHKN |= Local0 /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKN */ | |
| } | |
| Else | |
| { | |
| DHKN &= (Local0 ^ 0xFFFFFFFF) | |
| } | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| Release (XDHK) | |
| } | |
| Method (MHKS, 0, NotSerialized) | |
| { | |
| Notify (\_SB.SLPB, 0x80) // Status Change | |
| } | |
| Method (MHKC, 1, NotSerialized) | |
| { | |
| DHKC = Arg0 | |
| } | |
| Method (MHKP, 0, NotSerialized) | |
| { | |
| Acquire (XDHK, 0xFFFF) | |
| If (DHWW) | |
| { | |
| Local1 = DHWW /* \_SB_.PCI0.LPC_.EC__.HKEY.DHWW */ | |
| DHWW = Zero | |
| } | |
| ElseIf (DHKW) | |
| { | |
| Local1 = DHKW /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKW */ | |
| DHKW = Zero | |
| } | |
| ElseIf (DHKD) | |
| { | |
| Local1 = DHKD /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKD */ | |
| DHKD = Zero | |
| } | |
| ElseIf (DHKS) | |
| { | |
| Local1 = DHKS /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKS */ | |
| DHKS = Zero | |
| } | |
| ElseIf (DHKT) | |
| { | |
| Local1 = DHKT /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKT */ | |
| DHKT = Zero | |
| } | |
| Else | |
| { | |
| Local1 = DHKH /* \_SB_.PCI0.LPC_.EC__.HKEY.DHKH */ | |
| DHKH = Zero | |
| } | |
| Release (XDHK) | |
| Return (Local1) | |
| } | |
| Method (MHKE, 1, NotSerialized) | |
| { | |
| DHKB = Arg0 | |
| Acquire (XDHK, 0xFFFF) | |
| DHKH = Zero | |
| DHKW = Zero | |
| DHKS = Zero | |
| DHKD = Zero | |
| DHKT = Zero | |
| DHWW = Zero | |
| Release (XDHK) | |
| } | |
| Method (MHKQ, 1, NotSerialized) | |
| { | |
| If (DHKB) | |
| { | |
| If (DHKC) | |
| { | |
| Acquire (XDHK, 0xFFFF) | |
| If ((Arg0 < 0x1000)){} | |
| ElseIf ((Arg0 < 0x2000)) | |
| { | |
| DHKH = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x3000)) | |
| { | |
| DHKW = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x4000)) | |
| { | |
| DHKS = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x5000)) | |
| { | |
| DHKD = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x6000)) | |
| { | |
| DHKH = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x7000)) | |
| { | |
| DHKT = Arg0 | |
| } | |
| ElseIf ((Arg0 < 0x8000)) | |
| { | |
| DHWW = Arg0 | |
| } | |
| Else | |
| { | |
| } | |
| Release (XDHK) | |
| Notify (HKEY, 0x80) // Status Change | |
| } | |
| ElseIf ((Arg0 == 0x1004)) | |
| { | |
| Notify (\_SB.SLPB, 0x80) // Status Change | |
| } | |
| } | |
| } | |
| Method (MHKB, 1, NotSerialized) | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x11) | |
| \LIDB = 0x00 | |
| } | |
| ElseIf ((Arg0 == 0x01)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x10) | |
| \LIDB = 0x01 | |
| } | |
| Else | |
| { | |
| } | |
| } | |
| Method (MHKD, 0, NotSerialized) | |
| { | |
| If ((\PLUX == 0x00)) | |
| { | |
| If (VIGD) | |
| { | |
| \_SB.PCI0.VID.VLOC (0x00) | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.PEG.VID.VLOC (0x00) | |
| } | |
| } | |
| } | |
| Method (MHQC, 1, NotSerialized) | |
| { | |
| If (\WNTF) | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| Return (\CWAC) | |
| } | |
| ElseIf ((Arg0 == 0x01)) | |
| { | |
| Return (\CWAP) | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| Return (\CWAT) | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| Return (0x00) | |
| } | |
| Method (MHGC, 0, NotSerialized) | |
| { | |
| If (\WNTF) | |
| { | |
| Acquire (XDHK, 0xFFFF) | |
| If (CKC4 (0x00)) | |
| { | |
| Local0 = 0x03 | |
| } | |
| Else | |
| { | |
| Local0 = 0x04 | |
| } | |
| Release (XDHK) | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| Return (0x00) | |
| } | |
| Method (MHSC, 1, NotSerialized) | |
| { | |
| If ((\CWAC && \WNTF)) | |
| { | |
| Acquire (XDHK, 0xFFFF) | |
| If (\OSC4) | |
| { | |
| If ((Arg0 == 0x03)) | |
| { | |
| If (!\CWAS) | |
| { | |
| \PNTF (0x81) | |
| \CWAS = 0x01 | |
| } | |
| } | |
| ElseIf ((Arg0 == 0x04)) | |
| { | |
| If (\CWAS) | |
| { | |
| \PNTF (0x81) | |
| \CWAS = 0x00 | |
| } | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| Release (XDHK) | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| Method (CKC4, 1, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If (\C4WR) | |
| { | |
| If (!\C4AC) | |
| { | |
| Local0 |= 0x01 | |
| } | |
| } | |
| If (\C4NA) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| If ((\CWAC && \CWAS)) | |
| { | |
| Local0 |= 0x04 | |
| } | |
| Local0 &= ~Arg0 | |
| Return (Local0) | |
| } | |
| Method (MHQE, 0, NotSerialized) | |
| { | |
| Return (\C4WR) | |
| } | |
| Method (MHGE, 0, NotSerialized) | |
| { | |
| If ((\C4WR && \C4AC)) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x03) | |
| } | |
| Method (MHSE, 1, NotSerialized) | |
| { | |
| If (\C4WR) | |
| { | |
| Local0 = \C4AC | |
| If ((Arg0 == 0x03)) | |
| { | |
| \C4AC = 0x00 | |
| If ((Local0 ^ \C4AC)) | |
| { | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| } | |
| } | |
| ElseIf ((Arg0 == 0x04)) | |
| { | |
| \C4AC = 0x01 | |
| If ((Local0 ^ \C4AC)) | |
| { | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Method (UAWO, 1, NotSerialized) | |
| { | |
| Return (\UAWS (Arg0)) | |
| } | |
| Method (MLCG, 1, NotSerialized) | |
| { | |
| Local0 = \KBLS (0x00, 0x00) | |
| Return (Local0) | |
| } | |
| Method (MLCS, 1, NotSerialized) | |
| { | |
| Local0 = \KBLS (0x01, Arg0) | |
| If (!(Local0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x00010000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6001) | |
| } | |
| ElseIf (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00020000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1012) | |
| } | |
| } | |
| Return (Local0) | |
| } | |
| Method (DSSG, 1, NotSerialized) | |
| { | |
| Local0 = (0x0400 | \PDCI) | |
| Return (Local0) | |
| } | |
| Method (DSSS, 1, NotSerialized) | |
| { | |
| \PDCI |= Arg0 | |
| } | |
| Method (SBSG, 1, NotSerialized) | |
| { | |
| Return (\SYBC (0x00, 0x00)) | |
| } | |
| Method (SBSS, 1, NotSerialized) | |
| { | |
| Return (\SYBC (0x01, Arg0)) | |
| } | |
| Method (PBLG, 1, NotSerialized) | |
| { | |
| Local0 = \BRLV | |
| Local1 = (Local0 | 0x0F00) | |
| Return (Local1) | |
| } | |
| Method (PBLS, 1, NotSerialized) | |
| { | |
| \BRLV = Arg0 | |
| If (\VIGD) | |
| { | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \VBRC (\BRLV) | |
| } | |
| If (!\NBCF) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6050) | |
| } | |
| Return (0x00) | |
| } | |
| Method (PMSG, 1, NotSerialized) | |
| { | |
| Local0 = \PRSM (0x00, 0x00) | |
| Return (Local0) | |
| } | |
| Method (PMSS, 1, NotSerialized) | |
| { | |
| \PRSM (0x01, Arg0) | |
| Return (0x00) | |
| } | |
| Method (ISSG, 1, NotSerialized) | |
| { | |
| Local0 = \ISSP | |
| Local0 |= 0x80 | |
| Local0 |= (\ISCG & 0x30) | |
| Return (Local0) | |
| } | |
| Method (ISSS, 1, NotSerialized) | |
| { | |
| \ISCG = Arg0 | |
| Return (0x00) | |
| } | |
| Method (FFSG, 1, NotSerialized) | |
| { | |
| Return (\IFRS (0x00, 0x00)) | |
| } | |
| Method (FFSS, 1, NotSerialized) | |
| { | |
| \IFRS (0x01, Arg0) | |
| Return (0x00) | |
| } | |
| Method (GMKS, 0, NotSerialized) | |
| { | |
| Return (\FNSC (0x02, 0x00)) | |
| } | |
| Method (SMKS, 1, NotSerialized) | |
| { | |
| Return (\FNSC (0x03, (Arg0 & 0x00010001))) | |
| } | |
| Method (INSG, 1, NotSerialized) | |
| { | |
| Local0 = \IOEN | |
| Local0 |= (\IOST << 0x07) | |
| Local0 |= (\IOCP << 0x08) | |
| Return (Local0) | |
| } | |
| Method (INSS, 1, NotSerialized) | |
| { | |
| If ((\IOCP && (Arg0 & 0x01))) | |
| { | |
| \IOEN = 0x01 | |
| } | |
| Else | |
| { | |
| \IOEN = 0x00 | |
| If (\IOST) | |
| { | |
| If (!\ISOC (0x00)) | |
| { | |
| \IOST = 0x00 | |
| } | |
| } | |
| } | |
| Return (0x00) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Name (INDV, 0x00) | |
| Method (MHQI, 0, NotSerialized) | |
| { | |
| If ((\IPMS & 0x01)) | |
| { | |
| INDV |= 0x01 | |
| } | |
| If ((\IPMS & 0x02)) | |
| { | |
| INDV |= 0x02 | |
| } | |
| If ((\IPMS & 0x08)) | |
| { | |
| INDV |= 0x0200 | |
| } | |
| If ((\IPMS & 0x10)) | |
| { | |
| INDV |= 0x04 | |
| } | |
| Return (INDV) /* \_SB_.PCI0.LPC_.EC__.HKEY.INDV */ | |
| } | |
| Method (MHGI, 1, NotSerialized) | |
| { | |
| Name (RETB, Buffer (0x10){}) | |
| CreateByteField (RETB, 0x00, MHGS) | |
| Local0 = (0x01 << Arg0) | |
| If ((INDV & Local0)) | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| CreateField (RETB, 0x08, 0x78, BRBU) | |
| BRBU = \IPMB | |
| MHGS = 0x10 | |
| } | |
| ElseIf ((Arg0 == 0x01)) | |
| { | |
| CreateField (RETB, 0x08, 0x18, RRBU) | |
| RRBU = \IPMR | |
| MHGS = 0x04 | |
| } | |
| ElseIf ((Arg0 == 0x08)) | |
| { | |
| CreateField (RETB, 0x10, 0x18, ODBU) | |
| CreateByteField (RETB, 0x01, MHGZ) | |
| ODBU = \IPMO | |
| If ((^^BDEV == 0x03)) | |
| { | |
| If (\H8DR) | |
| { | |
| Local1 = ^^HPBU /* \_SB_.PCI0.LPC_.EC__.HPBU */ | |
| } | |
| Else | |
| { | |
| Local1 = (\RBEC (0x47) & 0x01) | |
| } | |
| If (!Local1) | |
| { | |
| MHGZ |= 0x04 /* \_SB_.PCI0.LPC_.EC__.HKEY.MHGI.MHGZ */ | |
| } | |
| If ((^^BSTS == 0x00)) | |
| { | |
| MHGZ |= 0x01 /* \_SB_.PCI0.LPC_.EC__.HKEY.MHGI.MHGZ */ | |
| MHGZ |= 0x02 /* \_SB_.PCI0.LPC_.EC__.HKEY.MHGI.MHGZ */ | |
| } | |
| } | |
| MHGS = 0x05 | |
| } | |
| ElseIf ((Arg0 == 0x09)) | |
| { | |
| CreateField (RETB, 0x10, 0x08, AUBU) | |
| AUBU = \IPMA | |
| RETB [0x01] = 0x01 | |
| MHGS = 0x03 | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| Local1 = \VDYN (0x00, 0x00) | |
| RETB [0x02] = (Local1 & 0x0F) | |
| Local1 >>= 0x04 | |
| RETB [0x01] = (Local1 & 0x0F) | |
| MHGS = 0x03 | |
| } | |
| } | |
| Return (RETB) /* \_SB_.PCI0.LPC_.EC__.HKEY.MHGI.RETB */ | |
| } | |
| Method (MHSI, 2, NotSerialized) | |
| { | |
| Local0 = (0x01 << Arg0) | |
| If ((INDV & Local0)) | |
| { | |
| If ((Arg0 == 0x08)) | |
| { | |
| If (Arg1) | |
| { | |
| If (\H8DR) | |
| { | |
| Local1 = ^^HPBU /* \_SB_.PCI0.LPC_.EC__.HPBU */ | |
| } | |
| Else | |
| { | |
| Local1 = (\RBEC (0x47) & 0x01) | |
| } | |
| If (!Local1) | |
| { | |
| ^^BDEV = ^^BGID (0x00) | |
| ^^NBIN (Local1) | |
| } | |
| } | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| \VDYN (0x01, Arg1) | |
| } | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q6A, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (HDMC) | |
| { | |
| Noop | |
| } | |
| ElseIf (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x04000000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x101B) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (MMTG, 0, NotSerialized) | |
| { | |
| Local0 = 0x0101 | |
| If (HDMC) | |
| { | |
| Local0 |= 0x00010000 | |
| } | |
| Return (Local0) | |
| } | |
| Method (MMTS, 1, NotSerialized) | |
| { | |
| If (HDMC) | |
| { | |
| Noop | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x0E, 0x80) | |
| } | |
| ElseIf ((Arg0 == 0x03)) | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x0E, 0xC0) | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x0E, 0x00) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (PWMC, 0, NotSerialized) | |
| { | |
| Return (0x01) | |
| } | |
| Method (PWMG, 0, NotSerialized) | |
| { | |
| Local0 = \_SB.PCI0.LPC.EC.PWMH | |
| Local0 <<= 0x08 | |
| Local0 |= \_SB.PCI0.LPC.EC.PWML | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q45, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (DOCD) | |
| { | |
| Sleep (0x64) | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x4010) | |
| } | |
| Else | |
| { | |
| Sleep (0x64) | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x4011) | |
| } | |
| } | |
| Method (DKID, 0, NotSerialized) | |
| { | |
| Local0 = \_SB.PCI0.LPC.DOI0 | |
| Local1 = \_SB.PCI0.LPC.DOI1 | |
| Local2 = \_SB.PCI0.LPC.DOI2 | |
| Local3 = \_SB.PCI0.LPC.DOI3 | |
| Local0 |= (Local1 << 0x01) | |
| Local0 |= (Local2 << 0x02) | |
| Local0 |= (Local3 << 0x03) | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (GDKS, 0, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If ((\_SB.PCI0.LPC.EC.DOCD == 0x01)) | |
| { | |
| Local0 |= 0x01 | |
| Local1 = \_SB.PCI0.LPC.EC.DKID () | |
| Local1 <<= 0x08 | |
| Local0 |= Local1 | |
| } | |
| Local0 |= 0x00010000 | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q3F, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6000) | |
| } | |
| Method (_Q74, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6060) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (NUMG, 0, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| Return (Local0) | |
| } | |
| } | |
| } | |
| } | |
| Device (PEG0) | |
| { | |
| Name (_ADR, 0x00010000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| Name (LART, Package (0x02) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| \_SB.LNKB, | |
| 0x00 | |
| } | |
| }) | |
| Name (AART, Package (0x02) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x11 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (AART) /* \_SB_.PCI0.PEG0.AART */ | |
| } | |
| Else | |
| { | |
| Return (LART) /* \_SB_.PCI0.PEG0.LART */ | |
| } | |
| } | |
| } | |
| Device (PEG) | |
| { | |
| Name (_ADR, 0x00010001) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| Name (LART, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKA, | |
| 0x00 | |
| } | |
| }) | |
| Name (AART, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x10 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (AART) /* \_SB_.PCI0.PEG_.AART */ | |
| } | |
| Else | |
| { | |
| Return (LART) /* \_SB_.PCI0.PEG_.LART */ | |
| } | |
| } | |
| Mutex (MDGS, 0x07) | |
| Name (VDEE, 0x01) | |
| Name (VDDA, Buffer (0x04){}) | |
| CreateBitField (VDDA, 0x00, VUPC) | |
| CreateBitField (VDDA, 0x01, VQDL) | |
| CreateBitField (VDDA, 0x02, VQDC) | |
| CreateBitField (VDDA, 0x03, VQD0) | |
| CreateBitField (VDDA, 0x04, VQD1) | |
| CreateBitField (VDDA, 0x05, VQD2) | |
| CreateBitField (VDDA, 0x06, VQD3) | |
| CreateBitField (VDDA, 0x07, VQD4) | |
| CreateBitField (VDDA, 0x08, VQD5) | |
| CreateBitField (VDDA, 0x09, VSDL) | |
| CreateBitField (VDDA, 0x0A, VSDC) | |
| CreateBitField (VDDA, 0x0B, VSD0) | |
| CreateBitField (VDDA, 0x0C, VSD1) | |
| CreateBitField (VDDA, 0x0D, VSD2) | |
| CreateBitField (VDDA, 0x0E, VSD3) | |
| CreateBitField (VDDA, 0x0F, VSD4) | |
| CreateBitField (VDDA, 0x10, VSD5) | |
| CreateBitField (VDDA, 0x11, MSWT) | |
| CreateBitField (VDDA, 0x12, VWST) | |
| Name (WKEN, 0x00) | |
| Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
| { | |
| If (Arg1) | |
| { | |
| WKEN = 0x00 | |
| } | |
| ElseIf ((Arg0 && Arg2)) | |
| { | |
| WKEN = 0x01 | |
| } | |
| Else | |
| { | |
| WKEN = 0x00 | |
| } | |
| } | |
| PowerResource (NVP3, 0x00, 0x0000) | |
| { | |
| Name (_STA, One) // _STA: Status | |
| Method (_ON, 0, Serialized) // _ON_: Power On | |
| { | |
| \_SB.PCI0.PEG.VID.GPON (0x00) | |
| _STA = One | |
| } | |
| Method (_OFF, 0, Serialized) // _OFF: Power Off | |
| { | |
| \_SB.PCI0.PEG.VID.GPOF (0x00) | |
| _STA = Zero | |
| } | |
| } | |
| PowerResource (NVP2, 0x00, 0x0000) | |
| { | |
| Name (_STA, One) // _STA: Status | |
| Method (_ON, 0, Serialized) // _ON_: Power On | |
| { | |
| _STA = One | |
| } | |
| Method (_OFF, 0, Serialized) // _OFF: Power Off | |
| { | |
| _STA = One | |
| } | |
| } | |
| Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
| { | |
| NVP3 | |
| }) | |
| Name (_PR2, Package (0x01) // _PR2: Power Resources for D2 | |
| { | |
| NVP2 | |
| }) | |
| Name (_PR3, Package (0x01) // _PR3: Power Resources for D3hot | |
| { | |
| NVP3 | |
| }) | |
| Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State | |
| { | |
| Return (0x04) | |
| } | |
| Device (VID) | |
| { | |
| Name (_ADR, 0x00) // _ADR: Address | |
| OperationRegion (VPCG, PCI_Config, 0x00, 0x0100) | |
| Field (VPCG, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x2C), | |
| VSID, 32, | |
| Offset (0x40), | |
| VIDS, 32, | |
| Offset (0x70), | |
| VPWR, 8 | |
| } | |
| OperationRegion (GPPB, PCI_Config, 0xB4, 0x14) | |
| Field (GPPB, ByteAcc, NoLock, Preserve) | |
| { | |
| PBCI, 8, | |
| PBNP, 8, | |
| PBLS, 8, | |
| PBCC, 8, | |
| PBCR, 32, | |
| PBDI, 32, | |
| PBDO, 32, | |
| PBMR, 32 | |
| } | |
| Method (VRSI, 0, NotSerialized) | |
| { | |
| If ((OSYS >= 0x07DD)) | |
| { | |
| VIDS = 0x221D17AA | |
| } | |
| Else | |
| { | |
| VIDS = 0x220F17AA | |
| } | |
| } | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (DGOS, 0x00) | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| \VUPS (0x02) | |
| VQDL = \VCDL | |
| VQDC = \VCDC | |
| VQD0 = \VCDT | |
| VQD1 = \VCDD | |
| VRSI () | |
| If (ISOP ()) | |
| { | |
| \VHYB (0x04, 0x01) | |
| } | |
| } | |
| Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
| { | |
| If (!VMSH) | |
| { | |
| GPON (0x00) | |
| } | |
| } | |
| Method (_PS1, 0, NotSerialized) // _PS1: Power State 1 | |
| { | |
| Noop | |
| } | |
| Method (_PS2, 0, NotSerialized) // _PS2: Power State 2 | |
| { | |
| Noop | |
| } | |
| Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
| { | |
| If (!VMSH) | |
| { | |
| GPOF (0x00) | |
| } | |
| } | |
| Method (GPON, 1, NotSerialized) | |
| { | |
| If (ISOP ()) | |
| { | |
| If (DGOS) | |
| { | |
| \VHYB (0x02, 0x00) | |
| Sleep (0x64) | |
| If ((ToInteger (Arg0) == 0x00)){} | |
| \VHYB (0x00, 0x01) | |
| Sleep (0x64) | |
| \VHYB (0x02, 0x01) | |
| Sleep (0x01) | |
| \VHYB (0x08, 0x01) | |
| Local0 = 0x0A | |
| Local1 = 0x32 | |
| While (Local1) | |
| { | |
| Sleep (Local0) | |
| If (\LCHK (0x01)) | |
| { | |
| Break | |
| } | |
| Local1-- | |
| } | |
| \VHYB (0x08, 0x03) | |
| If (VMSH) | |
| { | |
| \VHYB (0x0D, 0x00) | |
| } | |
| Local1 = 0xC8 | |
| While (Local1) | |
| { | |
| Sleep (0x01) | |
| If (\VHYB (0x0C, 0x00)) | |
| { | |
| Break | |
| } | |
| Local1-- | |
| } | |
| \VHYB (0x04, 0x00) | |
| \SWTT (0x01) | |
| DGOS = Zero | |
| } | |
| ElseIf (((VSID != 0x220F17AA) && (VSID != 0x221D17AA))) | |
| { | |
| \VHYB (0x04, 0x00) | |
| } | |
| \VHYB (0x09, \_SB.PCI0.PEG.VID.HDAS) | |
| } | |
| Else | |
| { | |
| VIDS = 0x220E17AA | |
| } | |
| } | |
| Method (GPOF, 1, NotSerialized) | |
| { | |
| If (ISOP ()) | |
| { | |
| If ((VMSH || (\_SB.PCI0.PEG.VID.OMPR == 0x03))) | |
| { | |
| \SWTT (0x00) | |
| \VHYB (0x08, 0x00) | |
| Local0 = 0x0A | |
| Local1 = 0x32 | |
| While (Local1) | |
| { | |
| Sleep (Local0) | |
| If (\LCHK (0x00)) | |
| { | |
| Break | |
| } | |
| Local1-- | |
| } | |
| \VHYB (0x08, 0x02) | |
| \VHYB (0x02, 0x00) | |
| Sleep (0x64) | |
| \VHYB (0x00, 0x00) | |
| If ((ToInteger (Arg0) == 0x00)){} | |
| DGOS = One | |
| \_SB.PCI0.PEG.VID.OMPR = 0x02 | |
| } | |
| } | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Method (_DSM, 4, NotSerialized) // _DSM: Device-Specific Method | |
| { | |
| If (\CMPB (Arg0, ToUUID ("a486d8f8-0bda-471b-a72b-6042a6b5bee0"))) | |
| { | |
| Return (NVOP (Arg0, Arg1, Arg2, Arg3)) | |
| } | |
| If (\CMPB (Arg0, ToUUID ("a3132d01-8cda-49ba-a52e-bc9d46df6b81"))) | |
| { | |
| Return (NVPS (Arg0, Arg1, Arg2, Arg3)) | |
| } | |
| If (\WIN8) | |
| { | |
| If (\CMPB (Arg0, ToUUID ("d4a50b75-65c7-46f7-bfb7-41514cea0244"))) | |
| { | |
| Return (NBCI (Arg0, Arg1, Arg2, Arg3)) | |
| } | |
| } | |
| Return (Buffer (0x04) | |
| { | |
| 0x01, 0x00, 0x00, 0x80 // .... | |
| }) | |
| } | |
| OperationRegion (ATRP, SystemMemory, \ATRB, 0x00100000) | |
| Field (ATRP, AnyAcc, Lock, Preserve) | |
| { | |
| IDX0, 262144, | |
| IDX1, 262144, | |
| IDX2, 262144, | |
| IDX3, 262144 | |
| } | |
| Method (_ROM, 2, Serialized) // _ROM: Read-Only Memory | |
| { | |
| If ((Arg0 >= 0x00018000)) | |
| { | |
| Return (GETB ((Arg0 - 0x00018000), Arg1, IDX3)) | |
| } | |
| If (((Arg0 + Arg1) > 0x00018000)) | |
| { | |
| Local0 = (0x00018000 - Arg0) | |
| Local1 = (Arg1 - Local0) | |
| Local3 = GETB (Arg0, Local0, IDX2) | |
| Local4 = GETB (0x00, Local1, IDX3) | |
| Concatenate (Local3, Local4, Local5) | |
| Return (Local5) | |
| } | |
| If (((Arg0 >= 0x00010000) && ((Arg0 + Arg1) <= | |
| 0x00018000))) | |
| { | |
| Return (GETB ((Arg0 - 0x00010000), Arg1, IDX2)) | |
| } | |
| If (((Arg0 + Arg1) > 0x00010000)) | |
| { | |
| Local0 = (0x00010000 - Arg0) | |
| Local1 = (Arg1 - Local0) | |
| Local3 = GETB (Arg0, Local0, IDX1) | |
| Local4 = GETB (0x00, Local1, IDX2) | |
| Concatenate (Local3, Local4, Local5) | |
| Return (Local5) | |
| } | |
| If (((Arg0 >= 0x8000) && ((Arg0 + Arg1) <= | |
| 0x00010000))) | |
| { | |
| Return (GETB ((Arg0 - 0x8000), Arg1, IDX1)) | |
| } | |
| If (((Arg0 + Arg1) > 0x8000)) | |
| { | |
| Local0 = (0x8000 - Arg0) | |
| Local1 = (Arg1 - Local0) | |
| Local3 = GETB (Arg0, Local0, IDX0) | |
| Local4 = GETB (0x00, Local1, IDX1) | |
| Concatenate (Local3, Local4, Local5) | |
| Return (Local5) | |
| } | |
| Return (GETB (Arg0, Arg1, IDX0)) | |
| } | |
| Method (GETB, 3, Serialized) | |
| { | |
| Local0 = (Arg0 * 0x08) | |
| Local1 = (Arg1 * 0x08) | |
| CreateField (Arg2, Local0, Local1, TBF3) | |
| Return (TBF3) /* \_SB_.PCI0.PEG_.VID_.GETB.TBF3 */ | |
| } | |
| Method (VSWT, 0, NotSerialized) | |
| { | |
| If (\WVIS) | |
| { | |
| Local0 = \VEVT (0x07) | |
| } | |
| Else | |
| { | |
| Local0 = \VEVT (0x05) | |
| } | |
| Local1 = (0xFF & Local0) | |
| If (Local1) | |
| { | |
| ASWT (Local1, 0x01) | |
| } | |
| } | |
| Method (VLOC, 1, NotSerialized) | |
| { | |
| If ((Arg0 == \_SB.LID._LID ())) | |
| { | |
| \VSLD (Arg0) | |
| If (((VPWR & 0x03) == 0x00)) | |
| { | |
| If (Arg0) | |
| { | |
| Local0 = \VEVT (0x01) | |
| } | |
| Else | |
| { | |
| Local0 = \VEVT (0x02) | |
| } | |
| Local1 = (0x0F & Local0) | |
| If (Local1) | |
| { | |
| ASWT (Local1, 0x00) | |
| } | |
| } | |
| } | |
| } | |
| Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
| { | |
| If ((Arg0 == 0x02)) | |
| { | |
| Local0 = 0x14 | |
| While (Local0) | |
| { | |
| Local0-- | |
| Acquire (MDGS, 0xFFFF) | |
| If ((0x00 == MSWT)) | |
| { | |
| MSWT = 0x01 | |
| Local0 = 0x00 | |
| VDEE = Arg0 | |
| } | |
| Release (MDGS) | |
| Sleep (0xC8) | |
| } | |
| } | |
| Else | |
| { | |
| Acquire (MDGS, 0xFFFF) | |
| If ((VDEE == 0x02)) | |
| { | |
| MSWT = 0x00 | |
| } | |
| If ((Arg0 > 0x02)) | |
| { | |
| VDEE = 0x01 | |
| } | |
| Else | |
| { | |
| VDEE = Arg0 | |
| } | |
| Release (MDGS) | |
| } | |
| } | |
| Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
| { | |
| Return (Package (0x08) | |
| { | |
| 0x0100, | |
| 0x0114, | |
| 0x0111, | |
| 0x0115, | |
| 0x0112, | |
| 0x0116, | |
| 0x0113, | |
| 0x0110 | |
| }) | |
| } | |
| Method (ASWT, 2, NotSerialized) | |
| { | |
| If ((0x01 == VDEE)) | |
| { | |
| Local1 = (0x01 & Arg1) | |
| \VSDS (Arg0, Local1) | |
| } | |
| Else | |
| { | |
| Local0 = 0x14 | |
| While (Local0) | |
| { | |
| Local0-- | |
| Acquire (MDGS, 0xFFFF) | |
| If ((0x00 == MSWT)) | |
| { | |
| Local0 = 0x00 | |
| If ((0x01 & Arg1)) | |
| { | |
| VUPC = 0x01 | |
| } | |
| Else | |
| { | |
| VUPC = 0x00 | |
| } | |
| If ((0x01 & Arg0)) | |
| { | |
| VQDL = 0x01 | |
| } | |
| Else | |
| { | |
| VQDL = 0x00 | |
| } | |
| If ((0x02 & Arg0)) | |
| { | |
| VQDC = 0x01 | |
| } | |
| Else | |
| { | |
| VQDC = 0x00 | |
| } | |
| If ((0x04 & Arg0)) | |
| { | |
| VQD0 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD0 = 0x00 | |
| } | |
| If ((0x08 & Arg0)) | |
| { | |
| VQD1 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD1 = 0x00 | |
| } | |
| If ((0x10 & Arg0)) | |
| { | |
| VQD2 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD2 = 0x00 | |
| } | |
| If ((0x20 & Arg0)) | |
| { | |
| VQD3 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD3 = 0x00 | |
| } | |
| If ((0x40 & Arg0)) | |
| { | |
| VQD4 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD4 = 0x00 | |
| } | |
| If ((0x80 & Arg0)) | |
| { | |
| VQD5 = 0x01 | |
| } | |
| Else | |
| { | |
| VQD5 = 0x00 | |
| } | |
| } | |
| Release (MDGS) | |
| Sleep (0xC8) | |
| } | |
| If ((0x02 & Arg1)) | |
| { | |
| Notify (VID, 0x81) // Information Change | |
| } | |
| Else | |
| { | |
| Notify (VID, 0x80) // Status Change | |
| } | |
| } | |
| } | |
| Method (VDSW, 1, NotSerialized) | |
| { | |
| If ((VPWR == 0x00)) | |
| { | |
| If (Arg0) | |
| { | |
| Local0 = \VEVT (0x03) | |
| } | |
| Else | |
| { | |
| Local0 = \VEVT (0x04) | |
| } | |
| Local1 = (0x0F & Local0) | |
| If (Local1) | |
| { | |
| ASWT (Local1, 0x00) | |
| } | |
| } | |
| } | |
| Device (LCD0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0110) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDL) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQDL) /* \_SB_.PCI0.PEG_.VQDL */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSDL = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| Method (_DDC, 1, NotSerialized) // _DDC: Display Data Current | |
| { | |
| If (ISOP ()) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 == 0x01)) | |
| { | |
| Return (\VEDI) | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| Return (\VEDI) | |
| } | |
| Return (0x00) | |
| } | |
| } | |
| Device (CRT0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0100) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x01) | |
| If (\VCSS) | |
| { | |
| If (\VCDC) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| ElseIf (\VCDC) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (0x0D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQDC) /* \_SB_.PCI0.PEG_.VQDC */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSDC = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DVI0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0111) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDD) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD1) /* \_SB_.PCI0.PEG_.VQD1 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD1 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DP0) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0114) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDT) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD0) /* \_SB_.PCI0.PEG_.VQD0 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD0 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DVI1) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0112) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDD) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD3) /* \_SB_.PCI0.PEG_.VQD3 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD3 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DP1) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0115) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDT) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD2) /* \_SB_.PCI0.PEG_.VQD2 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD2 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DVI2) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0113) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDD) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD5) /* \_SB_.PCI0.PEG_.VQD5 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD5 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Device (DP2) | |
| { | |
| Method (_ADR, 0, NotSerialized) // _ADR: Address | |
| { | |
| Return (0x0116) | |
| } | |
| Method (_DCS, 0, NotSerialized) // _DCS: Display Current Status | |
| { | |
| \VUPS (0x00) | |
| If (\VCDT) | |
| { | |
| Return (0x1F) | |
| } | |
| Else | |
| { | |
| Return (0x1D) | |
| } | |
| } | |
| Method (_DGS, 0, NotSerialized) // _DGS: Display Graphics State | |
| { | |
| Return (VQD4) /* \_SB_.PCI0.PEG_.VQD4 */ | |
| } | |
| Method (_DSS, 1, NotSerialized) // _DSS: Device Set State | |
| { | |
| VSD4 = (Arg0 & 0x01) | |
| If ((Arg0 & 0x80000000)) | |
| { | |
| If ((Arg0 & 0x40000000)) | |
| { | |
| DSWT (0x02) | |
| } | |
| Else | |
| { | |
| DSWT (0x01) | |
| } | |
| } | |
| } | |
| } | |
| Method (DSWT, 1, NotSerialized) | |
| { | |
| If (VSDL) | |
| { | |
| Local0 = 0x01 | |
| } | |
| Else | |
| { | |
| Local0 = 0x00 | |
| } | |
| If (VSDC) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| If (VSD0) | |
| { | |
| Local0 |= 0x08 | |
| } | |
| If (Local0) | |
| { | |
| If (VUPC) | |
| { | |
| \VSDS (Local0, Arg0) | |
| } | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.PEG.VID) | |
| { | |
| Method (NBCI, 4, Serialized) | |
| { | |
| Debug = "------- NBCI DSM --------" | |
| Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| Divide (0x00, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Divide (0x14, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Return (Local0) | |
| } | |
| Case (0x14) | |
| { | |
| Local0 = Package (0x07) | |
| { | |
| 0x0110, | |
| 0x0200, | |
| 0x00, | |
| 0x00, | |
| 0x05, | |
| 0x01, | |
| Package (0x04) | |
| { | |
| 0xDC, | |
| 0x00, | |
| 0x03E8, | |
| Package (0x03) | |
| { | |
| 0x65, | |
| Package (0x65) | |
| { | |
| 0x00, | |
| 0x0A, | |
| 0x14, | |
| 0x1E, | |
| 0x28, | |
| 0x32, | |
| 0x3C, | |
| 0x46, | |
| 0x50, | |
| 0x5A, | |
| 0x64, | |
| 0x6E, | |
| 0x78, | |
| 0x82, | |
| 0x8C, | |
| 0x96, | |
| 0xA0, | |
| 0xAA, | |
| 0xB4, | |
| 0xBE, | |
| 0xC8, | |
| 0xD2, | |
| 0xDC, | |
| 0xE6, | |
| 0xF0, | |
| 0xFA, | |
| 0x0104, | |
| 0x010E, | |
| 0x0118, | |
| 0x0122, | |
| 0x012C, | |
| 0x0136, | |
| 0x0140, | |
| 0x014A, | |
| 0x0154, | |
| 0x015E, | |
| 0x0168, | |
| 0x0172, | |
| 0x017C, | |
| 0x0186, | |
| 0x0190, | |
| 0x019A, | |
| 0x01A4, | |
| 0x01AE, | |
| 0x01B8, | |
| 0x01C2, | |
| 0x01CC, | |
| 0x01D6, | |
| 0x01E0, | |
| 0x01EA, | |
| 0x01F4, | |
| 0x01FE, | |
| 0x0208, | |
| 0x0212, | |
| 0x021C, | |
| 0x0226, | |
| 0x0230, | |
| 0x023A, | |
| 0x0244, | |
| 0x024E, | |
| 0x0258, | |
| 0x0262, | |
| 0x026C, | |
| 0x0276, | |
| 0x0280, | |
| 0x028A, | |
| 0x0294, | |
| 0x029E, | |
| 0x02A8, | |
| 0x02B2, | |
| 0x02BC, | |
| 0x02C6, | |
| 0x02D0, | |
| 0x02DA, | |
| 0x02E4, | |
| 0x02EE, | |
| 0x02F8, | |
| 0x0302, | |
| 0x030C, | |
| 0x0316, | |
| 0x0320, | |
| 0x032A, | |
| 0x0334, | |
| 0x033E, | |
| 0x0348, | |
| 0x0352, | |
| 0x035C, | |
| 0x0366, | |
| 0x0370, | |
| 0x037A, | |
| 0x0384, | |
| 0x038E, | |
| 0x0398, | |
| 0x03A2, | |
| 0x03AC, | |
| 0x03B6, | |
| 0x03C0, | |
| 0x03CA, | |
| 0x03D4, | |
| 0x03DE, | |
| 0x03E8 | |
| }, | |
| Package (0x65) | |
| { | |
| 0x00, | |
| 0x0A, | |
| 0x14, | |
| 0x1E, | |
| 0x28, | |
| 0x32, | |
| 0x3C, | |
| 0x46, | |
| 0x50, | |
| 0x5A, | |
| 0x64, | |
| 0x6E, | |
| 0x78, | |
| 0x82, | |
| 0x8C, | |
| 0x96, | |
| 0xA0, | |
| 0xAA, | |
| 0xB4, | |
| 0xBE, | |
| 0xC8, | |
| 0xD2, | |
| 0xDC, | |
| 0xE6, | |
| 0xF0, | |
| 0xFA, | |
| 0x0104, | |
| 0x010E, | |
| 0x0118, | |
| 0x0122, | |
| 0x012C, | |
| 0x0136, | |
| 0x0140, | |
| 0x014A, | |
| 0x0154, | |
| 0x015E, | |
| 0x0168, | |
| 0x0172, | |
| 0x017C, | |
| 0x0186, | |
| 0x0190, | |
| 0x019A, | |
| 0x01A4, | |
| 0x01AE, | |
| 0x01B8, | |
| 0x01C2, | |
| 0x01CC, | |
| 0x01D6, | |
| 0x01E0, | |
| 0x01EA, | |
| 0x01F4, | |
| 0x01FE, | |
| 0x0208, | |
| 0x0212, | |
| 0x021C, | |
| 0x0226, | |
| 0x0230, | |
| 0x023A, | |
| 0x0244, | |
| 0x024E, | |
| 0x0258, | |
| 0x0262, | |
| 0x026C, | |
| 0x0276, | |
| 0x0280, | |
| 0x028A, | |
| 0x0294, | |
| 0x029E, | |
| 0x02A8, | |
| 0x02B2, | |
| 0x02BC, | |
| 0x02C6, | |
| 0x02D0, | |
| 0x02DA, | |
| 0x02E4, | |
| 0x02EE, | |
| 0x02F8, | |
| 0x0302, | |
| 0x030C, | |
| 0x0316, | |
| 0x0320, | |
| 0x032A, | |
| 0x0334, | |
| 0x033E, | |
| 0x0348, | |
| 0x0352, | |
| 0x035C, | |
| 0x0366, | |
| 0x0370, | |
| 0x037A, | |
| 0x0384, | |
| 0x038E, | |
| 0x0398, | |
| 0x03A2, | |
| 0x03AC, | |
| 0x03B6, | |
| 0x03C0, | |
| 0x03CA, | |
| 0x03D4, | |
| 0x03DE, | |
| 0x03E8 | |
| } | |
| } | |
| } | |
| } | |
| Local1 = 0x00 | |
| While ((Local1 <= 0x64)) | |
| { | |
| Local2 = DerefOf (DerefOf (\_SB.PCI0.LPC.EC.BRTD [\BRTN]) [Local1]) | |
| Local2 *= 0x03E8 | |
| Divide (Local2, 0xFF, Local2, Local3) | |
| DerefOf (DerefOf (DerefOf (Local0 [0x06]) [0x03] | |
| ) [0x01]) [Local1] = Local3 | |
| Local1++ | |
| } | |
| Return (Local0) | |
| } | |
| } | |
| Return (0x80000002) | |
| } | |
| Method (NVSB, 1, NotSerialized) | |
| { | |
| Name (CNT, 0x00) | |
| If ((PBCC == 0x01)) | |
| { | |
| If ((PBMR == 0x00)) | |
| { | |
| PBMR = 0x02 | |
| If ((PBMR == 0x02)) | |
| { | |
| While (((PBCC && 0xFF) && (CNT < 0x0A))) | |
| { | |
| CNT++ | |
| Sleep (0x01) | |
| } | |
| If (((PBCR & 0x02) == 0x00)) | |
| { | |
| Local0 = (Arg0 * 0x03E8) | |
| Divide (Local0, 0xFF, Local1, Local2) | |
| Local2 <<= 0x08 | |
| PBDI = Local2 | |
| PBCR = 0x86100000 | |
| } | |
| PBMR = 0x00 | |
| Return (0x01) | |
| } | |
| } | |
| } | |
| Return (0x00) | |
| } | |
| } | |
| OperationRegion (PEGC, PCI_Config, 0x00, 0x0100) | |
| Field (PEGC, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0xEC), | |
| GMGP, 1, | |
| HPGP, 1, | |
| PMGP, 1 | |
| } | |
| } | |
| Device (B0D3) | |
| { | |
| Name (_ADR, 0x00030000) // _ADR: Address | |
| } | |
| Device (IGBE) | |
| { | |
| Name (_ADR, 0x00190000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
| { | |
| 0x0D, | |
| 0x04 | |
| }) | |
| } | |
| Name (LTRE, 0x00) | |
| Name (OBFF, 0x00) | |
| Device (EXP1) | |
| { | |
| Name (_ADR, 0x001C0000) // _ADR: Address | |
| Name (RID, 0x00) | |
| OperationRegion (PECS, PCI_Config, 0x00, 0x0100) | |
| Field (PECS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x62), | |
| PS, 1, | |
| PP, 1, | |
| Offset (0xDB), | |
| , 7, | |
| PMCE, 1, | |
| Offset (0xDF), | |
| , 7, | |
| PMCS, 1 | |
| } | |
| Name (LPRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| \_SB.LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| \_SB.LNKD, | |
| 0x00 | |
| } | |
| }) | |
| Name (APRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x13 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (APRT) /* \_SB_.PCI0.EXP1.APRT */ | |
| } | |
| Else | |
| { | |
| Return (LPRT) /* \_SB_.PCI0.EXP1.LPRT */ | |
| } | |
| } | |
| Name (OPTS, 0x00) | |
| Name (LTRV, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */){ Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| OPTS = 0x01 | |
| If (LTRE) | |
| { | |
| OPTS |= 0x40 | |
| } | |
| If (OBFF) | |
| { | |
| OPTS |= 0x10 | |
| } | |
| Return (OPTS) /* \_SB_.PCI0.EXP1.OPTS */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Case (0x04) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (OBFF) | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| Else | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| } | |
| } | |
| Case (0x06) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (LTRE) | |
| { | |
| Name (MLTR, 0x00) | |
| MLTR = 0x0846 | |
| LTRV [0x00] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x01] = (MLTR & 0x03FF) | |
| LTRV [0x02] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x03] = (MLTR & 0x03FF) | |
| Return (LTRV) /* \_SB_.PCI0.EXP1.LTRV */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Return (Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| } | |
| Device (EXP2) | |
| { | |
| Name (_ADR, 0x001C0001) // _ADR: Address | |
| Name (RID, 0x00) | |
| OperationRegion (PECS, PCI_Config, 0x00, 0x0100) | |
| Field (PECS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x62), | |
| PS, 1, | |
| PP, 1, | |
| Offset (0xDB), | |
| , 7, | |
| PMCE, 1, | |
| Offset (0xDF), | |
| , 7, | |
| PMCS, 1 | |
| } | |
| Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
| { | |
| 0x09, | |
| 0x04 | |
| }) | |
| Name (LPRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| \_SB.LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| \_SB.LNKA, | |
| 0x00 | |
| } | |
| }) | |
| Name (APRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x10 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (APRT) /* \_SB_.PCI0.EXP2.APRT */ | |
| } | |
| Else | |
| { | |
| Return (LPRT) /* \_SB_.PCI0.EXP2.LPRT */ | |
| } | |
| } | |
| Name (OPTS, 0x00) | |
| Name (LTRV, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */){ Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| OPTS = 0x01 | |
| If (LTRE) | |
| { | |
| OPTS |= 0x40 | |
| } | |
| If (OBFF) | |
| { | |
| OPTS |= 0x10 | |
| } | |
| Return (OPTS) /* \_SB_.PCI0.EXP2.OPTS */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Case (0x04) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (OBFF) | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| Else | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| } | |
| } | |
| Case (0x06) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (LTRE) | |
| { | |
| Name (MLTR, 0x00) | |
| MLTR = 0x0846 | |
| LTRV [0x00] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x01] = (MLTR & 0x03FF) | |
| LTRV [0x02] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x03] = (MLTR & 0x03FF) | |
| Return (LTRV) /* \_SB_.PCI0.EXP2.LTRV */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Return (Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| } | |
| Device (EXP3) | |
| { | |
| Name (_ADR, 0x001C0002) // _ADR: Address | |
| Name (RID, 0x00) | |
| OperationRegion (PECS, PCI_Config, 0x00, 0x0100) | |
| Field (PECS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x62), | |
| PS, 1, | |
| PP, 1, | |
| Offset (0xDB), | |
| , 7, | |
| PMCE, 1, | |
| Offset (0xDF), | |
| , 7, | |
| PMCS, 1 | |
| } | |
| Name (_PRW, Package (0x02) // _PRW: Power Resources for Wake | |
| { | |
| 0x09, | |
| 0x04 | |
| }) | |
| Name (LPRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| \_SB.LNKA, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| \_SB.LNKB, | |
| 0x00 | |
| } | |
| }) | |
| Name (APRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x11 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (APRT) /* \_SB_.PCI0.EXP3.APRT */ | |
| } | |
| Else | |
| { | |
| Return (LPRT) /* \_SB_.PCI0.EXP3.LPRT */ | |
| } | |
| } | |
| Name (OPTS, 0x00) | |
| Name (LTRV, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */){ Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| OPTS = 0x01 | |
| If (LTRE) | |
| { | |
| OPTS |= 0x40 | |
| } | |
| If (OBFF) | |
| { | |
| OPTS |= 0x10 | |
| } | |
| Return (OPTS) /* \_SB_.PCI0.EXP3.OPTS */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Case (0x04) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (OBFF) | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| Else | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| } | |
| } | |
| Case (0x06) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (LTRE) | |
| { | |
| Name (MLTR, 0x00) | |
| MLTR = 0x0846 | |
| LTRV [0x00] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x01] = (MLTR & 0x03FF) | |
| LTRV [0x02] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x03] = (MLTR & 0x03FF) | |
| Return (LTRV) /* \_SB_.PCI0.EXP3.LTRV */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Return (Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| } | |
| Device (EXP6) | |
| { | |
| Name (_ADR, 0x001C0005) // _ADR: Address | |
| Name (RID, 0x00) | |
| OperationRegion (PECS, PCI_Config, 0x00, 0x0100) | |
| Field (PECS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x5A), | |
| , 3, | |
| PDC, 1, | |
| , 2, | |
| PDS, 1, | |
| Offset (0x5B), | |
| Offset (0x62), | |
| PS, 1, | |
| PP, 1, | |
| Offset (0xDB), | |
| , 6, | |
| HPCE, 1, | |
| PMCE, 1, | |
| Offset (0xDF), | |
| , 6, | |
| HPCS, 1, | |
| PMCS, 1 | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| PDSF = PDS /* \_SB_.PCI0.EXP6.PDS_ */ | |
| LTRE = LTR6 /* \LTR6 */ | |
| OBFF = OBF6 /* \OBF6 */ | |
| } | |
| Name (LPRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| \_SB.LNKB, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| \_SB.LNKC, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| \_SB.LNKD, | |
| 0x00 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| \_SB.LNKA, | |
| 0x00 | |
| } | |
| }) | |
| Name (APRT, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x00, | |
| 0x00, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x01, | |
| 0x00, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| 0x00, | |
| 0x13 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| 0x00, | |
| 0x10 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (\GPIC) | |
| { | |
| Return (APRT) /* \_SB_.PCI0.EXP6.APRT */ | |
| } | |
| Else | |
| { | |
| Return (LPRT) /* \_SB_.PCI0.EXP6.LPRT */ | |
| } | |
| } | |
| Name (OPTS, 0x00) | |
| Name (LTRV, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (ToUUID ("e5c937d0-3553-4d7a-9117-ea4d19c3434d") /* Device Labeling Interface */){ Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| OPTS = 0x01 | |
| If (LTRE) | |
| { | |
| OPTS |= 0x40 | |
| } | |
| If (OBFF) | |
| { | |
| OPTS |= 0x10 | |
| } | |
| Return (OPTS) /* \_SB_.PCI0.EXP6.OPTS */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Case (0x04) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (OBFF) | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| Else | |
| { | |
| Return (Buffer (0x10) | |
| { | |
| /* 0000 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| } | |
| } | |
| } | |
| Case (0x06) | |
| { | |
| If ((Arg1 == 0x02)) | |
| { | |
| If (LTRE) | |
| { | |
| Name (MLTR, 0x00) | |
| MLTR = 0x0846 | |
| LTRV [0x00] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x01] = (MLTR & 0x03FF) | |
| LTRV [0x02] = ((MLTR >> 0x0A) & 0x07) | |
| LTRV [0x03] = (MLTR & 0x03FF) | |
| Return (LTRV) /* \_SB_.PCI0.EXP6.LTRV */ | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Return (Buffer (0x01) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| Name (PDSF, 0x00) | |
| Device (SLOT) | |
| { | |
| Name (_ADR, 0x00) // _ADR: Address | |
| Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
| { | |
| Return (0x01) | |
| } | |
| } | |
| } | |
| Device (SAT1) | |
| { | |
| Name (_ADR, 0x001F0002) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| } | |
| Device (SAT2) | |
| { | |
| Name (_ADR, 0x001F0005) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| } | |
| Device (SMBU) | |
| { | |
| Name (_ADR, 0x001F0003) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| Device (NFC) | |
| { | |
| Name (_HID, EisaId ("BCM2F09")) // _HID: Hardware ID | |
| Name (_CID, EisaId ("BCM2F09")) // _CID: Compatible ID | |
| Name (_UID, 0x00) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((\_SB.PCI0.LPC.NFCD || \NFCF)) | |
| { | |
| Return (0x00) | |
| } | |
| Else | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Method (GPEN, 0, NotSerialized) | |
| { | |
| \_GPE.GPFG = 0x01 | |
| } | |
| Method (SNFC, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| \_SB.PCI0.LPC.NFCP = 0x01 | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.NFCP = 0x00 | |
| } | |
| } | |
| } | |
| } | |
| Device (XHCI) | |
| { | |
| Name (_ADR, 0x00140000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| OperationRegion (XHCS, PCI_Config, 0x00, 0x0100) | |
| Field (XHCS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x10), | |
| MEMB, 32, | |
| Offset (0x40), | |
| , 11, | |
| SWAI, 1, | |
| Offset (0x44), | |
| , 12, | |
| SAIP, 2, | |
| Offset (0x48), | |
| Offset (0x74), | |
| Offset (0x75), | |
| PMEE, 1, | |
| , 6, | |
| PMES, 1, | |
| Offset (0xD0), | |
| PR2, 32, | |
| PR2M, 32, | |
| PR3, 32, | |
| PR3M, 32 | |
| } | |
| Name (XRST, Zero) | |
| OperationRegion (XHCM, SystemMemory, (MEMB & 0xFFFF0000), 0x0600) | |
| Field (XHCM, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x02), | |
| XHCV, 16, | |
| Offset (0x480), | |
| HP01, 1, | |
| Offset (0x490), | |
| HP02, 1, | |
| Offset (0x4A0), | |
| HP03, 1, | |
| Offset (0x530), | |
| HP07, 1, | |
| Offset (0x570), | |
| SP00, 1, | |
| Offset (0x580), | |
| SP01, 1, | |
| Offset (0x590), | |
| SP02, 1 | |
| } | |
| Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR1, Package (0x01) // _PR1: Power Resources for D1 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR2, Package (0x01) // _PR2: Power Resources for D2 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake | |
| { | |
| 0x0D, | |
| 0x03, | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Method (CUID, 1, Serialized) | |
| { | |
| If ((Arg0 == ToUUID ("7c9512a9-1705-4cb4-af7d-506a2423ab71"))) | |
| { | |
| Return (0x01) | |
| } | |
| Return (0x00) | |
| } | |
| Method (POSC, 3, Serialized) | |
| { | |
| CreateDWordField (Arg2, 0x00, CDW1) | |
| CreateDWordField (Arg2, 0x08, CDW3) | |
| If ((\XHCI == 0x00)) | |
| { | |
| CDW1 |= 0x02 | |
| \_SB.PCI0.LPC.XUSB = 0x00 | |
| XRST = 0x00 | |
| } | |
| If (!(CDW1 & 0x01)) | |
| { | |
| If ((CDW3 & 0x01)) | |
| { | |
| ESEL () | |
| } | |
| ElseIf (0x01) | |
| { | |
| If ((Arg0 > 0x01)) | |
| { | |
| SXHC () | |
| } | |
| Else | |
| { | |
| CDW1 |= 0x0A | |
| } | |
| } | |
| ElseIf ((Arg0 > 0x02)) | |
| { | |
| SXHC () | |
| } | |
| Else | |
| { | |
| CDW1 |= 0x0A | |
| } | |
| Return (Arg2) | |
| } | |
| If ((!(CDW1 & 0x01) && ((\XHCI == 0x02) || ( | |
| \XHCI == 0x03)))) | |
| { | |
| SXHC () | |
| } | |
| Return (Arg2) | |
| } | |
| Method (ESEL, 0, Serialized) | |
| { | |
| If (((\XHCI == 0x02) || (\XHCI == 0x03))) | |
| { | |
| PR3 &= 0xFFFFFFC0 | |
| PR2 &= 0xFFFF8000 | |
| \_SB.PCI0.LPC.XUSB = 0x00 | |
| XRST = 0x00 | |
| } | |
| } | |
| Method (SXHC, 0, NotSerialized) | |
| { | |
| \_SB.PCI0.LPC.XUSB = 0x01 | |
| XRST = 0x01 | |
| Local0 = 0x00 | |
| Local0 = (PR3 & 0xFFFFFFC0) | |
| PR3 = (Local0 | PR3M) /* \_SB_.PCI0.XHCI.PR3M */ | |
| Local0 = 0x00 | |
| Local0 = (PR2 & 0xFFFF8000) | |
| PR2 = (Local0 | PR2M) /* \_SB_.PCI0.XHCI.PR2M */ | |
| \_SB.PCI0.LPC.XUSB = 0x01 | |
| \USBR = 0x01 | |
| } | |
| Method (XHPS, 0, NotSerialized) | |
| { | |
| If ((\_SB.PCI0.XHCI.XHCV != 0xFFFF)) | |
| { | |
| \USBC = 0x01 | |
| \USBC |= (\_SB.PCI0.XHCI.HP01 << 0x01) | |
| \USBC |= (\_SB.PCI0.XHCI.HP02 << 0x02) | |
| \USBC |= (\_SB.PCI0.XHCI.HP03 << 0x03) | |
| \USBC |= (\_SB.PCI0.XHCI.HP07 << 0x04) | |
| \USBC |= (\_SB.PCI0.XHCI.SP00 << 0x05) | |
| \USBC |= (\_SB.PCI0.XHCI.SP01 << 0x06) | |
| \USBC |= (\_SB.PCI0.XHCI.SP02 << 0x07) | |
| } | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| If (\WIN8) | |
| { | |
| SXHC () | |
| } | |
| } | |
| Name (PEBS, 0xF8000000) | |
| OperationRegion (XHCB, SystemMemory, (PEBS + 0x000A0000), 0x0100) | |
| Field (XHCB, DWordAcc, Lock, Preserve) | |
| { | |
| DVID, 16, | |
| Offset (0x04), | |
| PDBM, 16, | |
| Offset (0x10), | |
| MBA1, 32, | |
| Offset (0x74), | |
| D0D3, 2, | |
| Offset (0x78), | |
| Offset (0xB0), | |
| , 13, | |
| MB13, 2, | |
| Offset (0xB4) | |
| } | |
| Name (SRMB, 0x7FA10000) | |
| Method (_PS0, 0, Serialized) // _PS0: Power State 0 | |
| { | |
| If ((\_SB.PCI0.XHCI.DVID == 0xFFFF)) | |
| { | |
| Return (Zero) | |
| } | |
| Local2 = \_SB.PCI0.XHCI.MBA1 | |
| Local1 = \_SB.PCI0.XHCI.PDBM | |
| \_SB.PCI0.XHCI.MBA1 = SRMB /* \_SB_.PCI0.XHCI.SRMB */ | |
| Local0 = \_SB.PCI0.XHCI.PDBM | |
| Local0 |= 0x06 | |
| \_SB.PCI0.XHCI.PDBM = Local0 | |
| OperationRegion (MCA1, SystemMemory, SRMB, 0x9000) | |
| Field (MCA1, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x510), | |
| P141, 14, | |
| , 17, | |
| WPR1, 1, | |
| Offset (0x520), | |
| P142, 14, | |
| , 17, | |
| WPR2, 1, | |
| Offset (0x530), | |
| P143, 14, | |
| , 17, | |
| WPR3, 1, | |
| Offset (0x540), | |
| P144, 14, | |
| , 17, | |
| WPR4, 1, | |
| Offset (0x80E0), | |
| , 15, | |
| AX15, 1, | |
| Offset (0x8154), | |
| , 31, | |
| CLK2, 1, | |
| Offset (0x816C), | |
| , 2, | |
| CLK0, 1, | |
| , 11, | |
| CLK1, 1, | |
| Offset (0x8170) | |
| } | |
| Local3 = \_SB.PCI0.XHCI.D0D3 | |
| If ((Local3 == 0x03)) | |
| { | |
| \_SB.PCI0.XHCI.D0D3 = 0x00 | |
| } | |
| CLK2 = 0x01 | |
| If ((Local3 == 0x03)) | |
| { | |
| \_SB.PCI0.XHCI.D0D3 = 0x03 | |
| } | |
| \_SB.PCI0.XHCI.PDBM = Local1 | |
| \_SB.PCI0.XHCI.MBA1 = Local2 | |
| } | |
| Method (_PS3, 0, Serialized) // _PS3: Power State 3 | |
| { | |
| If ((\_SB.PCI0.XHCI.DVID == 0xFFFF)) | |
| { | |
| Return (Zero) | |
| } | |
| \_SB.PCI0.XHCI.PMES = 0x01 | |
| \_SB.PCI0.XHCI.PMEE = 0x01 | |
| Local2 = \_SB.PCI0.XHCI.MBA1 | |
| Local1 = \_SB.PCI0.XHCI.PDBM | |
| \_SB.PCI0.XHCI.MBA1 = SRMB /* \_SB_.PCI0.XHCI.SRMB */ | |
| Local0 = \_SB.PCI0.XHCI.PDBM | |
| Local0 |= 0x06 | |
| \_SB.PCI0.XHCI.PDBM = Local0 | |
| OperationRegion (MCA1, SystemMemory, SRMB, 0x9000) | |
| Field (MCA1, DWordAcc, Lock, Preserve) | |
| { | |
| Offset (0x80E0), | |
| , 15, | |
| AX15, 1, | |
| Offset (0x8154), | |
| , 31, | |
| CLK2, 1, | |
| Offset (0x816C), | |
| , 2, | |
| CLK0, 1, | |
| , 11, | |
| CLK1, 1, | |
| Offset (0x8170) | |
| } | |
| Local3 = \_SB.PCI0.XHCI.D0D3 | |
| If ((Local3 == 0x03)) | |
| { | |
| \_SB.PCI0.XHCI.D0D3 = 0x00 | |
| } | |
| CLK2 = 0x00 | |
| If ((Local3 == 0x03)) | |
| { | |
| \_SB.PCI0.XHCI.D0D3 = 0x03 | |
| } | |
| \_SB.PCI0.XHCI.PDBM = Local1 | |
| \_SB.PCI0.XHCI.MBA1 = Local2 | |
| } | |
| Device (URTH) | |
| { | |
| Name (_ADR, 0x00) // _ADR: Address | |
| Device (HSP0) | |
| { | |
| Name (_ADR, 0x01) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC0, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP0._UPC.UPCP */ | |
| If (!(PR2 & 0x01)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP0._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD0 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x01)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP0._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP1) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC1, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP1._UPC.UPCP */ | |
| If (!(PR2 & 0x02)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP1._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD1 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x02)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP1._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP2) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC2, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP2._UPC.UPCP */ | |
| If (!(PR2 & 0x04)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP2._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD2 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x04)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP2._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP3) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP3._UPC.UPCP */ | |
| If (!(PR2 & 0x08)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP3._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x08)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP3._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP4) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP4._UPC.UPCP */ | |
| If (!(PR2 & 0x10)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP4._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x10)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP4._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP5) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC9, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP5._UPC.UPCP */ | |
| If (!(PR2 & 0x20)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP5._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD9 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x20)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP5._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP6) | |
| { | |
| Name (_ADR, 0x07) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP6._UPC.UPCP */ | |
| If (!(PR2 & 0x40)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP6._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x40)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP6._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP7) | |
| { | |
| Name (_ADR, 0x08) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP7._UPC.UPCP */ | |
| If (!(PR2 & 0x80)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP7._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x80)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP7._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP8) | |
| { | |
| Name (_ADR, 0x09) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC4, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP8._UPC.UPCP */ | |
| If (!(PR2 & 0x0100)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP8._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD4 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x0100)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP8._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSP9) | |
| { | |
| Name (_ADR, 0x0A) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC5, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP9._UPC.UPCP */ | |
| If (!(PR2 & 0x0200)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSP9._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD5 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x0200)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSP9._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSPA) | |
| { | |
| Name (_ADR, 0x0B) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPA._UPC.UPCP */ | |
| If (!(PR2 & 0x0400)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPA._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x0400)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSPA._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSPB) | |
| { | |
| Name (_ADR, 0x0C) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPB._UPC.UPCP */ | |
| If (!(PR2 & 0x0800)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPB._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x0800)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSPB._PLD.PLDP */ | |
| } | |
| Device (WCAM) | |
| { | |
| Name (_ADR, 0x0C) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (\WIN8) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (\UPCI) | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (\PLDC) | |
| } | |
| } | |
| } | |
| Device (HSPC) | |
| { | |
| Name (_ADR, 0x0D) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPC._UPC.UPCP */ | |
| If (!(PR2 & 0x1000)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPC._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x1000)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSPC._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSPD) | |
| { | |
| Name (_ADR, 0x0E) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPD._UPC.UPCP */ | |
| If (!(PR2 & 0x2000)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPD._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x2000)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSPD._PLD.PLDP */ | |
| } | |
| } | |
| Device (HSPE) | |
| { | |
| Name (_ADR, 0x0F) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPE._UPC.UPCP */ | |
| If (!(PR2 & 0x4000)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.HSPE._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If (!(PR2 & 0x2000)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.HSPE._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP0) | |
| { | |
| Name (_ADR, 0x10) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC0, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP0._UPC.UPCP */ | |
| If ((!(PR2 & 0x01) || !(PR3 & 0x01))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP0._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD0 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x01) || !(PR3 & 0x01))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP0._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP1) | |
| { | |
| Name (_ADR, 0x11) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC1, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP1._UPC.UPCP */ | |
| If ((!(PR2 & 0x02) || !(PR3 & 0x02))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP1._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD1 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x02) || !(PR3 & 0x02))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP1._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP2) | |
| { | |
| Name (_ADR, 0x12) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP2._UPC.UPCP */ | |
| If ((!(PR2 & 0x04) || !(PR3 & 0x04))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP2._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x04) || !(PR3 & 0x04))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP2._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP3) | |
| { | |
| Name (_ADR, 0x13) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP3._UPC.UPCP */ | |
| If ((!(PR2 & 0x08) || !(PR3 & 0x08))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP3._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x08) || !(PR3 & 0x08))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP3._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP4) | |
| { | |
| Name (_ADR, 0x14) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC4, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP4._UPC.UPCP */ | |
| If ((!(PR2 & 0x10) || !(PR3 & 0x10))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP4._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD4 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x10) || !(PR3 & 0x10))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP4._PLD.PLDP */ | |
| } | |
| } | |
| Device (SSP5) | |
| { | |
| Name (_ADR, 0x15) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP5._UPC.UPCP */ | |
| If ((!(PR2 & 0x20) || !(PR3 & 0x20))) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.XHCI.URTH.SSP5._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| \_SB.PCI0.XHCI.XHPS () | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((!(PR2 & 0x20) || !(PR3 & 0x20))) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.XHCI.URTH.SSP5._PLD.PLDP */ | |
| } | |
| } | |
| } | |
| } | |
| Device (EHC1) | |
| { | |
| Name (_ADR, 0x001D0000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| OperationRegion (EHCS, PCI_Config, 0x00, 0x0100) | |
| Field (EHCS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x62), | |
| PWKI, 1, | |
| PWUC, 8, | |
| Offset (0x64) | |
| } | |
| Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR1, Package (0x01) // _PR1: Power Resources for D1 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR2, Package (0x01) // _PR2: Power Resources for D2 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| PWKI = 0x01 | |
| PWUC = 0x23 | |
| } | |
| Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake | |
| { | |
| 0x0D, | |
| 0x03, | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Device (URTH) | |
| { | |
| Name (_ADR, 0x00) // _ADR: Address | |
| Device (URMH) | |
| { | |
| Name (_ADR, 0x01) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (\UPCI) | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (\PLDI) | |
| } | |
| Device (PRT0) | |
| { | |
| Name (_ADR, 0x01) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC0, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT0._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x01)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT0._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD0 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| Else | |
| { | |
| If ((\_SB.PCI0.XHCI.PR2 & 0x01)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT0._PLD.PLDP */ | |
| } | |
| } | |
| } | |
| Device (PRT1) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC1, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT1._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x02)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT1._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD1 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x02)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT1._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC2, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT2._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x04)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT2._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD2 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x04)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT2._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT3) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT3._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x08)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT3._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x08)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT3._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT4) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC4, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT4._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x10)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT4._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD4 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x10)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT4._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT5) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC5, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT5._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x20)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT5._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD5 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x20)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT5._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT6) | |
| { | |
| Name (_ADR, 0x07) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT6._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x40)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT6._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x40)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT6._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT7) | |
| { | |
| Name (_ADR, 0x08) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCN, UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT7._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x80)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT7._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDN | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x80)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC1.URTH.URMH.PRT7._PLD.PLDP */ | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Device (EHC2) | |
| { | |
| Name (_ADR, 0x001A0000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| OperationRegion (EHCS, PCI_Config, 0x00, 0x0100) | |
| Field (EHCS, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0x62), | |
| PWKI, 1, | |
| PWUC, 6, | |
| Offset (0x64) | |
| } | |
| Name (_PR0, Package (0x01) // _PR0: Power Resources for D0 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR1, Package (0x01) // _PR1: Power Resources for D1 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Name (_PR2, Package (0x01) // _PR2: Power Resources for D2 | |
| { | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| PWKI = 0x01 | |
| PWUC = 0x13 | |
| } | |
| Name (_PRW, Package (0x03) // _PRW: Power Resources for Wake | |
| { | |
| 0x0D, | |
| 0x03, | |
| \_SB.PCI0.LPC.EC.PUBS | |
| }) | |
| Device (URTH) | |
| { | |
| Name (_ADR, 0x00) // _ADR: Address | |
| Device (URMH) | |
| { | |
| Name (_ADR, 0x01) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (\UPCI) | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (\PLDI) | |
| } | |
| Device (PRT8) | |
| { | |
| Name (_ADR, 0x01) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT8._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0100)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT8._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0100)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT8._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRT9) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPC9, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT9._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0200)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT9._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLD9 | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0200)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRT9._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRTA) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTA._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0400)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTA._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0400)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTA._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRTB) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTB._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0800)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTB._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x0800)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTB._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRTC) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTC._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x1000)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTC._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Name (PLDP, Buffer (0x10){}) | |
| PLDP = \PLDI | |
| CreateBitField (PLDP, 0x40, VIS) | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x1000)) | |
| { | |
| VIS &= 0x00 | |
| } | |
| Return (PLDP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTC._PLD.PLDP */ | |
| } | |
| } | |
| Device (PRTD) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Name (UPCP, Package (0x04) | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| CopyObject (\UPCI, UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTD._UPC.UPCP */ | |
| If ((\XHCI == 0x00)){} | |
| ElseIf ((\_SB.PCI0.XHCI.PR2 & 0x2000)) | |
| { | |
| UPCP [0x00] = 0x00 | |
| } | |
| Return (UPCP) /* \_SB_.PCI0.EHC2.URTH.URMH.PRTD._UPC.UPCP */ | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (\PLDI) | |
| } | |
| Device (WCAM) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (\WIN8) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (\UPCI) | |
| } | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (\PLDC) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Device (HDEF) | |
| { | |
| Name (_ADR, 0x001B0000) // _ADR: Address | |
| Name (_S3D, 0x03) // _S3D: S3 Device State | |
| Name (RID, 0x00) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Name (BDEV, 0xFF) | |
| Name (BSTS, 0x00) | |
| Name (BHKE, 0x00) | |
| Method (_Q2C, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If ((BSTS == 0x00)) | |
| { | |
| BDEV = BGID (0x00) | |
| NBRE (BDEV) | |
| } | |
| } | |
| Method (_Q2D, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| BDEV = BGID (0x00) | |
| NBIN (BDEV) | |
| } | |
| Method (_Q38, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Local0 = BGID (0x00) | |
| If ((Local0 == 0x0F)) | |
| { | |
| BDIS () | |
| \BHDP (0x01, 0x00) | |
| NBEJ (BDEV) | |
| BDEV = Local0 | |
| If ((\BIDE == 0x03)) | |
| { | |
| \_SB.PCI0.SAT1.PRIM.GTME = 0x00 | |
| \_SB.PCI0.SAT1.SCND.GTME = 0x00 | |
| } | |
| } | |
| ElseIf (HPBU){} | |
| Else | |
| { | |
| BDEV = Local0 | |
| NBIN (Local0) | |
| } | |
| } | |
| Name (ODEJ, 0x00) | |
| Method (_Q44, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.CSON) | |
| { | |
| ODEJ = 0x01 | |
| BDEV = BGID (0x00) | |
| NBIN (BDEV) | |
| ODEJ = 0x00 | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x3006) | |
| } | |
| } | |
| Method (NBRE, 1, NotSerialized) | |
| { | |
| If ((Arg0 < 0x0C)) | |
| { | |
| If ((\BIDE == 0x03)) | |
| { | |
| Notify (\_SB.PCI0.SAT1.SCND.MSTR, 0x03) // Eject Request | |
| } | |
| Else | |
| { | |
| Notify (\_SB.PCI0.SAT1.PRT5, 0x03) // Eject Request | |
| } | |
| } | |
| } | |
| Method (NBEJ, 1, NotSerialized) | |
| { | |
| If ((BSTS == 0x00)) | |
| { | |
| If ((Arg0 < 0x0C)) | |
| { | |
| If ((\BIDE == 0x03)) | |
| { | |
| Notify (\_SB.PCI0.SAT1.SCND.MSTR, 0x01) // Device Check | |
| } | |
| Else | |
| { | |
| Notify (\_SB.PCI0.SAT1.PRT5, 0x01) // Device Check | |
| } | |
| } | |
| } | |
| BEEP (0x00) | |
| BSTS = 0x00 | |
| } | |
| Method (NBIN, 1, NotSerialized) | |
| { | |
| If ((Arg0 < 0x0C)) | |
| { | |
| BEN (0x01) | |
| If ((\BIDE == 0x03)) | |
| { | |
| Notify (\_SB.PCI0.SAT1.SCND.MSTR, 0x01) // Device Check | |
| } | |
| Else | |
| { | |
| Notify (\_SB.PCI0.SAT1.PRT5, 0x01) // Device Check | |
| } | |
| } | |
| BEEP (0x00) | |
| BSTS = 0x00 | |
| } | |
| Method (BEJ0, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| BDIS () | |
| \BHDP (0x01, 0x00) | |
| BSTS = 0x01 | |
| If (BHKE) | |
| { | |
| BHKE = 0x00 | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x3003) | |
| } | |
| } | |
| Else | |
| { | |
| BSTS = 0x00 | |
| } | |
| } | |
| Method (BEJ3, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| BDIS () | |
| BSTS = 0x01 | |
| } | |
| Else | |
| { | |
| BSTS = 0x00 | |
| } | |
| } | |
| Method (BPTS, 1, NotSerialized) | |
| { | |
| HDBM = 0x01 | |
| If ((BSTS != 0x00)) | |
| { | |
| BDEV = 0x0F | |
| BSTS = 0x00 | |
| } | |
| BHKE = 0x00 | |
| BUWK (0x00) | |
| } | |
| Method (BWAK, 1, NotSerialized) | |
| { | |
| BUWK (0x00) | |
| Local0 = BGID (0x00) | |
| If ((BSTS == 0x00)) | |
| { | |
| If ((Local0 != BDEV)) | |
| { | |
| NBEJ (BDEV) | |
| BDEV = Local0 | |
| NBIN (Local0) | |
| } | |
| ElseIf ((\LFDC || (BDEV != 0x0D))) | |
| { | |
| If ((Local0 != 0x0F)) | |
| { | |
| If (HPBU) | |
| { | |
| If ((Arg0 <= 0x02)){} | |
| Else | |
| { | |
| NBRE (Local0) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| If ((BDEV < 0x0C)) | |
| { | |
| \UBIS (0x00) | |
| } | |
| Else | |
| { | |
| \UBIS (0x01) | |
| } | |
| } | |
| Method (BDIS, 0, NotSerialized) | |
| { | |
| If (!\_SB.PCI0.LPC.CSON) | |
| { | |
| If ((!\_SB.PCI0.LPC.GLIS && !ODDF)) | |
| { | |
| \UBIS (0x01) | |
| } | |
| \_SB.PCI0.LPC.CSON = 0x01 | |
| \IDET = 0x0F | |
| } | |
| } | |
| Method (BPON, 1, NotSerialized) | |
| { | |
| If (\_SB.PCI0.LPC.CSON) | |
| { | |
| \_SB.PCI0.LPC.CSON = 0x00 | |
| If (\_SB.PCI0.LPC.GLIS) | |
| { | |
| \UBIS (0x00) | |
| } | |
| } | |
| } | |
| Method (BEN, 1, NotSerialized) | |
| { | |
| If (\_SB.PCI0.LPC.CSON) | |
| { | |
| BPON (Arg0) | |
| If (ODDF) | |
| { | |
| Notify (\_SB.PCI0.SAT1, 0x85) // Device-Specific | |
| } | |
| If ((Arg0 && (ODEJ == 0x01))) | |
| { | |
| \_SB.PCI0.LPC.EC.HANT = 0x09 | |
| } | |
| If (Arg0) | |
| { | |
| IRDY () | |
| } | |
| } | |
| } | |
| Method (BSTA, 1, NotSerialized) | |
| { | |
| If (\_SB.PCI0.LPC.CSON) | |
| { | |
| Return (0x00) | |
| } | |
| BINI () | |
| If ((Arg0 == 0x01)) | |
| { | |
| Return ((BDEV < 0x0C)) | |
| } | |
| Return (0x00) | |
| } | |
| Method (BUWK, 1, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| If (Arg0) | |
| { | |
| \_SB.PCI0.LPC.EC.HWBU = 0x01 | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HWBU = 0x00 | |
| } | |
| } | |
| ElseIf (Arg0) | |
| { | |
| \MBEC (0x32, 0xFF, 0x80) | |
| } | |
| Else | |
| { | |
| \MBEC (0x32, 0x7F, 0x00) | |
| } | |
| } | |
| Method (BINI, 0, NotSerialized) | |
| { | |
| If ((BDEV == 0xFF)) | |
| { | |
| BDEV = BGID (0x00) | |
| } | |
| } | |
| Method (BGID, 1, NotSerialized) | |
| { | |
| If (Arg0) | |
| { | |
| Local0 = 0xFF | |
| } | |
| Else | |
| { | |
| If (\H8DR) | |
| { | |
| Local1 = HPBU /* \_SB_.PCI0.LPC_.EC__.HPBU */ | |
| Local2 = HBID /* \_SB_.PCI0.LPC_.EC__.HBID */ | |
| } | |
| Else | |
| { | |
| Local2 = RBEC (0x47) | |
| Local1 = (Local2 & 0x01) | |
| Local2 &= 0x04 | |
| Local2 >>= 0x02 | |
| } | |
| If (Local2) | |
| { | |
| Local0 = 0x0F | |
| } | |
| ElseIf (HDUB) | |
| { | |
| Local0 = 0x0F | |
| } | |
| ElseIf (((\IDET == 0x03) || (\IDET == 0x06))) | |
| { | |
| Local0 = \IDET | |
| } | |
| Else | |
| { | |
| Local0 = 0x07 | |
| } | |
| If ((Local0 == 0x0F)){} | |
| } | |
| If ((\HDUB && (Local0 < 0x0C))) | |
| { | |
| Local0 = 0x0F | |
| } | |
| Return (Local0) | |
| } | |
| Method (IRDY, 0, NotSerialized) | |
| { | |
| Local0 = 0x01F4 | |
| Local1 = 0x3C | |
| Local2 = Zero | |
| While (Local1) | |
| { | |
| Sleep (Local0) | |
| Local3 = \BCHK () | |
| If (!Local3) | |
| { | |
| Break | |
| } | |
| If ((Local3 == 0x02)) | |
| { | |
| Local2 = One | |
| Break | |
| } | |
| Local1-- | |
| } | |
| Return (Local2) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q43, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \UCMS (0x18) | |
| } | |
| Method (SAUM, 1, NotSerialized) | |
| { | |
| If ((Arg0 > 0x03)) | |
| { | |
| Noop | |
| } | |
| ElseIf (\H8DR) | |
| { | |
| HAUM = Arg0 | |
| } | |
| Else | |
| { | |
| \MBEC (0x03, 0x9F, (Arg0 << 0x05)) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (GSMS, 1, NotSerialized) | |
| { | |
| Return (\AUDC (0x00, 0x00)) | |
| } | |
| Method (SSMS, 1, NotSerialized) | |
| { | |
| Return (\AUDC (0x01, (Arg0 & 0x01))) | |
| } | |
| Method (SHDA, 1, NotSerialized) | |
| { | |
| Return (\AUDC (0x02, (Arg0 & 0x01))) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Name (BRTW, Package (0x12) | |
| { | |
| 0x64, | |
| 0x64, | |
| 0x05, | |
| 0x0A, | |
| 0x14, | |
| 0x19, | |
| 0x1E, | |
| 0x23, | |
| 0x28, | |
| 0x2D, | |
| 0x32, | |
| 0x37, | |
| 0x3C, | |
| 0x41, | |
| 0x46, | |
| 0x50, | |
| 0x5A, | |
| 0x64 | |
| }) | |
| Name (BRTB, Package (0x04) | |
| { | |
| Package (0x16) | |
| { | |
| 0x1E, | |
| 0x04, | |
| 0x03, | |
| 0x05, | |
| 0x08, | |
| 0x0A, | |
| 0x0E, | |
| 0x12, | |
| 0x18, | |
| 0x20, | |
| 0x2B, | |
| 0x36, | |
| 0x43, | |
| 0x55, | |
| 0x6D, | |
| 0x8A, | |
| 0xB9, | |
| 0xFF, | |
| 0xDC, | |
| 0xDC, | |
| 0x04, | |
| 0x04 | |
| }, | |
| Package (0x16) | |
| { | |
| 0x19, | |
| 0x04, | |
| 0x04, | |
| 0x06, | |
| 0x09, | |
| 0x0C, | |
| 0x10, | |
| 0x15, | |
| 0x1D, | |
| 0x27, | |
| 0x34, | |
| 0x41, | |
| 0x51, | |
| 0x66, | |
| 0x82, | |
| 0xA4, | |
| 0xCD, | |
| 0xFF, | |
| 0xDC, | |
| 0xDC, | |
| 0x04, | |
| 0x04 | |
| }, | |
| Package (0x16) | |
| { | |
| 0x14, | |
| 0x04, | |
| 0x04, | |
| 0x07, | |
| 0x09, | |
| 0x0C, | |
| 0x10, | |
| 0x15, | |
| 0x1C, | |
| 0x25, | |
| 0x32, | |
| 0x40, | |
| 0x53, | |
| 0x6E, | |
| 0x94, | |
| 0xC6, | |
| 0xE1, | |
| 0xFF, | |
| 0xDC, | |
| 0xDC, | |
| 0x04, | |
| 0x04 | |
| }, | |
| Package (0x16) | |
| { | |
| 0x00, | |
| 0x04, | |
| 0x04, | |
| 0x07, | |
| 0x09, | |
| 0x0C, | |
| 0x10, | |
| 0x15, | |
| 0x1C, | |
| 0x25, | |
| 0x32, | |
| 0x40, | |
| 0x50, | |
| 0x64, | |
| 0x82, | |
| 0xA5, | |
| 0xCD, | |
| 0xFF, | |
| 0xDC, | |
| 0xDC, | |
| 0x04, | |
| 0x04 | |
| } | |
| }) | |
| Name (BRTD, Package (0x04) | |
| { | |
| Package (0x65) | |
| { | |
| 0x03, | |
| 0x04, | |
| 0x05, | |
| 0x06, | |
| 0x07, | |
| 0x08, | |
| 0x09, | |
| 0x0A, | |
| 0x0B, | |
| 0x0C, | |
| 0x0D, | |
| 0x0E, | |
| 0x0F, | |
| 0x10, | |
| 0x11, | |
| 0x12, | |
| 0x13, | |
| 0x14, | |
| 0x15, | |
| 0x16, | |
| 0x17, | |
| 0x18, | |
| 0x19, | |
| 0x1A, | |
| 0x1B, | |
| 0x1C, | |
| 0x1D, | |
| 0x1E, | |
| 0x1F, | |
| 0x20, | |
| 0x21, | |
| 0x22, | |
| 0x23, | |
| 0x24, | |
| 0x25, | |
| 0x26, | |
| 0x27, | |
| 0x28, | |
| 0x29, | |
| 0x2A, | |
| 0x2B, | |
| 0x2C, | |
| 0x2E, | |
| 0x2F, | |
| 0x31, | |
| 0x33, | |
| 0x35, | |
| 0x37, | |
| 0x38, | |
| 0x3A, | |
| 0x3C, | |
| 0x3E, | |
| 0x40, | |
| 0x42, | |
| 0x45, | |
| 0x47, | |
| 0x49, | |
| 0x4B, | |
| 0x4D, | |
| 0x50, | |
| 0x52, | |
| 0x54, | |
| 0x57, | |
| 0x59, | |
| 0x5C, | |
| 0x5E, | |
| 0x61, | |
| 0x63, | |
| 0x66, | |
| 0x68, | |
| 0x6B, | |
| 0x6E, | |
| 0x71, | |
| 0x73, | |
| 0x76, | |
| 0x79, | |
| 0x7C, | |
| 0x7F, | |
| 0x82, | |
| 0x85, | |
| 0x88, | |
| 0x8D, | |
| 0x92, | |
| 0x97, | |
| 0x9D, | |
| 0xA2, | |
| 0xA7, | |
| 0xAD, | |
| 0xB3, | |
| 0xB9, | |
| 0xBE, | |
| 0xC4, | |
| 0xCB, | |
| 0xD1, | |
| 0xD7, | |
| 0xDD, | |
| 0xE4, | |
| 0xEB, | |
| 0xF1, | |
| 0xF8, | |
| 0xFF | |
| }, | |
| Package (0x65) | |
| { | |
| 0x03, | |
| 0x04, | |
| 0x05, | |
| 0x06, | |
| 0x07, | |
| 0x08, | |
| 0x09, | |
| 0x0A, | |
| 0x0B, | |
| 0x0C, | |
| 0x0D, | |
| 0x0E, | |
| 0x0F, | |
| 0x10, | |
| 0x11, | |
| 0x12, | |
| 0x13, | |
| 0x14, | |
| 0x15, | |
| 0x16, | |
| 0x17, | |
| 0x18, | |
| 0x19, | |
| 0x1A, | |
| 0x1B, | |
| 0x1C, | |
| 0x1D, | |
| 0x1E, | |
| 0x1F, | |
| 0x20, | |
| 0x21, | |
| 0x22, | |
| 0x23, | |
| 0x25, | |
| 0x26, | |
| 0x28, | |
| 0x2A, | |
| 0x2C, | |
| 0x2E, | |
| 0x2F, | |
| 0x31, | |
| 0x33, | |
| 0x35, | |
| 0x37, | |
| 0x3A, | |
| 0x3C, | |
| 0x3E, | |
| 0x40, | |
| 0x42, | |
| 0x45, | |
| 0x47, | |
| 0x4A, | |
| 0x4C, | |
| 0x4E, | |
| 0x51, | |
| 0x54, | |
| 0x56, | |
| 0x59, | |
| 0x5C, | |
| 0x5E, | |
| 0x61, | |
| 0x64, | |
| 0x67, | |
| 0x6A, | |
| 0x6D, | |
| 0x70, | |
| 0x73, | |
| 0x76, | |
| 0x79, | |
| 0x7D, | |
| 0x80, | |
| 0x83, | |
| 0x86, | |
| 0x8A, | |
| 0x8D, | |
| 0x91, | |
| 0x94, | |
| 0x98, | |
| 0x9C, | |
| 0x9F, | |
| 0xA3, | |
| 0xA7, | |
| 0xAB, | |
| 0xAF, | |
| 0xB4, | |
| 0xB8, | |
| 0xBC, | |
| 0xC1, | |
| 0xC5, | |
| 0xCA, | |
| 0xCE, | |
| 0xD3, | |
| 0xD8, | |
| 0xDC, | |
| 0xE1, | |
| 0xE6, | |
| 0xEB, | |
| 0xF0, | |
| 0xF5, | |
| 0xFA, | |
| 0xFF | |
| }, | |
| Package (0x65) | |
| { | |
| 0x03, | |
| 0x04, | |
| 0x05, | |
| 0x06, | |
| 0x07, | |
| 0x08, | |
| 0x09, | |
| 0x0A, | |
| 0x0B, | |
| 0x0C, | |
| 0x0D, | |
| 0x0E, | |
| 0x0F, | |
| 0x10, | |
| 0x11, | |
| 0x12, | |
| 0x13, | |
| 0x14, | |
| 0x15, | |
| 0x16, | |
| 0x17, | |
| 0x18, | |
| 0x19, | |
| 0x1A, | |
| 0x1C, | |
| 0x1D, | |
| 0x1F, | |
| 0x21, | |
| 0x22, | |
| 0x24, | |
| 0x26, | |
| 0x28, | |
| 0x2A, | |
| 0x2C, | |
| 0x2E, | |
| 0x30, | |
| 0x33, | |
| 0x35, | |
| 0x37, | |
| 0x3A, | |
| 0x3C, | |
| 0x3F, | |
| 0x41, | |
| 0x44, | |
| 0x46, | |
| 0x49, | |
| 0x4C, | |
| 0x4F, | |
| 0x51, | |
| 0x54, | |
| 0x57, | |
| 0x5A, | |
| 0x5D, | |
| 0x61, | |
| 0x64, | |
| 0x67, | |
| 0x6A, | |
| 0x6E, | |
| 0x71, | |
| 0x75, | |
| 0x78, | |
| 0x7C, | |
| 0x80, | |
| 0x83, | |
| 0x87, | |
| 0x8B, | |
| 0x8F, | |
| 0x93, | |
| 0x97, | |
| 0x9B, | |
| 0x9F, | |
| 0xA3, | |
| 0xA8, | |
| 0xAC, | |
| 0xB0, | |
| 0xB5, | |
| 0xB9, | |
| 0xBE, | |
| 0xC3, | |
| 0xC7, | |
| 0xCC, | |
| 0xCE, | |
| 0xD1, | |
| 0xD3, | |
| 0xD6, | |
| 0xD8, | |
| 0xDB, | |
| 0xDD, | |
| 0xE0, | |
| 0xE2, | |
| 0xE5, | |
| 0xE7, | |
| 0xEA, | |
| 0xEC, | |
| 0xEF, | |
| 0xF2, | |
| 0xF4, | |
| 0xF7, | |
| 0xFA, | |
| 0xFC, | |
| 0xFF | |
| }, | |
| Package (0x65) | |
| { | |
| 0x03, | |
| 0x04, | |
| 0x05, | |
| 0x06, | |
| 0x07, | |
| 0x08, | |
| 0x09, | |
| 0x0A, | |
| 0x0B, | |
| 0x0C, | |
| 0x0D, | |
| 0x0E, | |
| 0x0F, | |
| 0x10, | |
| 0x11, | |
| 0x12, | |
| 0x13, | |
| 0x14, | |
| 0x15, | |
| 0x16, | |
| 0x17, | |
| 0x18, | |
| 0x19, | |
| 0x1A, | |
| 0x1C, | |
| 0x1D, | |
| 0x1F, | |
| 0x21, | |
| 0x22, | |
| 0x24, | |
| 0x26, | |
| 0x28, | |
| 0x2A, | |
| 0x2C, | |
| 0x2E, | |
| 0x30, | |
| 0x33, | |
| 0x35, | |
| 0x37, | |
| 0x3A, | |
| 0x3C, | |
| 0x3F, | |
| 0x41, | |
| 0x44, | |
| 0x46, | |
| 0x49, | |
| 0x4C, | |
| 0x4F, | |
| 0x51, | |
| 0x54, | |
| 0x57, | |
| 0x5A, | |
| 0x5D, | |
| 0x61, | |
| 0x64, | |
| 0x67, | |
| 0x6A, | |
| 0x6E, | |
| 0x71, | |
| 0x75, | |
| 0x78, | |
| 0x7C, | |
| 0x80, | |
| 0x83, | |
| 0x87, | |
| 0x8B, | |
| 0x8F, | |
| 0x93, | |
| 0x97, | |
| 0x9B, | |
| 0x9F, | |
| 0xA3, | |
| 0xA8, | |
| 0xAC, | |
| 0xB0, | |
| 0xB5, | |
| 0xB9, | |
| 0xBE, | |
| 0xC3, | |
| 0xC7, | |
| 0xCC, | |
| 0xCE, | |
| 0xD1, | |
| 0xD3, | |
| 0xD6, | |
| 0xD8, | |
| 0xDB, | |
| 0xDD, | |
| 0xE0, | |
| 0xE2, | |
| 0xE5, | |
| 0xE7, | |
| 0xEA, | |
| 0xEC, | |
| 0xEF, | |
| 0xF2, | |
| 0xF4, | |
| 0xF7, | |
| 0xFA, | |
| 0xFC, | |
| 0xFF | |
| } | |
| }) | |
| Method (_Q14, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x8000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1010) | |
| } | |
| If (\NBCF) | |
| { | |
| If (\VIGD) | |
| { | |
| Notify (\_SB.PCI0.VID.LCD0, 0x86) // Device-Specific | |
| } | |
| Else | |
| { | |
| Notify (\_SB.PCI0.PEG.VID.LCD0, 0x86) // Device-Specific | |
| } | |
| } | |
| Else | |
| { | |
| Local0 = \BRLV | |
| If ((Local0 != 0x0F)) | |
| { | |
| Local0++ | |
| \BRLV = Local0 | |
| } | |
| If (\VIGD) | |
| { | |
| \UCMS (0x16) | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \VBRC (Local0) | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6050) | |
| } | |
| } | |
| Method (_Q15, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00010000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1011) | |
| } | |
| If (\NBCF) | |
| { | |
| If (\VIGD) | |
| { | |
| Notify (\_SB.PCI0.VID.LCD0, 0x87) // Device-Specific | |
| } | |
| Else | |
| { | |
| Notify (\_SB.PCI0.PEG.VID.LCD0, 0x87) // Device-Specific | |
| } | |
| } | |
| Else | |
| { | |
| Local0 = \BRLV | |
| If (Local0) | |
| { | |
| Local0-- | |
| \BRLV = Local0 | |
| } | |
| If (\VIGD) | |
| { | |
| \UCMS (0x16) | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \VBRC (Local0) | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6050) | |
| } | |
| Return (Zero) | |
| } | |
| Method (BRNS, 0, NotSerialized) | |
| { | |
| Local0 = (\BRLV + 0x02) | |
| Local3 = \BRTN | |
| If (\_SB.PCI0.VID.DRDY) | |
| { | |
| If ((0x00 == Local0)) | |
| { | |
| Local1 = DerefOf (DerefOf (BRTB [Local3]) [0x14]) | |
| Local2 = DerefOf (DerefOf (BRTB [Local3]) [0x12]) | |
| } | |
| Else | |
| { | |
| Local1 = DerefOf (DerefOf (BRTB [Local3]) [0x15]) | |
| Local2 = DerefOf (DerefOf (BRTB [Local3]) [0x13]) | |
| } | |
| Local2 = (Local1 | (Local2 << 0x09)) | |
| \_SB.PCI0.VID.AINT (0x03, Local2) | |
| Local2 = DerefOf (DerefOf (BRTB [Local3]) [Local0]) | |
| \_SB.PCI0.VID.AINT (0x01, Local2) | |
| } | |
| Else | |
| { | |
| \UCMS (0x12) | |
| } | |
| } | |
| Method (BRCF, 1, NotSerialized) | |
| { | |
| If ((Arg0 < 0x00)) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 > 0x64)) | |
| { | |
| Return (0x0F) | |
| } | |
| Local0 = (Arg0 + 0x03) | |
| Local0 *= 0x0F | |
| Divide (Local0, 0x64, Local0, Local1) | |
| Return (Local1) | |
| } | |
| Method (BRCD, 1, NotSerialized) | |
| { | |
| Local0 = DerefOf (DerefOf (BRTD [\BRTN]) [Arg0]) | |
| Return (Local0) | |
| } | |
| Method (BFRQ, 0, NotSerialized) | |
| { | |
| Local0 = 0x80000100 | |
| Local1 = DerefOf (DerefOf (BRTB [\BRTN]) [0x13]) | |
| Local0 |= (Local1 << 0x09) | |
| Local1 = DerefOf (DerefOf (BRTB [\BRTN]) [0x15]) | |
| Local0 |= Local1 | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q19, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00800000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1018) | |
| } | |
| \UCMS (0x03) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q63, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.MHKK (0x00080000)) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x1014) | |
| } | |
| \UCMS (0x0B) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q70, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| FNST () | |
| } | |
| Method (_Q72, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| FNST () | |
| } | |
| Method (_Q73, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| FNST () | |
| } | |
| Method (FNST, 0, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| Local0 = HFNS /* \_SB_.PCI0.LPC_.EC__.HFNS */ | |
| Local1 = HFNE /* \_SB_.PCI0.LPC_.EC__.HFNE */ | |
| } | |
| Else | |
| { | |
| Local0 = (\RBEC (0x0E) & 0x03) | |
| Local1 = (\RBEC (0x00) & 0x08) | |
| } | |
| If (Local1) | |
| { | |
| If ((Local0 == 0x00)) | |
| { | |
| \UCMS (0x11) | |
| } | |
| If ((Local0 == 0x01)) | |
| { | |
| \UCMS (0x0F) | |
| } | |
| If ((Local0 == 0x02)) | |
| { | |
| \UCMS (0x10) | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6005) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (GHSL, 1, NotSerialized) | |
| { | |
| Return (\FNSC (0x00, 0x00)) | |
| } | |
| Method (SHSL, 1, NotSerialized) | |
| { | |
| Return (\FNSC (0x01, (Arg0 & 0x00010001))) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Name (WGFL, 0x00) | |
| Method (WSIF, 0, NotSerialized) | |
| { | |
| Return (0x00) | |
| } | |
| Method (WLSW, 0, NotSerialized) | |
| { | |
| Return (0x00010001) | |
| } | |
| Method (GWAN, 0, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If ((WGFL & 0x01)) | |
| { | |
| Local0 |= 0x01 | |
| } | |
| If ((WGFL & 0x08)) | |
| { | |
| Return (Local0) | |
| } | |
| If (WPWS ()) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Local0 |= 0x04 | |
| Return (Local0) | |
| } | |
| Method (SWAN, 1, NotSerialized) | |
| { | |
| If ((Arg0 & 0x02)) | |
| { | |
| WPWC (0x01) | |
| } | |
| Else | |
| { | |
| WPWC (0x00) | |
| } | |
| } | |
| Method (GBDC, 0, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If ((WGFL & 0x10)) | |
| { | |
| Local0 |= 0x01 | |
| } | |
| If ((WGFL & 0x80)) | |
| { | |
| Return (Local0) | |
| } | |
| If (BPWS ()) | |
| { | |
| Local0 |= 0x02 | |
| } | |
| Local0 |= 0x04 | |
| Return (Local0) | |
| } | |
| Method (SBDC, 1, NotSerialized) | |
| { | |
| If ((Arg0 & 0x02)) | |
| { | |
| BPWC (0x01) | |
| } | |
| Else | |
| { | |
| BPWC (0x00) | |
| } | |
| } | |
| Method (WPWS, 0, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| Local0 = \_SB.PCI0.LPC.EC.DCWW | |
| } | |
| Else | |
| { | |
| Local0 = ((\RBEC (0x3A) & 0x40) >> 0x06) | |
| } | |
| Return (Local0) | |
| } | |
| Method (WPWC, 1, NotSerialized) | |
| { | |
| If ((Arg0 && ((WGFL & 0x01) && !(WGFL & 0x08 | |
| )))) | |
| { | |
| If (\H8DR) | |
| { | |
| \_SB.PCI0.LPC.EC.DCWW = One | |
| } | |
| Else | |
| { | |
| \MBEC (0x3A, 0xFF, 0x40) | |
| } | |
| WGFL |= 0x02 | |
| } | |
| Else | |
| { | |
| If (\H8DR) | |
| { | |
| \_SB.PCI0.LPC.EC.DCWW = Zero | |
| } | |
| Else | |
| { | |
| \MBEC (0x3A, 0xBF, 0x00) | |
| } | |
| WGFL &= ~0x02 | |
| } | |
| } | |
| Method (BPWS, 0, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| Local0 = \_SB.PCI0.LPC.EC.DCBD | |
| } | |
| Else | |
| { | |
| Local0 = ((\RBEC (0x3A) & 0x10) >> 0x04) | |
| } | |
| Return (Local0) | |
| } | |
| Method (BPWC, 1, NotSerialized) | |
| { | |
| If ((Arg0 && ((WGFL & 0x10) && !(WGFL & 0x80 | |
| )))) | |
| { | |
| If (\H8DR) | |
| { | |
| \_SB.PCI0.LPC.EC.DCBD = One | |
| } | |
| Else | |
| { | |
| \MBEC (0x3A, 0xFF, 0x10) | |
| } | |
| WGFL |= 0x20 | |
| } | |
| Else | |
| { | |
| If (\H8DR) | |
| { | |
| \_SB.PCI0.LPC.EC.DCBD = Zero | |
| } | |
| Else | |
| { | |
| \MBEC (0x3A, 0xEF, 0x00) | |
| } | |
| WGFL &= ~0x20 | |
| } | |
| } | |
| Method (WGIN, 0, NotSerialized) | |
| { | |
| WGFL = 0x00 | |
| WGFL = \WGSV (0x01) | |
| If (\WIN8) | |
| { | |
| If ((WGFL && 0x10)) | |
| { | |
| BPWC (0x01) | |
| } | |
| } | |
| If (WPWS ()) | |
| { | |
| WGFL |= 0x02 | |
| } | |
| If (BPWS ()) | |
| { | |
| WGFL |= 0x20 | |
| } | |
| } | |
| Method (WGPS, 1, NotSerialized) | |
| { | |
| If ((Arg0 >= 0x04)) | |
| { | |
| \BLTH (0x05) | |
| } | |
| } | |
| Method (WGWK, 1, NotSerialized) | |
| { | |
| If ((WGFL & 0x20)) | |
| { | |
| BPWC (0x01) | |
| } | |
| If ((WGFL & 0x02)) | |
| { | |
| WPWC (0x01) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q41, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x7000) | |
| } | |
| } | |
| Device (WMI1) | |
| { | |
| Name (_HID, EisaId ("PNP0C14") /* Windows Management Instrumentation Device */) // _HID: Hardware ID | |
| Name (_UID, 0x01) // _UID: Unique ID | |
| Name (_WDG, Buffer (0xB4) | |
| { | |
| /* 0000 */ 0x0E, 0x23, 0xF5, 0x51, 0x77, 0x96, 0xCD, 0x46, // .#.Qw..F | |
| /* 0008 */ 0xA1, 0xCF, 0xC0, 0xB2, 0x3E, 0xE3, 0x4D, 0xB7, // ....>.M. | |
| /* 0010 */ 0x41, 0x30, 0x50, 0x05, 0x64, 0x9A, 0x47, 0x98, // A0P.d.G. | |
| /* 0018 */ 0xF5, 0x33, 0x33, 0x4E, 0xA7, 0x07, 0x8E, 0x25, // .33N...% | |
| /* 0020 */ 0x1E, 0xBB, 0xC3, 0xA1, 0x41, 0x31, 0x01, 0x06, // ....A1.. | |
| /* 0028 */ 0xEF, 0x54, 0x4B, 0x6A, 0xED, 0xA5, 0x33, 0x4D, // .TKj..3M | |
| /* 0030 */ 0x94, 0x55, 0xB0, 0xD9, 0xB4, 0x8D, 0xF4, 0xB3, // .U...... | |
| /* 0038 */ 0x41, 0x32, 0x01, 0x06, 0xB6, 0xEB, 0xF1, 0x74, // A2.....t | |
| /* 0040 */ 0x7A, 0x92, 0x7D, 0x4C, 0x95, 0xDF, 0x69, 0x8E, // z.}L..i. | |
| /* 0048 */ 0x21, 0xE8, 0x0E, 0xB5, 0x41, 0x33, 0x01, 0x06, // !...A3.. | |
| /* 0050 */ 0xFF, 0x04, 0xEF, 0x7E, 0x28, 0x43, 0x7C, 0x44, // ...~(C|D | |
| /* 0058 */ 0xB5, 0xBB, 0xD4, 0x49, 0x92, 0x5D, 0x53, 0x8D, // ...I.]S. | |
| /* 0060 */ 0x41, 0x34, 0x01, 0x06, 0x9E, 0x15, 0xDB, 0x8A, // A4...... | |
| /* 0068 */ 0x32, 0x1E, 0x5C, 0x45, 0xBC, 0x93, 0x30, 0x8A, // 2.\E..0. | |
| /* 0070 */ 0x7E, 0xD9, 0x82, 0x46, 0x41, 0x35, 0x01, 0x01, // ~..FA5.. | |
| /* 0078 */ 0xFD, 0xD9, 0x51, 0x26, 0x1C, 0x91, 0x69, 0x4B, // ..Q&..iK | |
| /* 0080 */ 0xB9, 0x4E, 0xD0, 0xDE, 0xD5, 0x96, 0x3B, 0xD7, // .N....;. | |
| /* 0088 */ 0x41, 0x36, 0x01, 0x06, 0x1A, 0x65, 0x64, 0x73, // A6...eds | |
| /* 0090 */ 0x2F, 0x13, 0xE7, 0x4F, 0xAD, 0xAA, 0x40, 0xC6, // /..O..@. | |
| /* 0098 */ 0xC7, 0xEE, 0x2E, 0x3B, 0x41, 0x37, 0x01, 0x06, // ...;A7.. | |
| /* 00A0 */ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, // !...f... | |
| /* 00A8 */ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, // ......). | |
| /* 00B0 */ 0x42, 0x41, 0x01, 0x00 // BA.. | |
| }) | |
| Name (RETN, Package (0x05) | |
| { | |
| "Success", | |
| "Not Supported", | |
| "Invalid Parameter", | |
| "Access Denied", | |
| "System Busy" | |
| }) | |
| Name (ITEM, Package (0x58) | |
| { | |
| Package (0x02) | |
| { | |
| 0x0E, | |
| "WakeOnLAN" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "EthernetLANOptionROM" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "USBBIOSSupport" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "AlwaysOnUSB" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x01, | |
| "TrackPoint" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x01, | |
| "TouchPad" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FnSticky" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x04, | |
| "ThinkPadNumLock" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0C, | |
| "PowerOnNumLock" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x05, | |
| "BootDisplayDevice" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "SpeedStep" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x09, | |
| "AdaptiveThermalManagementAC" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x09, | |
| "AdaptiveThermalManagementBattery" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x06, | |
| "CDROMSpeed" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x01, | |
| "CPUPowerManagement" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "PowerControlBeep" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "LowBatteryAlarm" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "PasswordBeep" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "KeyboardBeep" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "ExtendedMemoryTest" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x07, | |
| "SATAControllerMode" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "CoreMultiProcessing" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "VirtualizationTechnology" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "LockBIOSSetting" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0B, | |
| "MinimumPasswordLength" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BIOSPasswordAtUnattendedBoot" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FingerprintPredesktopAuthentication" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x08, | |
| "FingerprintReaderPriority" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x03, | |
| "FingerprintSecurityMode" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x02, | |
| "SecurityChip" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BIOSUpdateByEndUsers" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "DataExecutionPrevention" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "EthernetLANAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "WirelessLANAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "WirelessWANAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BluetoothAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "WirelessUSBAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "ModemAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "USBPortAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "IEEE1394Access" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "ExpressCardAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "PCIExpressSlotAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "UltrabayAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "MemoryCardSlotAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "SmartCardSlotAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "IntegratedCameraAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "MicrophoneAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0A, | |
| "BootMode" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "StartupOptionKeys" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BootDeviceListF12Option" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x64, | |
| "BootOrder" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "WiMAXAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0D, | |
| "GraphicsDevice" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "TXTFeature" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "VTdFeature" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0F, | |
| "AMTControl" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FingerprintPasswordAuthentication" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FingerprintReaderAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "OsDetectionForSwitchableGraphics" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0F, | |
| "ComputraceModuleActivation" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x01, | |
| "PCIExpressPowerManagement" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x0F, | |
| "ATpModuleActivation" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "eSATAPortAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "HardwarePasswordManager" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "HyperThreadingTechnology" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FnCtrlKeySwap" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BIOSPasswordAtReboot" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "OnByAcAttach" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x64, | |
| "NetworkBoot" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BootOrderLock" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x10, | |
| "USB30Mode" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x11, | |
| "ExpressCardSpeed" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "RapidStartTechnology" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x12, | |
| "KeyboardIllumination" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "IPv4NetworkStack" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "IPv6NetworkStack" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x13, | |
| "UefiPxeBootPriority" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "PhysicalPresenceForTpmProvision" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "PhysicalPresenceForTpmClear" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "SecureRollBackPrevention" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "SecureBoot" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "NfcAccess" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "BottomCoverTamperDetected" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x14, | |
| "DiscreteGFXPerfMode" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x15, | |
| "TotalGraphicsMemory" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x16, | |
| "SmartConnectTechnology" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x17, | |
| "BootTimeExtension" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "FnKeyAsPrimary" | |
| } | |
| }) | |
| Name (VSEL, Package (0x18) | |
| { | |
| Package (0x02) | |
| { | |
| "Disable", | |
| "Enable" | |
| }, | |
| Package (0x02) | |
| { | |
| "Disable", | |
| "Automatic" | |
| }, | |
| Package (0x03) | |
| { | |
| "Active", | |
| "Inactive", | |
| "Disable" | |
| }, | |
| Package (0x02) | |
| { | |
| "Normal", | |
| "High" | |
| }, | |
| Package (0x02) | |
| { | |
| "Independent", | |
| "Synchronized" | |
| }, | |
| Package (0x04) | |
| { | |
| "LCD", | |
| "VGA", | |
| "Digital", | |
| "DockDisplay" | |
| }, | |
| Package (0x03) | |
| { | |
| "High", | |
| "Normal", | |
| "Silent" | |
| }, | |
| Package (0x02) | |
| { | |
| "Compatibility", | |
| "AHCI" | |
| }, | |
| Package (0x02) | |
| { | |
| "External", | |
| "InternalOnly" | |
| }, | |
| Package (0x02) | |
| { | |
| "MaximizePerformance", | |
| "Balanced" | |
| }, | |
| Package (0x02) | |
| { | |
| "Quick", | |
| "Diagnostics" | |
| }, | |
| Package (0x0A) | |
| { | |
| "Disable", | |
| "4", | |
| "5", | |
| "6", | |
| "7", | |
| "8", | |
| "9", | |
| "10", | |
| "11", | |
| "12" | |
| }, | |
| Package (0x03) | |
| { | |
| "Auto", | |
| "On", | |
| "Off" | |
| }, | |
| Package (0x03) | |
| { | |
| "IntegratedGfx", | |
| "", | |
| "SwitchableGfx" | |
| }, | |
| Package (0x04) | |
| { | |
| "Disable", | |
| "ACOnly", | |
| "ACandBattery", | |
| "Enable" | |
| }, | |
| Package (0x03) | |
| { | |
| "Disable", | |
| "Enable", | |
| "Disable" | |
| }, | |
| Package (0x03) | |
| { | |
| "Disable", | |
| "Enable", | |
| "Automatic" | |
| }, | |
| Package (0x02) | |
| { | |
| "Generation1", | |
| "Automatic" | |
| }, | |
| Package (0x03) | |
| { | |
| "ThinkLightOnly", | |
| "BacklightOnly", | |
| "Both" | |
| }, | |
| Package (0x02) | |
| { | |
| "IPv6First", | |
| "IPv4First" | |
| }, | |
| Package (0x02) | |
| { | |
| "Balanced", | |
| "HighPerformance" | |
| }, | |
| Package (0x02) | |
| { | |
| "256MB", | |
| "512MB" | |
| }, | |
| Package (0x02) | |
| { | |
| "Enable", | |
| "Disable" | |
| }, | |
| Package (0x0B) | |
| { | |
| "Disable", | |
| "1", | |
| "2", | |
| "3", | |
| "", | |
| "5", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "10" | |
| } | |
| }) | |
| Name (VLST, Package (0x0F) | |
| { | |
| "HDD0", | |
| "HDD1", | |
| "HDD2", | |
| "HDD3", | |
| "HDD4", | |
| "PCILAN", | |
| "ATAPICD0", | |
| "ATAPICD1", | |
| "ATAPICD2", | |
| "USBFDD", | |
| "USBCD", | |
| "USBHDD", | |
| "OtherHDD", | |
| "OtherCD", | |
| "NODEV" | |
| }) | |
| Name (PENC, Package (0x02) | |
| { | |
| "ascii", | |
| "scancode" | |
| }) | |
| Name (PKBD, Package (0x03) | |
| { | |
| "us", | |
| "fr", | |
| "gr" | |
| }) | |
| Name (PTYP, Package (0x08) | |
| { | |
| "pap", | |
| "pop", | |
| "uhdp1", | |
| "mhdp1", | |
| "uhdp2", | |
| "mhdp2", | |
| "uhdp3", | |
| "mhdp3" | |
| }) | |
| Mutex (MWMI, 0x07) | |
| Name (PCFG, Buffer (0x18){}) | |
| Name (IBUF, Buffer (0x0100){}) | |
| Name (ILEN, 0x00) | |
| Name (PSTR, Buffer (0x81){}) | |
| Method (WQA0, 1, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| If ((\WMIS (0x00, Arg0) != 0x00)) | |
| { | |
| Release (MWMI) | |
| Return ("") | |
| } | |
| Local0 = DerefOf (ITEM [\WITM]) | |
| Local1 = DerefOf (Local0 [0x00]) | |
| Local2 = DerefOf (Local0 [0x01]) | |
| If ((Local1 < 0x64)) | |
| { | |
| Concatenate (Local2, ",", Local6) | |
| Local3 = DerefOf (VSEL [Local1]) | |
| Concatenate (Local6, DerefOf (Local3 [\WSEL]), Local7) | |
| } | |
| Else | |
| { | |
| Local3 = SizeOf (VLST) | |
| If ((\WLS0 <= Local3)) | |
| { | |
| Concatenate (Local2, ",", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS0]), Local2) | |
| } | |
| If ((\WLS1 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS1]), Local2) | |
| } | |
| If ((\WLS2 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS2]), Local2) | |
| } | |
| If ((\WLS3 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS3]), Local2) | |
| } | |
| If ((\WLS4 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS4]), Local2) | |
| } | |
| If ((\WLS5 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS5]), Local2) | |
| } | |
| If ((\WLS6 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS6]), Local2) | |
| } | |
| If ((\WLS7 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS7]), Local2) | |
| } | |
| If ((\WLS8 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS8]), Local2) | |
| } | |
| If ((\WLS9 <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLS9]), Local2) | |
| } | |
| If ((\WLSA <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLSA]), Local2) | |
| } | |
| If ((\WLSB <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLSB]), Local2) | |
| } | |
| If ((\WLSC <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLSC]), Local2) | |
| } | |
| If ((\WLSD <= Local3)) | |
| { | |
| Concatenate (Local2, ":", Local7) | |
| Concatenate (Local7, DerefOf (VLST [\WLSD]), Local2) | |
| } | |
| Local7 = Local2 | |
| } | |
| Release (MWMI) | |
| Return (Local7) | |
| } | |
| Method (WMA1, 3, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| If ((SizeOf (Arg2) == 0x00)) | |
| { | |
| Local0 = 0x02 | |
| } | |
| Else | |
| { | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = WSET (ITEM, VSEL) | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x01, 0x00) | |
| } | |
| } | |
| } | |
| Release (MWMI) | |
| Return (DerefOf (RETN [Local0])) | |
| } | |
| Method (WMA2, 3, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| If ((ILEN != 0x00)) | |
| { | |
| Local0 = CPAS (IBUF, 0x00) | |
| } | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x02, 0x00) | |
| } | |
| } | |
| Release (MWMI) | |
| Return (DerefOf (RETN [Local0])) | |
| } | |
| Method (WMA3, 3, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| If ((ILEN != 0x00)) | |
| { | |
| Local0 = CPAS (IBUF, 0x00) | |
| } | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x03, 0x00) | |
| } | |
| } | |
| Release (MWMI) | |
| Return (DerefOf (RETN [Local0])) | |
| } | |
| Method (WMA4, 3, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| If ((ILEN != 0x00)) | |
| { | |
| Local0 = CPAS (IBUF, 0x00) | |
| } | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x04, 0x00) | |
| } | |
| } | |
| Release (MWMI) | |
| Return (DerefOf (RETN [Local0])) | |
| } | |
| Method (WQA5, 1, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| Local0 = \WMIS (0x05, 0x00) | |
| PCFG [0x00] = \WSPM | |
| PCFG [0x04] = \WSPS | |
| PCFG [0x08] = \WSMN | |
| PCFG [0x0C] = \WSMX | |
| PCFG [0x10] = \WSEN | |
| PCFG [0x14] = \WSKB | |
| Release (MWMI) | |
| Return (PCFG) /* \_SB_.WMI1.PCFG */ | |
| } | |
| Method (WMA6, 3, NotSerialized) | |
| { | |
| Acquire (MWMI, 0xFFFF) | |
| If ((SizeOf (Arg2) == 0x00)) | |
| { | |
| Local0 = 0x02 | |
| } | |
| Else | |
| { | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| If ((ILEN != 0x00)) | |
| { | |
| Local0 = SPAS (IBUF) | |
| } | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x06, 0x00) | |
| } | |
| } | |
| } | |
| Release (MWMI) | |
| Return (DerefOf (RETN [Local0])) | |
| } | |
| Method (WMA7, 3, NotSerialized) | |
| { | |
| If ((SizeOf (Arg2) == 0x00)) | |
| { | |
| Return ("") | |
| } | |
| Local0 = CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| Local1 = GITM (IBUF, ITEM) | |
| If ((Local1 == Ones)) | |
| { | |
| Return ("") | |
| } | |
| Local0 = DerefOf (ITEM [Local1]) | |
| Local1 = DerefOf (Local0 [0x00]) | |
| If ((Local1 < 0x64)) | |
| { | |
| Local3 = DerefOf (VSEL [Local1]) | |
| Local2 = DerefOf (Local3 [0x00]) | |
| Local4 = SizeOf (Local3) | |
| Local5 = 0x01 | |
| While ((Local5 < Local4)) | |
| { | |
| Local6 = DerefOf (Local3 [Local5]) | |
| If ((SizeOf (Local6) != 0x00)) | |
| { | |
| Concatenate (Local2, ",", Local7) | |
| Concatenate (Local7, Local6, Local2) | |
| } | |
| Local5++ | |
| } | |
| } | |
| Else | |
| { | |
| Local2 = DerefOf (VLST [0x00]) | |
| Local4 = SizeOf (VLST) | |
| Local5 = 0x01 | |
| While ((Local5 < Local4)) | |
| { | |
| Local6 = DerefOf (VLST [Local5]) | |
| Concatenate (Local2, ",", Local7) | |
| Concatenate (Local7, Local6, Local2) | |
| Local5++ | |
| } | |
| } | |
| } | |
| Return (Local2) | |
| } | |
| Method (CARG, 1, NotSerialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| If ((Local0 == 0x00)) | |
| { | |
| IBUF = 0x00 | |
| ILEN = 0x00 | |
| Return (0x00) | |
| } | |
| If ((ObjectType (Arg0) != 0x02)) | |
| { | |
| Return (0x02) | |
| } | |
| If ((Local0 >= 0xFF)) | |
| { | |
| Return (0x02) | |
| } | |
| IBUF = Arg0 | |
| Local0-- | |
| Local1 = DerefOf (IBUF [Local0]) | |
| If (((Local1 == 0x3B) || (Local1 == 0x2A))) | |
| { | |
| IBUF [Local0] = 0x00 | |
| ILEN = Local0 | |
| } | |
| Else | |
| { | |
| ILEN = SizeOf (Arg0) | |
| } | |
| Return (0x00) | |
| } | |
| Method (SCMP, 3, NotSerialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| If ((Local0 == 0x00)) | |
| { | |
| Return (0x00) | |
| } | |
| Local0++ | |
| Name (STR1, Buffer (Local0){}) | |
| STR1 = Arg0 | |
| Local0-- | |
| Local1 = 0x00 | |
| Local2 = Arg2 | |
| While ((Local1 < Local0)) | |
| { | |
| Local3 = DerefOf (STR1 [Local1]) | |
| Local4 = DerefOf (Arg1 [Local2]) | |
| If ((Local3 != Local4)) | |
| { | |
| Return (0x00) | |
| } | |
| Local1++ | |
| Local2++ | |
| } | |
| Local4 = DerefOf (Arg1 [Local2]) | |
| If ((Local4 == 0x00)) | |
| { | |
| Return (0x01) | |
| } | |
| If (((Local4 == 0x2C) || (Local4 == 0x3A))) | |
| { | |
| Return (0x01) | |
| } | |
| Return (0x00) | |
| } | |
| Method (GITM, 2, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| Local1 = SizeOf (Arg1) | |
| While ((Local0 < Local1)) | |
| { | |
| Local3 = DerefOf (DerefOf (Arg1 [Local0]) [0x01]) | |
| If (SCMP (Local3, Arg0, 0x00)) | |
| { | |
| Return (Local0) | |
| } | |
| Local0++ | |
| } | |
| Return (Ones) | |
| } | |
| Method (GSEL, 3, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| Local1 = SizeOf (Arg0) | |
| While ((Local0 < Local1)) | |
| { | |
| Local2 = DerefOf (Arg0 [Local0]) | |
| If (SCMP (Local2, Arg1, Arg2)) | |
| { | |
| Return (Local0) | |
| } | |
| Local0++ | |
| } | |
| Return (Ones) | |
| } | |
| Method (SLEN, 2, NotSerialized) | |
| { | |
| Local0 = DerefOf (Arg0 [Arg1]) | |
| Return (SizeOf (Local0)) | |
| } | |
| Method (CLRP, 0, NotSerialized) | |
| { | |
| \WPAS = 0x00 | |
| \WPNW = 0x00 | |
| } | |
| Method (GPAS, 2, NotSerialized) | |
| { | |
| Local0 = Arg1 | |
| Local1 = 0x00 | |
| While ((Local1 <= 0x80)) | |
| { | |
| Local2 = DerefOf (Arg0 [Local0]) | |
| If (((Local2 == 0x2C) || (Local2 == 0x00))) | |
| { | |
| PSTR [Local1] = 0x00 | |
| Return (Local1) | |
| } | |
| PSTR [Local1] = Local2 | |
| Local0++ | |
| Local1++ | |
| } | |
| PSTR [Local1] = 0x00 | |
| Return (Ones) | |
| } | |
| Method (CPAS, 2, NotSerialized) | |
| { | |
| CLRP () | |
| Local0 = Arg1 | |
| Local1 = GPAS (Arg0, Local0) | |
| If ((Local1 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| If ((Local1 == 0x00)) | |
| { | |
| Return (0x02) | |
| } | |
| \WPAS = PSTR /* \_SB_.WMI1.PSTR */ | |
| Local0 += Local1 | |
| Local0++ | |
| Local6 = GSEL (PENC, Arg0, Local0) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WENC = Local6 | |
| If ((Local6 == 0x00)) | |
| { | |
| Local0 += SLEN (PENC, 0x00) | |
| If ((DerefOf (Arg0 [Local0]) != 0x2C)) | |
| { | |
| Return (0x02) | |
| } | |
| Local0++ | |
| Local6 = GSEL (PKBD, Arg0, Local0) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WKBD = Local6 | |
| } | |
| Return (0x00) | |
| } | |
| Method (SPAS, 1, NotSerialized) | |
| { | |
| CLRP () | |
| Local6 = GSEL (PTYP, Arg0, 0x00) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WPTY = Local6 | |
| Local0 = SLEN (PTYP, Local6) | |
| If ((DerefOf (Arg0 [Local0]) != 0x2C)) | |
| { | |
| Return (0x02) | |
| } | |
| Local0++ | |
| Local1 = GPAS (Arg0, Local0) | |
| If (((Local1 == Ones) || (Local1 == 0x00))) | |
| { | |
| Return (0x02) | |
| } | |
| \WPAS = PSTR /* \_SB_.WMI1.PSTR */ | |
| Local0 += Local1 | |
| If ((DerefOf (Arg0 [Local0]) != 0x2C)) | |
| { | |
| Return (0x02) | |
| } | |
| Local0++ | |
| Local1 = GPAS (Arg0, Local0) | |
| If ((Local1 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| If ((Local1 == 0x00)) | |
| { | |
| PSTR = 0x00 | |
| } | |
| \WPNW = PSTR /* \_SB_.WMI1.PSTR */ | |
| Local0 += Local1 | |
| Local0++ | |
| Local6 = GSEL (PENC, Arg0, Local0) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WENC = Local6 | |
| If ((Local6 == 0x00)) | |
| { | |
| Local0 += SLEN (PENC, 0x00) | |
| If ((DerefOf (Arg0 [Local0]) != 0x2C)) | |
| { | |
| Return (0x02) | |
| } | |
| Local0++ | |
| Local6 = GSEL (PKBD, Arg0, Local0) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WKBD = Local6 | |
| } | |
| Return (0x00) | |
| } | |
| Method (WSET, 2, NotSerialized) | |
| { | |
| Local0 = ILEN /* \_SB_.WMI1.ILEN */ | |
| Local0++ | |
| Local1 = GITM (IBUF, Arg0) | |
| If ((Local1 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WITM = Local1 | |
| Local3 = DerefOf (Arg0 [Local1]) | |
| Local4 = DerefOf (Local3 [0x01]) | |
| Local2 = SizeOf (Local4) | |
| Local2++ | |
| Local4 = DerefOf (Local3 [0x00]) | |
| If ((Local4 < 0x64)) | |
| { | |
| Local5 = DerefOf (Arg1 [Local4]) | |
| Local6 = GSEL (Local5, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WSEL = Local6 | |
| Local2 += SLEN (Local5, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| Else | |
| { | |
| \WLS0 = 0x3F | |
| \WLS1 = 0x3F | |
| \WLS2 = 0x3F | |
| \WLS3 = 0x3F | |
| \WLS4 = 0x3F | |
| \WLS5 = 0x3F | |
| \WLS6 = 0x3F | |
| \WLS7 = 0x3F | |
| \WLS8 = 0x3F | |
| \WLS9 = 0x3F | |
| \WLSA = 0x3F | |
| \WLSB = 0x3F | |
| \WLSC = 0x3F | |
| \WLSD = 0x3F | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS0 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS1 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS2 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS3 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS4 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS5 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS6 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS7 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS8 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLS9 = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLSA = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLSB = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLSC = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| If (((Local2 < Local0) && (Local4 == 0x3A))) | |
| { | |
| Local2++ | |
| Local6 = GSEL (VLST, IBUF, Local2) | |
| If ((Local6 == Ones)) | |
| { | |
| Return (0x02) | |
| } | |
| \WLSD = Local6 | |
| Local2 += SLEN (VLST, Local6) | |
| Local4 = DerefOf (IBUF [Local2]) | |
| } | |
| } | |
| If (((Local4 == 0x2C) && (Local2 < Local0))) | |
| { | |
| Local2++ | |
| Local0 = CPAS (IBUF, Local2) | |
| If ((Local0 != 0x00)) | |
| { | |
| Return (Local0) | |
| } | |
| } | |
| Return (0x00) | |
| } | |
| Name (WQBA, Buffer (0x089D) | |
| { | |
| /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB.... | |
| /* 0008 */ 0x8D, 0x08, 0x00, 0x00, 0xF2, 0x36, 0x00, 0x00, // .....6.. | |
| /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T | |
| /* 0018 */ 0xA8, 0xC9, 0x9A, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B | |
| /* 0020 */ 0x10, 0x13, 0x10, 0x0A, 0x0D, 0x21, 0x02, 0x0B, // .....!.. | |
| /* 0028 */ 0x83, 0x50, 0x4C, 0x18, 0x14, 0xA0, 0x45, 0x41, // .PL...EA | |
| /* 0030 */ 0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, // .....!.. | |
| /* 0038 */ 0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, // ..p.@... | |
| /* 0040 */ 0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, // (r.".... | |
| /* 0048 */ 0x31, 0x0E, 0x88, 0x14, 0x40, 0x48, 0x26, 0x84, // 1...@H&. | |
| /* 0050 */ 0x44, 0x00, 0x53, 0x21, 0x70, 0x84, 0xA0, 0x5F, // D.S!p.._ | |
| /* 0058 */ 0x01, 0x08, 0x1D, 0xA2, 0xC9, 0xA0, 0x00, 0xA7, // ........ | |
| /* 0060 */ 0x08, 0x82, 0xB4, 0x65, 0x01, 0xBA, 0x05, 0xF8, // ...e.... | |
| /* 0068 */ 0x16, 0xA0, 0x1D, 0x42, 0x68, 0x15, 0x0A, 0x30, // ...Bh..0 | |
| /* 0070 */ 0x29, 0xC0, 0x27, 0x98, 0x2C, 0x0A, 0x90, 0x0D, // ).'.,... | |
| /* 0078 */ 0x26, 0xDB, 0x70, 0x64, 0x18, 0x4C, 0xE4, 0x18, // &.pd.L.. | |
| /* 0080 */ 0x50, 0x62, 0xC6, 0x80, 0xD2, 0x39, 0x05, 0xD9, // Pb...9.. | |
| /* 0088 */ 0x04, 0x16, 0x74, 0xA1, 0x28, 0x9A, 0x46, 0x94, // ..t.(.F. | |
| /* 0090 */ 0x04, 0x07, 0x75, 0x0C, 0x11, 0x82, 0x97, 0x2B, // ..u....+ | |
| /* 0098 */ 0x40, 0xF2, 0x04, 0xA4, 0x79, 0x5E, 0xB2, 0x3E, // @...y^.> | |
| /* 00A0 */ 0x08, 0x0D, 0x81, 0x8D, 0x80, 0x47, 0x91, 0x00, // .....G.. | |
| /* 00A8 */ 0xC2, 0x62, 0x2C, 0x53, 0xE2, 0x61, 0x50, 0x1E, // .b,S.aP. | |
| /* 00B0 */ 0x40, 0x24, 0x67, 0xA8, 0x28, 0x60, 0x7B, 0x9D, // @$g.(`{. | |
| /* 00B8 */ 0x88, 0x86, 0x75, 0x9C, 0x4C, 0x12, 0x1C, 0x6A, // ..u.L..j | |
| /* 00C0 */ 0x94, 0x96, 0x28, 0xC0, 0xFC, 0xC8, 0x34, 0x91, // ..(...4. | |
| /* 00C8 */ 0x63, 0x6B, 0x7A, 0xC4, 0x82, 0x64, 0xD2, 0x86, // ckz..d.. | |
| /* 00D0 */ 0x82, 0x1A, 0xBA, 0xA7, 0x75, 0x52, 0x9E, 0x68, // ....uR.h | |
| /* 00D8 */ 0xC4, 0x83, 0x32, 0x4C, 0x02, 0x8F, 0x82, 0xA1, // ..2L.... | |
| /* 00E0 */ 0x71, 0x82, 0xB2, 0x20, 0xE4, 0x60, 0xA0, 0x28, // q.. .`.( | |
| /* 00E8 */ 0xC0, 0x93, 0xF0, 0x1C, 0x8B, 0x17, 0x20, 0x7C, // ...... | | |
| /* 00F0 */ 0xC6, 0xE4, 0x28, 0x10, 0x23, 0x81, 0x8F, 0x04, // ..(.#... | |
| /* 00F8 */ 0x1E, 0xCD, 0x31, 0x63, 0x81, 0xC2, 0x05, 0x3C, // ..1c...< | |
| /* 0100 */ 0x9F, 0x63, 0x88, 0x1C, 0xF7, 0x50, 0x63, 0x1C, // .c...Pc. | |
| /* 0108 */ 0x45, 0xE4, 0x04, 0xEF, 0x00, 0x51, 0x8C, 0x56, // E....Q.V | |
| /* 0110 */ 0xD0, 0xBC, 0x85, 0x18, 0x2C, 0x9A, 0xC1, 0x7A, // ....,..z | |
| /* 0118 */ 0x06, 0x27, 0x83, 0x4E, 0xF0, 0xFF, 0x3F, 0x02, // .'.N..?. | |
| /* 0120 */ 0x2E, 0x03, 0x42, 0x1E, 0x05, 0x58, 0x1D, 0x94, // ..B..X.. | |
| /* 0128 */ 0xA6, 0x61, 0x82, 0xEE, 0x05, 0xBC, 0x1A, 0x1A, // .a...... | |
| /* 0130 */ 0x13, 0xA0, 0x11, 0x43, 0xCA, 0x04, 0x38, 0xBB, // ...C..8. | |
| /* 0138 */ 0x2F, 0x68, 0x46, 0x6D, 0x09, 0x30, 0x27, 0x40, // /hFm.0'@ | |
| /* 0140 */ 0x9B, 0x00, 0x6F, 0x08, 0x42, 0x39, 0xCF, 0x28, // ..o.B9.( | |
| /* 0148 */ 0xC7, 0x72, 0x8A, 0x51, 0x1E, 0x06, 0x62, 0xBE, // .r.Q..b. | |
| /* 0150 */ 0x0C, 0x04, 0x8D, 0x12, 0x23, 0xE6, 0xB9, 0xC4, // ....#... | |
| /* 0158 */ 0x35, 0x6C, 0x84, 0x18, 0x21, 0x4F, 0x21, 0x50, // 5l..!O!P | |
| /* 0160 */ 0xDC, 0xF6, 0x07, 0x41, 0x06, 0x8D, 0x1B, 0xBD, // ...A.... | |
| /* 0168 */ 0x4F, 0x0B, 0x67, 0x75, 0x02, 0x47, 0xFF, 0xA4, // O.gu.G.. | |
| /* 0170 */ 0x60, 0x02, 0x4F, 0xF9, 0xC0, 0x9E, 0x0D, 0x4E, // `.O....N | |
| /* 0178 */ 0xE0, 0x58, 0xA3, 0xC6, 0x38, 0x95, 0x04, 0x8E, // .X..8... | |
| /* 0180 */ 0xFD, 0x80, 0x90, 0x06, 0x10, 0x45, 0x82, 0x47, // .....E.G | |
| /* 0188 */ 0x9D, 0x16, 0x7C, 0x2E, 0xF0, 0xD0, 0x0E, 0xDA, // ..|..... | |
| /* 0190 */ 0x73, 0x3C, 0x81, 0x20, 0x87, 0x70, 0x04, 0x4F, // s<. .p.O | |
| /* 0198 */ 0x0C, 0x0F, 0x04, 0x1E, 0x03, 0xBB, 0x29, 0xF8, // ......). | |
| /* 01A0 */ 0x08, 0xE0, 0x13, 0x02, 0xDE, 0x35, 0xA0, 0xAE, // .....5.. | |
| /* 01A8 */ 0x06, 0x0F, 0x06, 0x6C, 0xD0, 0xE1, 0x30, 0xE3, // ...l..0. | |
| /* 01B0 */ 0xF5, 0xF0, 0xC3, 0x9D, 0xC0, 0x49, 0x3E, 0x60, // .....I>` | |
| /* 01B8 */ 0xF0, 0xC3, 0x86, 0x07, 0x87, 0x9B, 0xE7, 0xC9, // ........ | |
| /* 01C0 */ 0x1C, 0x59, 0xA9, 0x02, 0xCC, 0x1E, 0x0E, 0x74, // .Y.....t | |
| /* 01C8 */ 0x90, 0xF0, 0x69, 0x83, 0x9D, 0x01, 0x30, 0xF2, // ..i...0. | |
| /* 01D0 */ 0x07, 0x81, 0x1A, 0x99, 0xA1, 0x3D, 0xEE, 0x97, // .....=.. | |
| /* 01D8 */ 0x0E, 0x43, 0x3E, 0x27, 0x1C, 0x16, 0x13, 0x7B, // .C>'...{ | |
| /* 01E0 */ 0xEA, 0xA0, 0xE3, 0x01, 0xFF, 0x65, 0xE4, 0x39, // .....e.9 | |
| /* 01E8 */ 0xC3, 0xD3, 0xF7, 0x7C, 0x4D, 0x30, 0xEC, 0xC0, // ...|M0.. | |
| /* 01F0 */ 0xD1, 0x03, 0x31, 0xF4, 0xC3, 0xC6, 0x61, 0x9C, // ..1...a. | |
| /* 01F8 */ 0x86, 0xEF, 0x1F, 0x3E, 0x2F, 0xC0, 0x38, 0x05, // ...>/.8. | |
| /* 0200 */ 0x78, 0xE4, 0xFE, 0xFF, 0x1F, 0x52, 0x7C, 0x9A, // x....R|. | |
| /* 0208 */ 0xE0, 0x47, 0x0B, 0x9F, 0x26, 0xD8, 0xF5, 0xE0, // .G..&... | |
| /* 0210 */ 0x34, 0x9E, 0x03, 0x3C, 0x9C, 0xB3, 0xF2, 0x61, // 4..<...a | |
| /* 0218 */ 0x02, 0x6C, 0xF7, 0x13, 0x36, 0xA2, 0x77, 0x0B, // .l..6.w. | |
| /* 0220 */ 0x8F, 0x06, 0x7B, 0x0A, 0x00, 0xDF, 0xF9, 0x05, // ..{..... | |
| /* 0228 */ 0x9C, 0x77, 0x0D, 0x36, 0x58, 0x18, 0xE7, 0x17, // .w.6X... | |
| /* 0230 */ 0xE0, 0x71, 0x42, 0xF0, 0x10, 0xF8, 0x41, 0xC2, // .qB...A. | |
| /* 0238 */ 0x43, 0xE0, 0x03, 0x78, 0xFE, 0x38, 0x43, 0x2B, // C..x.8C+ | |
| /* 0240 */ 0x9D, 0x17, 0x72, 0x60, 0xF0, 0xCE, 0x39, 0x30, // ..r`..90 | |
| /* 0248 */ 0x46, 0xC1, 0xF3, 0x3C, 0x36, 0x4C, 0xA0, 0x20, // F..<6L. | |
| /* 0250 */ 0xAF, 0x01, 0x85, 0x7A, 0x16, 0x50, 0x18, 0x9F, // ...z.P.. | |
| /* 0258 */ 0x6A, 0x80, 0xD7, 0xFF, 0xFF, 0x54, 0x03, 0x5C, // j....T.\ | |
| /* 0260 */ 0x0E, 0x07, 0xB8, 0x93, 0x03, 0xDC, 0x7B, 0x01, // ......{. | |
| /* 0268 */ 0xBB, 0x38, 0x3C, 0xD7, 0xC0, 0x15, 0x7D, 0xAE, // .8<...}. | |
| /* 0270 */ 0x81, 0x7A, 0x6F, 0x29, 0x6E, 0x8C, 0xBA, 0xC6, // .zo)n... | |
| /* 0278 */ 0x04, 0x79, 0x14, 0x78, 0xA4, 0x89, 0xF2, 0x3C, // .y.x...< | |
| /* 0280 */ 0xF3, 0x2E, 0x13, 0xE1, 0xD9, 0xC6, 0xD7, 0x1A, // ........ | |
| /* 0288 */ 0x4F, 0x21, 0x8E, 0xAF, 0x35, 0x46, 0x7C, 0x99, // O!..5F|. | |
| /* 0290 */ 0x78, 0xB7, 0x31, 0xEE, 0xC1, 0x3D, 0xD6, 0x3C, // x.1..=.< | |
| /* 0298 */ 0xE4, 0x18, 0xE4, 0x68, 0x22, 0xBC, 0x18, 0x04, // ...h"... | |
| /* 02A0 */ 0x7C, 0xBC, 0xF1, 0xB1, 0x06, 0xBC, 0x62, 0x5E, // |.....b^ | |
| /* 02A8 */ 0x28, 0xB2, 0x70, 0xAC, 0x01, 0x34, 0xFE, 0xFF, // (.p..4.. | |
| /* 02B0 */ 0x8F, 0x35, 0xC0, 0x0D, 0xEB, 0x01, 0x05, 0x7C, // .5.....| | |
| /* 02B8 */ 0x47, 0x06, 0x76, 0x43, 0x81, 0x77, 0x42, 0x01, // G.vC.wB. | |
| /* 02C0 */ 0xFC, 0x24, 0x7E, 0x01, 0xE8, 0xC8, 0xE1, 0xB4, // .$~..... | |
| /* 02C8 */ 0x20, 0xB2, 0xF1, 0x06, 0xF0, 0x29, 0x80, 0xAA, // ....).. | |
| /* 02D0 */ 0x01, 0xD2, 0x34, 0x61, 0x13, 0x4C, 0x4F, 0x2E, // ..4a.LO. | |
| /* 02D8 */ 0x78, 0x1F, 0x09, 0x9C, 0x9B, 0x44, 0xC9, 0x87, // x....D.. | |
| /* 02E0 */ 0x45, 0xE1, 0x9C, 0xF5, 0x20, 0x42, 0x41, 0x0C, // E... BA. | |
| /* 02E8 */ 0xE8, 0x20, 0xC7, 0x09, 0xF4, 0x19, 0xC5, 0x07, // . ...... | |
| /* 02F0 */ 0x91, 0x13, 0x7D, 0x22, 0xF4, 0xA0, 0x3C, 0x8C, // ..}"..<. | |
| /* 02F8 */ 0x77, 0x14, 0x76, 0x02, 0xF1, 0x61, 0xC2, 0x63, // w.v..a.c | |
| /* 0300 */ 0xF7, 0x31, 0x81, 0xFF, 0x63, 0x3C, 0x1B, 0xA3, // .1..c<.. | |
| /* 0308 */ 0x5B, 0x0D, 0x86, 0xFE, 0xFF, 0xE7, 0x14, 0x0E, // [....... | |
| /* 0310 */ 0xE6, 0x83, 0x08, 0x27, 0xA8, 0xEB, 0x26, 0x01, // ...'..&. | |
| /* 0318 */ 0x32, 0x7D, 0x47, 0x05, 0x50, 0x00, 0xF9, 0x5E, // 2}G.P..^ | |
| /* 0320 */ 0xE0, 0x73, 0xC0, 0xB3, 0x01, 0x1B, 0xC3, 0xA3, // .s...... | |
| /* 0328 */ 0x80, 0xD1, 0x8C, 0xCE, 0xC3, 0x4F, 0x16, 0x15, // .....O.. | |
| /* 0330 */ 0x77, 0xB2, 0x14, 0xC4, 0x93, 0x75, 0x94, 0xC9, // w....u.. | |
| /* 0338 */ 0xA2, 0x67, 0xE2, 0x7B, 0x85, 0x67, 0xF4, 0xA6, // .g.{.g.. | |
| /* 0340 */ 0xE5, 0x39, 0x7A, 0xC2, 0xBE, 0x87, 0xC0, 0x3A, // .9z....: | |
| /* 0348 */ 0x0C, 0x84, 0x7C, 0x30, 0xF0, 0x34, 0x0C, 0xE7, // ..|0.4.. | |
| /* 0350 */ 0xC9, 0x72, 0x38, 0x4F, 0x96, 0x8F, 0xC5, 0xD7, // .r8O.... | |
| /* 0358 */ 0x10, 0xF0, 0x09, 0x9C, 0x2D, 0xC8, 0xE1, 0x31, // ....-..1 | |
| /* 0360 */ 0xB1, 0x46, 0x45, 0xAF, 0x42, 0x1E, 0x1E, 0xBF, // .FE.B... | |
| /* 0368 */ 0x1C, 0x78, 0x3E, 0xCF, 0x08, 0x47, 0xF9, 0x24, // .x>..G.$ | |
| /* 0370 */ 0x81, 0xC3, 0x78, 0x26, 0xF1, 0x10, 0x7D, 0x2B, // ..x&..}+ | |
| /* 0378 */ 0x82, 0x35, 0x91, 0x93, 0xF6, 0x6D, 0xE1, 0x64, // .5...m.d | |
| /* 0380 */ 0x83, 0xBE, 0x9E, 0x61, 0x6E, 0x45, 0xB0, 0xFF, // ...anE.. | |
| /* 0388 */ 0xFF, 0xB7, 0x22, 0x38, 0x17, 0x34, 0x98, 0x99, // .."8.4.. | |
| /* 0390 */ 0xEE, 0x55, 0xA8, 0x58, 0xF7, 0x2A, 0x40, 0xEC, // .U.X.*@. | |
| /* 0398 */ 0xB0, 0x5E, 0x7B, 0x7C, 0xB0, 0x82, 0x7B, 0xAF, // .^{|..{. | |
| /* 03A0 */ 0x82, 0x7B, 0xA9, 0x7A, 0x56, 0x38, 0xC6, 0xF0, // .{.zV8.. | |
| /* 03A8 */ 0x0F, 0x53, 0x31, 0x4E, 0xE9, 0xB5, 0xD3, 0x40, // .S1N...@ | |
| /* 03B0 */ 0x61, 0xA2, 0xC4, 0x7B, 0xAF, 0xF2, 0x18, 0xDF, // a..{.... | |
| /* 03B8 */ 0xAB, 0xD8, 0x15, 0x2A, 0x4C, 0xAC, 0x97, 0x2B, // ...*L..+ | |
| /* 03C0 */ 0xA3, 0xBE, 0x4E, 0x84, 0x0B, 0x14, 0x24, 0xD2, // ..N...$. | |
| /* 03C8 */ 0xAB, 0x55, 0x94, 0xC8, 0xF1, 0x0D, 0xF9, 0x5E, // .U.....^ | |
| /* 03D0 */ 0x05, 0x5E, 0x39, 0xF7, 0x2A, 0x90, 0xFD, 0xFF, // .^9.*... | |
| /* 03D8 */ 0xEF, 0x55, 0x80, 0x79, 0xB4, 0xF7, 0x2A, 0x30, // .U.y..*0 | |
| /* 03E0 */ 0x5E, 0x1B, 0xD8, 0x0D, 0x09, 0x16, 0xD0, 0x8B, // ^....... | |
| /* 03E8 */ 0x15, 0x60, 0x28, 0xF3, 0xC5, 0x8A, 0xE6, 0xBD, // .`(..... | |
| /* 03F0 */ 0x58, 0x21, 0xFE, 0xFF, 0xE7, 0x12, 0xA6, 0xE7, // X!...... | |
| /* 03F8 */ 0x62, 0x45, 0xE6, 0x09, 0xFF, 0x66, 0x05, 0x70, // bE...f.p | |
| /* 0400 */ 0xFA, 0xFF, 0x7F, 0xB3, 0x02, 0x8C, 0xDD, 0x8B, // ........ | |
| /* 0408 */ 0x30, 0x47, 0x2B, 0x78, 0x29, 0x6F, 0x56, 0x34, // 0G+x)oV4 | |
| /* 0410 */ 0xCE, 0x32, 0x14, 0x70, 0x41, 0x14, 0xC6, 0x37, // .2.pA..7 | |
| /* 0418 */ 0x2B, 0xC0, 0xD1, 0x75, 0x05, 0x37, 0x64, 0xB8, // +..u.7d. | |
| /* 0420 */ 0x60, 0x51, 0x82, 0xF9, 0x10, 0xE2, 0xE9, 0x1C, // `Q...... | |
| /* 0428 */ 0xF1, 0x43, 0xC2, 0x4B, 0xC0, 0x63, 0x8E, 0x07, // .C.K.c.. | |
| /* 0430 */ 0xFC, 0x40, 0xE0, 0xCB, 0x15, 0x98, 0xFE, 0xFF, // .@...... | |
| /* 0438 */ 0x04, 0x3E, 0xF9, 0x9E, 0xE5, 0xDB, 0xD4, 0x7B, // .>.....{ | |
| /* 0440 */ 0x2F, 0x3F, 0x60, 0xBD, 0x57, 0xF9, 0xF0, 0x1B, // /?`.W... | |
| /* 0448 */ 0xEB, 0x9D, 0xE1, 0xE5, 0xCA, 0x23, 0x89, 0x72, // .....#.r | |
| /* 0450 */ 0x12, 0xA1, 0x7C, 0xB7, 0x7A, 0xAF, 0x32, 0x4A, // ..|.z.2J | |
| /* 0458 */ 0xC4, 0x17, 0x62, 0x9F, 0x82, 0x0D, 0x6D, 0x94, // ..b...m. | |
| /* 0460 */ 0xA7, 0x8A, 0xE8, 0xC6, 0x7B, 0xB9, 0x02, 0xAF, // ....{... | |
| /* 0468 */ 0xA4, 0xCB, 0x15, 0x40, 0x93, 0xE1, 0xBF, 0x5C, // ...@...\ | |
| /* 0470 */ 0x81, 0xEF, 0xE6, 0x80, 0xBD, 0x26, 0xC1, 0xF9, // .....&.. | |
| /* 0478 */ 0xFF, 0x5F, 0x93, 0xF8, 0xF5, 0x0A, 0xF0, 0x93, // ._...... | |
| /* 0480 */ 0xFD, 0x7A, 0x45, 0x73, 0x5F, 0xAF, 0x50, 0xA2, // .zEs_.P. | |
| /* 0488 */ 0x20, 0xA4, 0x08, 0x48, 0x33, 0x05, 0xCF, 0xFD, // ..H3... | |
| /* 0490 */ 0x0A, 0xE0, 0xC4, 0xFF, 0xFF, 0x7E, 0x05, 0x58, // .....~.X | |
| /* 0498 */ 0x0E, 0x77, 0xBF, 0x02, 0x7A, 0xB7, 0x23, 0xF0, // .w..z.#. | |
| /* 04A0 */ 0xA2, 0xBC, 0x1D, 0x61, 0xAF, 0x58, 0xF8, 0x8C, // ...a.X.. | |
| /* 04A8 */ 0x57, 0x2C, 0x1A, 0x66, 0x25, 0x8A, 0xB7, 0x26, // W,.f%..& | |
| /* 04B0 */ 0x0A, 0xE3, 0x2B, 0x16, 0x30, 0xF9, 0xFF, 0x5F, // ..+.0.._ | |
| /* 04B8 */ 0xB1, 0x80, 0xD9, 0x41, 0x14, 0x37, 0x6A, 0xB8, // ...A.7j. | |
| /* 04C0 */ 0x17, 0x27, 0xDF, 0x7A, 0x3C, 0xDF, 0x88, 0xBE, // .'.z<... | |
| /* 04C8 */ 0xC3, 0x60, 0x4E, 0x58, 0x30, 0x6E, 0x58, 0xF0, // .`NX0nX. | |
| /* 04D0 */ 0x87, 0xF4, 0x30, 0xEC, 0x93, 0xC4, 0x3B, 0x96, // ..0...;. | |
| /* 04D8 */ 0x8F, 0x56, 0x06, 0x79, 0x03, 0x7E, 0xB2, 0x7A, // .V.y.~.z | |
| /* 04E0 */ 0xB0, 0x8A, 0x62, 0x84, 0x80, 0xC7, 0xF3, 0x2E, // ..b..... | |
| /* 04E8 */ 0xEC, 0xA3, 0xD5, 0x9B, 0x96, 0x51, 0x62, 0xC7, // .....Qb. | |
| /* 04F0 */ 0xF2, 0x85, 0xEA, 0x59, 0xCB, 0xD7, 0x2C, 0x43, // ...Y..,C | |
| /* 04F8 */ 0xC4, 0x7D, 0x20, 0xF6, 0x0D, 0x0B, 0xB0, 0xFD, // .} ..... | |
| /* 0500 */ 0xFF, 0xBF, 0x61, 0x01, 0x8E, 0x2E, 0x0E, 0xFC, // ..a..... | |
| /* 0508 */ 0xE0, 0x80, 0xBD, 0x61, 0x01, 0x3E, 0x67, 0x0A, // ...a.>g. | |
| /* 0510 */ 0x9E, 0x1B, 0x16, 0xB0, 0xF9, 0xFF, 0xDF, 0xB0, // ........ | |
| /* 0518 */ 0x00, 0xFE, 0xFF, 0xFF, 0x6F, 0x58, 0xC0, 0xE1, // ....oX.. | |
| /* 0520 */ 0x76, 0x85, 0xBD, 0x65, 0x61, 0x6F, 0x2F, 0x64, // v..eao/d | |
| /* 0528 */ 0x15, 0x34, 0xD4, 0x4A, 0x14, 0xFC, 0x7B, 0x65, // .4.J..{e | |
| /* 0530 */ 0x18, 0x7A, 0xC3, 0x02, 0x1C, 0x8D, 0xDB, 0xA3, // .z...... | |
| /* 0538 */ 0x06, 0xC7, 0xD9, 0xE0, 0x49, 0x02, 0x73, 0xAE, // ....I.s. | |
| /* 0540 */ 0xC6, 0xCD, 0xE6, 0xE0, 0x02, 0x47, 0xE8, 0x1D, // .....G.. | |
| /* 0548 */ 0x54, 0x73, 0x67, 0x97, 0x14, 0x18, 0xB7, 0x2C, // Tsg...., | |
| /* 0550 */ 0xB8, 0x97, 0xAA, 0x87, 0x86, 0x28, 0x07, 0xF1, // .....(.. | |
| /* 0558 */ 0x2A, 0xFC, 0x60, 0xF5, 0x28, 0x75, 0x64, 0x8F, // *.`.(ud. | |
| /* 0560 */ 0x57, 0x4F, 0xC3, 0x3E, 0x66, 0xF9, 0x96, 0x65, // WO.>f..e | |
| /* 0568 */ 0xA8, 0x08, 0x6F, 0x59, 0xEC, 0x0C, 0x11, 0x2F, // ..oY.../ | |
| /* 0570 */ 0x56, 0x94, 0x10, 0xEF, 0x15, 0xA1, 0x7D, 0xE7, // V.....}. | |
| /* 0578 */ 0x32, 0xF8, 0xA3, 0xB1, 0x51, 0x83, 0xBE, 0x1C, // 2...Q... | |
| /* 0580 */ 0xBF, 0x65, 0xC1, 0xFB, 0xFF, 0xDF, 0xB2, 0xE0, // .e...... | |
| /* 0588 */ 0x8B, 0xFC, 0xAB, 0xE8, 0x44, 0xE0, 0x5B, 0x16, // ....D.[. | |
| /* 0590 */ 0xC0, 0x8F, 0x60, 0x10, 0x72, 0x32, 0x70, 0xF4, // ..`.r2p. | |
| /* 0598 */ 0x79, 0x01, 0x3F, 0x80, 0x87, 0x11, 0x0F, 0x89, // y.?..... | |
| /* 05A0 */ 0x05, 0x18, 0x38, 0xBD, 0x2F, 0xF9, 0x4C, 0xC1, // ..8./.L. | |
| /* 05A8 */ 0x0F, 0x18, 0x3E, 0x53, 0xB0, 0xEB, 0x41, 0xF4, // ..>S..A. | |
| /* 05B0 */ 0xC7, 0x00, 0x9F, 0x4B, 0x30, 0x83, 0x03, 0xFF, // ...K0... | |
| /* 05B8 */ 0xB5, 0xE2, 0xD0, 0x3D, 0x8A, 0xD7, 0x07, 0x13, // ...=.... | |
| /* 05C0 */ 0x78, 0x70, 0xFC, 0xFF, 0x3F, 0x38, 0xB8, 0x77, // xp..?8.w | |
| /* 05C8 */ 0x86, 0x23, 0xF2, 0x1D, 0xC6, 0x83, 0x03, 0xDB, // .#...... | |
| /* 05D0 */ 0x41, 0x00, 0x38, 0x0C, 0x0E, 0x1F, 0x6A, 0x70, // A.8...jp | |
| /* 05D8 */ 0xE8, 0xF1, 0x18, 0x38, 0xA4, 0xCF, 0x63, 0xEC, // ...8..c. | |
| /* 05E0 */ 0xC2, 0xF0, 0x90, 0xE3, 0xA1, 0x81, 0x0D, 0xD0, // ........ | |
| /* 05E8 */ 0x43, 0x03, 0x96, 0x93, 0x78, 0x0A, 0x39, 0x34, // C...x.94 | |
| /* 05F0 */ 0x30, 0x4B, 0x18, 0x1A, 0x50, 0x8A, 0x37, 0x34, // 0K..P.74 | |
| /* 05F8 */ 0xFA, 0xFF, 0x1F, 0x1A, 0x1F, 0x92, 0x0F, 0x0B, // ........ | |
| /* 0600 */ 0x31, 0x9F, 0x72, 0x22, 0xBC, 0x2F, 0xF8, 0x04, // 1.r"./.. | |
| /* 0608 */ 0xC5, 0xD0, 0x5F, 0x53, 0x7C, 0xBB, 0xF0, 0x4D, // .._S|..M | |
| /* 0610 */ 0x10, 0x37, 0x3E, 0x70, 0x5D, 0x3A, 0x3D, 0x3E, // .7>p]:=> | |
| /* 0618 */ 0xE0, 0x73, 0xE4, 0xF2, 0xF8, 0x70, 0x47, 0x27, // .s...pG' | |
| /* 0620 */ 0x8F, 0x0F, 0x86, 0xCB, 0xAB, 0x0C, 0x39, 0x9A, // ......9. | |
| /* 0628 */ 0xF8, 0x68, 0xC5, 0x86, 0x07, 0xB6, 0x9B, 0x9E, // .h...... | |
| /* 0630 */ 0x87, 0x07, 0x7C, 0xAE, 0x9B, 0x60, 0xBC, 0x42, // ..|..`.B | |
| /* 0638 */ 0xF2, 0x6B, 0x09, 0x8C, 0x13, 0x14, 0xFE, 0xBA, // .k...... | |
| /* 0640 */ 0x09, 0xDE, 0xFF, 0xFF, 0x75, 0x13, 0x78, 0x8E, // ....u.x. | |
| /* 0648 */ 0x82, 0x6B, 0xBD, 0x64, 0xD3, 0x20, 0xAF, 0x1C, // .k.d. .. | |
| /* 0650 */ 0xC5, 0x7A, 0x11, 0x50, 0x18, 0x9F, 0xD9, 0x00, // .z.P.... | |
| /* 0658 */ 0x47, 0x63, 0x7D, 0x66, 0x03, 0xCB, 0xBD, 0x80, // Gc}f.... | |
| /* 0660 */ 0xDD, 0xD8, 0xE0, 0x9E, 0xD6, 0x60, 0xDF, 0x1D, // .....`.. | |
| /* 0668 */ 0x1E, 0xCE, 0x1E, 0xD3, 0x1E, 0xD5, 0x1E, 0xD0, // ........ | |
| /* 0670 */ 0x7C, 0xC4, 0x8E, 0xF1, 0x96, 0x16, 0x24, 0x4E, // |.....$N | |
| /* 0678 */ 0x84, 0xD7, 0x81, 0xA7, 0x35, 0x5F, 0x32, 0xE2, // ....5_2. | |
| /* 0680 */ 0x05, 0x7A, 0x5A, 0x33, 0x46, 0x9C, 0x97, 0x36, // .zZ3F..6 | |
| /* 0688 */ 0x23, 0xBE, 0x52, 0x84, 0x78, 0x58, 0xF3, 0xC9, // #.R.xX.. | |
| /* 0690 */ 0xCD, 0x78, 0x0F, 0x13, 0xE1, 0xC2, 0xBC, 0xB0, // .x...... | |
| /* 0698 */ 0x3D, 0xAD, 0x81, 0xE3, 0xFF, 0x7F, 0x5A, 0x83, // =.....Z. | |
| /* 06A0 */ 0x23, 0xE7, 0x8A, 0x0D, 0xD0, 0xE4, 0xA2, 0x8F, // #....... | |
| /* 06A8 */ 0x3B, 0xA4, 0x80, 0xE5, 0xDA, 0xC0, 0x6E, 0x29, // ;.....n) | |
| /* 06B0 */ 0xF0, 0x2E, 0xD8, 0xC0, 0xF9, 0xFF, 0x7F, 0x44, // .......D | |
| /* 06B8 */ 0x01, 0x5F, 0x96, 0x0B, 0x36, 0xCD, 0x71, 0xC1, // ._..6.q. | |
| /* 06C0 */ 0x46, 0x71, 0x58, 0x0D, 0x90, 0xE6, 0x09, 0xFF, // FqX..... | |
| /* 06C8 */ 0x7A, 0x0D, 0xFE, 0x49, 0xF8, 0x7A, 0x0D, 0xD8, // z..I.z.. | |
| /* 06D0 */ 0xBE, 0xC5, 0xE2, 0xAE, 0xD7, 0xC0, 0xEA, 0xFF, // ........ | |
| /* 06D8 */ 0x7F, 0xBD, 0x06, 0x96, 0x82, 0x47, 0x4A, 0xEF, // .....GJ. | |
| /* 06E0 */ 0xD4, 0xE0, 0xBA, 0x69, 0xE3, 0x41, 0xDF, 0xB4, // ...i.A.. | |
| /* 06E8 */ 0x61, 0x0A, 0xBE, 0x45, 0xD1, 0x28, 0xE4, 0x8A, // a..E.(.. | |
| /* 06F0 */ 0xB6, 0x10, 0x0A, 0xE3, 0x5B, 0x14, 0xE0, 0x08, // ....[... | |
| /* 06F8 */ 0xFB, 0x2D, 0x0A, 0x2C, 0x17, 0xA7, 0xB7, 0x28, // .-.,...( | |
| /* 0700 */ 0xFC, 0x0C, 0x3C, 0x68, 0xDF, 0x75, 0x18, 0xA6, // ..<h.u.. | |
| /* 0708 */ 0xEF, 0xD0, 0xF0, 0x4F, 0x4D, 0xCF, 0x4D, 0x0F, // ...OM.M. | |
| /* 0710 */ 0x4E, 0x0F, 0xCD, 0x3E, 0x48, 0xF9, 0x70, 0xF0, // N..>H.p. | |
| /* 0718 */ 0xFC, 0xF4, 0xFF, 0x8F, 0xF1, 0x5E, 0xE7, 0x9B, // .....^.. | |
| /* 0720 */ 0xD4, 0x6B, 0x94, 0x2F, 0x30, 0xC7, 0x10, 0x31, // .k./0..1 | |
| /* 0728 */ 0xCA, 0xCB, 0xB4, 0x21, 0xE2, 0xF9, 0xD4, 0xE4, // ...!.... | |
| /* 0730 */ 0xB3, 0x42, 0xDC, 0x10, 0x0F, 0xD1, 0x46, 0x88, // .B....F. | |
| /* 0738 */ 0xFA, 0x3C, 0xED, 0x09, 0xBD, 0x46, 0x81, 0x57, // .<...F.W | |
| /* 0740 */ 0xD0, 0x35, 0x0A, 0xA0, 0xC9, 0xFD, 0x08, 0x77, // .5.....w | |
| /* 0748 */ 0x8D, 0x02, 0xCB, 0xBD, 0x81, 0x9D, 0x87, 0xF8, // ........ | |
| /* 0750 */ 0x95, 0xC8, 0xD7, 0x06, 0x18, 0xF7, 0x28, 0x38, // ......(8 | |
| /* 0758 */ 0xFF, 0xFF, 0x7B, 0x14, 0x60, 0x23, 0xCC, 0x3D, // ..{.`#.= | |
| /* 0760 */ 0x8A, 0x06, 0xB9, 0x47, 0xA1, 0x4E, 0x26, 0xBE, // ...G.N&. | |
| /* 0768 */ 0xD4, 0x79, 0xA2, 0xE0, 0x08, 0x7F, 0x91, 0x42, // .y.....B | |
| /* 0770 */ 0xC5, 0x26, 0x51, 0xE8, 0xC3, 0x10, 0x2A, 0xE6, // .&Q...*. | |
| /* 0778 */ 0x61, 0x84, 0x82, 0x18, 0xD0, 0x19, 0x4E, 0x14, // a.....N. | |
| /* 0780 */ 0x68, 0x15, 0x27, 0x0A, 0x72, 0x8B, 0xF1, 0xA4, // h.'.r... | |
| /* 0788 */ 0x1E, 0xA3, 0x00, 0x5F, 0xCB, 0xF4, 0x50, 0x79, // ..._..Py | |
| /* 0790 */ 0xE4, 0xA1, 0x52, 0x10, 0x0F, 0xD5, 0x71, 0x86, // ..R...q. | |
| /* 0798 */ 0x8A, 0x9E, 0xA4, 0xE7, 0x8F, 0xF9, 0xFF, 0x1F, // ........ | |
| /* 07A0 */ 0x1C, 0xB0, 0x07, 0x29, 0x80, 0x17, 0x0A, 0x6D, // ...)...m | |
| /* 07A8 */ 0xFA, 0xD4, 0x68, 0xD4, 0xAA, 0x41, 0x99, 0x1A, // ..h..A.. | |
| /* 07B0 */ 0x65, 0x1A, 0xD4, 0xEA, 0x53, 0xA9, 0x31, 0x63, // e...S.1c | |
| /* 07B8 */ 0xE7, 0x50, 0x4B, 0x3B, 0x4B, 0x50, 0x31, 0x8B, // .PK;KP1. | |
| /* 07C0 */ 0xD1, 0x68, 0x1C, 0x05, 0x84, 0xCA, 0xFE, 0x9B, // .h...... | |
| /* 07C8 */ 0x0B, 0xC4, 0x21, 0x9F, 0x3A, 0x02, 0x74, 0xB0, // ..!.:.t. | |
| /* 07D0 */ 0x17, 0x95, 0x80, 0x2C, 0x6B, 0x6D, 0x02, 0x71, // ...,km.q | |
| /* 07D8 */ 0x7C, 0x13, 0x10, 0x8D, 0x80, 0x48, 0xCB, 0x63, // |....H.c | |
| /* 07E0 */ 0x42, 0x40, 0xCE, 0x0D, 0x22, 0x20, 0xAB, 0x58, // B@.." .X | |
| /* 07E8 */ 0x93, 0x80, 0xAC, 0xF9, 0x01, 0x23, 0x70, 0xEB, // .....#p. | |
| /* 07F0 */ 0xD4, 0x01, 0xC4, 0x52, 0x82, 0xD0, 0x44, 0x0B, // ...R..D. | |
| /* 07F8 */ 0x17, 0xA8, 0xE3, 0x81, 0x68, 0x30, 0x84, 0x46, // ....h0.F | |
| /* 0800 */ 0x40, 0x0E, 0x46, 0x21, 0x20, 0xCB, 0xF8, 0x74, // @.F! ..t | |
| /* 0808 */ 0x0B, 0xDC, 0x02, 0xAC, 0x00, 0x31, 0xF9, 0x20, // .....1. | |
| /* 0810 */ 0x54, 0xB0, 0x17, 0x50, 0xA6, 0x1E, 0x44, 0x40, // T..P..D@ | |
| /* 0818 */ 0x56, 0xBA, 0x56, 0x01, 0x59, 0x37, 0x88, 0x80, // V.V.Y7.. | |
| /* 0820 */ 0xFE, 0xFF, 0x2F, 0x83, 0x32, 0x03, 0xCE, 0x32, // ../.2..2 | |
| /* 0828 */ 0xBA, 0x01, 0x62, 0x0A, 0x1F, 0x0A, 0x02, 0xB1, // ..b..... | |
| /* 0830 */ 0x26, 0x3D, 0xA0, 0x4C, 0x20, 0x88, 0xAE, 0x1C, // &=.L ... | |
| /* 0838 */ 0xC4, 0x0F, 0x10, 0x93, 0x06, 0x22, 0x20, 0xC7, // ....." . | |
| /* 0840 */ 0x39, 0x98, 0x08, 0xDC, 0x71, 0x14, 0x01, 0x52, // 9...q..R | |
| /* 0848 */ 0x47, 0xC3, 0xA5, 0x20, 0x54, 0xFC, 0xF3, 0x44, // G.. T..D | |
| /* 0850 */ 0x20, 0x16, 0x64, 0x09, 0x8C, 0x82, 0xD0, 0x08, // .d..... | |
| /* 0858 */ 0x9A, 0x40, 0x98, 0x3C, 0x4F, 0x20, 0x2C, 0xD4, // .@.<O ,. | |
| /* 0860 */ 0x9F, 0x5C, 0xA7, 0x15, 0xA2, 0x6A, 0x88, 0xD4, // .\...j.. | |
| /* 0868 */ 0x15, 0x08, 0x0B, 0xFC, 0x30, 0xD0, 0x60, 0x9C, // ....0.`. | |
| /* 0870 */ 0x1E, 0x44, 0x40, 0x4E, 0xFA, 0xA7, 0x0A, 0x44, // .D@N...D | |
| /* 0878 */ 0x72, 0x83, 0x08, 0xC8, 0xF9, 0x9F, 0x22, 0x02, // r.....". | |
| /* 0880 */ 0x77, 0xEA, 0xD7, 0x84, 0x86, 0x4F, 0xBE, 0x58, // w....O.X | |
| /* 0888 */ 0x41, 0x88, 0xB8, 0x87, 0x55, 0x50, 0xA2, 0x14, // A...UP.. | |
| /* 0890 */ 0x44, 0x40, 0x56, 0xF6, 0xB4, 0x12, 0x90, 0x75, // D@V....u | |
| /* 0898 */ 0x82, 0x08, 0xC8, 0xFF, 0x7F // ..... | |
| }) | |
| } | |
| Device (WMI2) | |
| { | |
| Name (_HID, EisaId ("PNP0C14") /* Windows Management Instrumentation Device */) // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Name (_WDG, Buffer (0x64) | |
| { | |
| /* 0000 */ 0xF1, 0x24, 0xB4, 0xFC, 0x5A, 0x07, 0x0E, 0x4E, // .$..Z..N | |
| /* 0008 */ 0xBF, 0xC4, 0x62, 0xF3, 0xE7, 0x17, 0x71, 0xFA, // ..b...q. | |
| /* 0010 */ 0x41, 0x37, 0x01, 0x01, 0xE3, 0x5E, 0xBE, 0xE2, // A7...^.. | |
| /* 0018 */ 0xDA, 0x42, 0xDB, 0x49, 0x83, 0x78, 0x1F, 0x52, // .B.I.x.R | |
| /* 0020 */ 0x47, 0x38, 0x82, 0x02, 0x41, 0x38, 0x01, 0x02, // G8..A8.. | |
| /* 0028 */ 0x9A, 0x01, 0x30, 0x74, 0xE9, 0xDC, 0x48, 0x45, // ..0t..HE | |
| /* 0030 */ 0xBA, 0xB0, 0x9F, 0xDE, 0x09, 0x35, 0xCA, 0xFF, // .....5.. | |
| /* 0038 */ 0x41, 0x39, 0x0A, 0x05, 0x03, 0x70, 0xF4, 0x7F, // A9...p.. | |
| /* 0040 */ 0x6C, 0x3B, 0x5E, 0x4E, 0xA2, 0x27, 0xE9, 0x79, // l;^N.'.y | |
| /* 0048 */ 0x82, 0x4A, 0x85, 0xD1, 0x41, 0x41, 0x01, 0x06, // .J..AA.. | |
| /* 0050 */ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, // !...f... | |
| /* 0058 */ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, // ......). | |
| /* 0060 */ 0x42, 0x42, 0x01, 0x00 // BB.. | |
| }) | |
| Name (PREL, Buffer (0x08) | |
| { | |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| }) | |
| Method (WQA7, 1, NotSerialized) | |
| { | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| \WMIS (0x07, 0x00) | |
| PREL [0x00] = \WLS0 | |
| PREL [0x01] = \WLS1 | |
| PREL [0x02] = \WLS2 | |
| PREL [0x03] = \WLS3 | |
| PREL [0x04] = \WLS4 | |
| PREL [0x05] = \WLS5 | |
| PREL [0x06] = \WLS6 | |
| PREL [0x07] = \WLS7 | |
| Release (\_SB.WMI1.MWMI) | |
| Return (PREL) /* \_SB_.WMI2.PREL */ | |
| } | |
| Method (WMA8, 3, NotSerialized) | |
| { | |
| CreateByteField (Arg2, 0x00, PRE0) | |
| CreateByteField (Arg2, 0x01, PRE1) | |
| CreateByteField (Arg2, 0x02, PRE2) | |
| CreateByteField (Arg2, 0x03, PRE3) | |
| CreateByteField (Arg2, 0x04, PRE4) | |
| CreateByteField (Arg2, 0x05, PRE5) | |
| CreateByteField (Arg2, 0x06, PRE6) | |
| CreateByteField (Arg2, 0x07, PRE7) | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| \WLS0 = PRE0 /* \_SB_.WMI2.WMA8.PRE0 */ | |
| \WLS1 = PRE1 /* \_SB_.WMI2.WMA8.PRE1 */ | |
| \WLS2 = PRE2 /* \_SB_.WMI2.WMA8.PRE2 */ | |
| \WLS3 = PRE3 /* \_SB_.WMI2.WMA8.PRE3 */ | |
| \WLS4 = PRE4 /* \_SB_.WMI2.WMA8.PRE4 */ | |
| \WLS5 = PRE5 /* \_SB_.WMI2.WMA8.PRE5 */ | |
| \WLS6 = PRE6 /* \_SB_.WMI2.WMA8.PRE6 */ | |
| \WLS7 = PRE7 /* \_SB_.WMI2.WMA8.PRE7 */ | |
| \WMIS (0x08, 0x00) | |
| Release (\_SB.WMI1.MWMI) | |
| } | |
| Name (ITEM, Package (0x05) | |
| { | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "InhibitEnteringThinkPadSetup" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "MTMSerialConcatenation" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "SwapProductName" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "ComputraceMsgDisable" | |
| }, | |
| Package (0x02) | |
| { | |
| 0x00, | |
| "AtpMsgDisable" | |
| } | |
| }) | |
| Name (VSEL, Package (0x02) | |
| { | |
| Package (0x02) | |
| { | |
| "Disable", | |
| "Enable" | |
| }, | |
| Package (0x02) | |
| { | |
| "Off", | |
| "On" | |
| } | |
| }) | |
| Method (WQA9, 1, NotSerialized) | |
| { | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| If ((\WMIS (0x09, Arg0) != 0x00)) | |
| { | |
| Release (\_SB.WMI1.MWMI) | |
| Return ("") | |
| } | |
| Local0 = DerefOf (ITEM [\WITM]) | |
| Local1 = DerefOf (Local0 [0x00]) | |
| Local2 = DerefOf (Local0 [0x01]) | |
| Concatenate (Local2, ",", Local6) | |
| Local3 = DerefOf (VSEL [Local1]) | |
| Concatenate (Local6, DerefOf (Local3 [\WSEL]), Local7) | |
| Release (\_SB.WMI1.MWMI) | |
| Return (Local7) | |
| } | |
| Method (WMAA, 3, NotSerialized) | |
| { | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| If ((SizeOf (Arg2) == 0x00)) | |
| { | |
| Local0 = 0x02 | |
| } | |
| Else | |
| { | |
| Local0 = \_SB.WMI1.CARG (Arg2) | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \_SB.WMI1.WSET (ITEM, VSEL) | |
| If ((Local0 == 0x00)) | |
| { | |
| Local0 = \WMIS (0x0A, 0x00) | |
| } | |
| } | |
| } | |
| Release (\_SB.WMI1.MWMI) | |
| Return (DerefOf (\_SB.WMI1.RETN [Local0])) | |
| } | |
| Name (WQBB, Buffer (0x0538) | |
| { | |
| /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB.... | |
| /* 0008 */ 0x28, 0x05, 0x00, 0x00, 0xAE, 0x18, 0x00, 0x00, // (....... | |
| /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T | |
| /* 0018 */ 0x98, 0xDE, 0x8B, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B | |
| /* 0020 */ 0x10, 0x0D, 0x10, 0x8A, 0x0D, 0x21, 0x02, 0x0B, // .....!.. | |
| /* 0028 */ 0x83, 0x50, 0x50, 0x18, 0x14, 0xA0, 0x45, 0x41, // .PP...EA | |
| /* 0030 */ 0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, // .....!.. | |
| /* 0038 */ 0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, // ..p.@... | |
| /* 0040 */ 0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, // (r.".... | |
| /* 0048 */ 0x31, 0x10, 0x88, 0x14, 0x40, 0x48, 0x28, 0x84, // 1...@H(. | |
| /* 0050 */ 0x44, 0x00, 0x53, 0x21, 0x70, 0x84, 0xA0, 0x5F, // D.S!p.._ | |
| /* 0058 */ 0x01, 0x08, 0x1D, 0x0A, 0x90, 0x29, 0xC0, 0xA0, // .....).. | |
| /* 0060 */ 0x00, 0xA7, 0x08, 0x22, 0x88, 0xD2, 0xB2, 0x00, // ...".... | |
| /* 0068 */ 0xDD, 0x02, 0x7C, 0x0B, 0xD0, 0x0E, 0x21, 0xB4, // ..|...!. | |
| /* 0070 */ 0xC8, 0x95, 0x0A, 0xB0, 0x08, 0x25, 0x9F, 0x80, // .....%.. | |
| /* 0078 */ 0x92, 0x88, 0x22, 0xD9, 0x78, 0xB2, 0x8D, 0x48, // ..".x..H | |
| /* 0080 */ 0xE6, 0x61, 0x91, 0x83, 0x40, 0x89, 0x19, 0x04, // .a..@... | |
| /* 0088 */ 0x4A, 0x27, 0xAE, 0x6C, 0xE2, 0x6A, 0x10, 0x07, // J'.l.j.. | |
| /* 0090 */ 0x10, 0xE5, 0x3C, 0xA2, 0x24, 0x38, 0xAA, 0x83, // ..<.$8.. | |
| /* 0098 */ 0x88, 0x10, 0xBB, 0x5C, 0x01, 0x92, 0x07, 0x20, // ...\... | |
| /* 00A0 */ 0xCD, 0x13, 0x93, 0xF5, 0x39, 0x68, 0x64, 0x6C, // ....9hdl | |
| /* 00A8 */ 0x04, 0x3C, 0x98, 0x04, 0x10, 0x16, 0x65, 0x9D, // .<....e. | |
| /* 00B0 */ 0x8A, 0x02, 0x83, 0xF2, 0x00, 0x22, 0x39, 0x63, // ....."9c | |
| /* 00B8 */ 0x45, 0x01, 0xDB, 0xEB, 0x44, 0x64, 0x72, 0xA0, // E...Ddr. | |
| /* 00C0 */ 0x54, 0x12, 0x1C, 0x6A, 0x98, 0x9E, 0x5A, 0xF3, // T..j..Z. | |
| /* 00C8 */ 0x13, 0xD3, 0x44, 0x4E, 0xAD, 0xE9, 0x21, 0x0B, // ..DN..!. | |
| /* 00D0 */ 0x92, 0x49, 0x1B, 0x0A, 0x6A, 0xEC, 0x9E, 0xD6, // .I..j... | |
| /* 00D8 */ 0x49, 0x79, 0xA6, 0x11, 0x0F, 0xCA, 0x30, 0x09, // Iy....0. | |
| /* 00E0 */ 0x3C, 0x0A, 0x86, 0xC6, 0x09, 0xCA, 0x82, 0x90, // <....... | |
| /* 00E8 */ 0x83, 0x81, 0xA2, 0x00, 0x4F, 0xC2, 0x73, 0x2C, // ....O.s, | |
| /* 00F0 */ 0x5E, 0x80, 0xF0, 0x11, 0x93, 0xB3, 0x40, 0x8C, // ^.....@. | |
| /* 00F8 */ 0x04, 0x3E, 0x13, 0x78, 0xE4, 0xC7, 0x8C, 0x1D, // .>.x.... | |
| /* 0100 */ 0x51, 0xB8, 0x80, 0xE7, 0x73, 0x0C, 0x91, 0xE3, // Q...s... | |
| /* 0108 */ 0x1E, 0x6A, 0x8C, 0xA3, 0x88, 0x7C, 0x38, 0x0C, // .j...|8. | |
| /* 0110 */ 0xED, 0x74, 0xE3, 0x1C, 0xD8, 0xE9, 0x14, 0x04, // .t...... | |
| /* 0118 */ 0x2E, 0x90, 0x60, 0x3D, 0xCF, 0x59, 0x20, 0xFF, // ..`=.Y . | |
| /* 0120 */ 0xFF, 0x18, 0x07, 0xC1, 0xF0, 0x8E, 0x01, 0x23, // .......# | |
| /* 0128 */ 0x03, 0x42, 0x1E, 0x05, 0x58, 0x1D, 0x96, 0x26, // .B..X..& | |
| /* 0130 */ 0x91, 0xC0, 0xEE, 0x05, 0x68, 0xBC, 0x04, 0x48, // ....h..H | |
| /* 0138 */ 0xE1, 0x20, 0xA5, 0x0C, 0x42, 0x30, 0x8D, 0x09, // . ..B0.. | |
| /* 0140 */ 0xB0, 0x75, 0x68, 0x90, 0x37, 0x01, 0xD6, 0xAE, // .uh.7... | |
| /* 0148 */ 0x02, 0x42, 0x89, 0x74, 0x02, 0x71, 0x42, 0x44, // .B.t.qBD | |
| /* 0150 */ 0x89, 0x18, 0xD4, 0x40, 0x51, 0x6A, 0x43, 0x15, // ...@QjC. | |
| /* 0158 */ 0x4C, 0x67, 0xC3, 0x13, 0x66, 0xDC, 0x10, 0x31, // Lg..f..1 | |
| /* 0160 */ 0x0C, 0x14, 0xB7, 0xFD, 0x41, 0x90, 0x61, 0xE3, // ....A.a. | |
| /* 0168 */ 0xC6, 0xEF, 0x41, 0x9D, 0xD6, 0xD9, 0x1D, 0xD3, // ..A..... | |
| /* 0170 */ 0xAB, 0x82, 0x09, 0x3C, 0xE9, 0x37, 0x84, 0xA7, // ...<.7.. | |
| /* 0178 */ 0x83, 0xA3, 0x38, 0xDA, 0xA8, 0x31, 0x9A, 0x23, // ..8..1.# | |
| /* 0180 */ 0x65, 0xAB, 0xD6, 0xB9, 0xC2, 0x91, 0xE0, 0x51, // e......Q | |
| /* 0188 */ 0xE7, 0x05, 0x9F, 0x0C, 0x3C, 0xB4, 0xC3, 0xF6, // ....<... | |
| /* 0190 */ 0x60, 0xCF, 0xD2, 0x43, 0x38, 0x82, 0x67, 0x86, // `..C8.g. | |
| /* 0198 */ 0x47, 0x02, 0x8F, 0x81, 0xDD, 0x15, 0x7C, 0x08, // G.....|. | |
| /* 01A0 */ 0xF0, 0x19, 0x01, 0xEF, 0x1A, 0x50, 0x97, 0x83, // .....P.. | |
| /* 01A8 */ 0x47, 0x03, 0x36, 0xE9, 0x70, 0x98, 0xF1, 0x7A, // G.6.p..z | |
| /* 01B0 */ 0xEE, 0x9E, 0xBA, 0xCF, 0x18, 0xFC, 0xBC, 0xE1, // ........ | |
| /* 01B8 */ 0xC1, 0xE1, 0x46, 0x7A, 0x32, 0x47, 0x56, 0xAA, // ..Fz2GV. | |
| /* 01C0 */ 0x00, 0xB3, 0xD7, 0x00, 0x1D, 0x25, 0x7C, 0xE0, // .....%|. | |
| /* 01C8 */ 0x60, 0x77, 0x81, 0xA7, 0x00, 0x13, 0x58, 0xFE, // `w....X. | |
| /* 01D0 */ 0x20, 0x50, 0x23, 0x33, 0xB4, 0xC7, 0xFB, 0xDE, // P#3.... | |
| /* 01D8 */ 0x61, 0xC8, 0x27, 0x85, 0xC3, 0x62, 0x62, 0x0F, // a.'..bb. | |
| /* 01E0 */ 0x1E, 0x74, 0x3C, 0xE0, 0xBF, 0x8F, 0x3C, 0x69, // .t<...<i | |
| /* 01E8 */ 0x78, 0xFA, 0x9E, 0xAF, 0x09, 0x06, 0x86, 0x90, // x....... | |
| /* 01F0 */ 0x95, 0xF1, 0xA0, 0x06, 0x62, 0xE8, 0x57, 0x85, // ....b.W. | |
| /* 01F8 */ 0xC3, 0x38, 0x0D, 0x9F, 0x40, 0x7C, 0x0E, 0x08, // .8..@|.. | |
| /* 0200 */ 0x12, 0xE3, 0x98, 0x3C, 0x38, 0xFF, 0xFF, 0x09, // ...<8... | |
| /* 0208 */ 0x1C, 0x6B, 0xE4, 0xF4, 0x9C, 0xE2, 0xF3, 0x04, // .k...... | |
| /* 0210 */ 0x3F, 0x5C, 0xF8, 0x3C, 0xC1, 0x4E, 0x0C, 0xA7, // ?\.<.N.. | |
| /* 0218 */ 0xF1, 0x1C, 0xE0, 0xE1, 0x9C, 0x95, 0x8F, 0x13, // ........ | |
| /* 0220 */ 0xC0, 0x02, 0xE2, 0x75, 0x82, 0x0F, 0x14, 0x3E, // ...u...> | |
| /* 0228 */ 0xEC, 0xA1, 0x79, 0x14, 0x2F, 0x11, 0x6F, 0x0F, // ..y./.o. | |
| /* 0230 */ 0x26, 0x88, 0xF6, 0x10, 0x03, 0xC6, 0x19, 0xE1, // &....... | |
| /* 0238 */ 0xCE, 0x1B, 0x70, 0x4E, 0x31, 0xC0, 0x03, 0xEA, // ..pN1... | |
| /* 0240 */ 0x10, 0x30, 0x87, 0x09, 0x0F, 0x81, 0x0F, 0xE0, // .0...... | |
| /* 0248 */ 0x19, 0xE4, 0x1C, 0x7D, 0xCC, 0x39, 0x33, 0xDC, // ...}.93. | |
| /* 0250 */ 0x71, 0x07, 0x6C, 0xC3, 0xE0, 0x91, 0x2D, 0x80, // q.l...-. | |
| /* 0258 */ 0xB0, 0x38, 0x4F, 0x02, 0x05, 0x7C, 0x1B, 0x50, // .8O..|.P | |
| /* 0260 */ 0x18, 0x1F, 0x6E, 0xC0, 0xFB, 0xFF, 0x3F, 0xDC, // ..n...?. | |
| /* 0268 */ 0x00, 0xD7, 0xF3, 0x01, 0xEE, 0xF8, 0x00, 0xF7, // ........ | |
| /* 0270 */ 0x62, 0xC1, 0x0E, 0x0F, 0x8F, 0x37, 0xC0, 0x60, // b....7.` | |
| /* 0278 */ 0x48, 0x8F, 0x34, 0x6F, 0x35, 0x31, 0x5E, 0x6D, // H.4o51^m | |
| /* 0280 */ 0x42, 0x44, 0x78, 0xA8, 0x79, 0xB7, 0x31, 0x52, // BDx.y.1R | |
| /* 0288 */ 0xBC, 0xC7, 0x1B, 0x76, 0x8D, 0x39, 0x8B, 0x07, // ...v.9.. | |
| /* 0290 */ 0x90, 0x28, 0xC5, 0xA1, 0xE9, 0x62, 0x13, 0x23, // .(...b.# | |
| /* 0298 */ 0xCA, 0x9B, 0x8D, 0x61, 0xDF, 0x74, 0x0C, 0x14, // ...a.t.. | |
| /* 02A0 */ 0x2A, 0x52, 0x84, 0x30, 0x2F, 0x16, 0x21, 0x1E, // *R.0/.!. | |
| /* 02A8 */ 0x6F, 0xC0, 0x2C, 0xE9, 0xA5, 0xA2, 0xCF, 0x81, // o.,..... | |
| /* 02B0 */ 0x8F, 0x37, 0x80, 0x97, 0xFF, 0xFF, 0xF1, 0x06, // .7...... | |
| /* 02B8 */ 0xF0, 0x30, 0x0C, 0x1F, 0x53, 0xC0, 0x76, 0x73, // .0..S.vs | |
| /* 02C0 */ 0x60, 0xF7, 0x14, 0xF8, 0xE7, 0x14, 0xC0, 0x91, // `....... | |
| /* 02C8 */ 0x90, 0x47, 0x80, 0x0E, 0x1E, 0x16, 0x01, 0x22, // .G....." | |
| /* 02D0 */ 0x1B, 0xCF, 0x00, 0x9F, 0x89, 0xA8, 0x40, 0x2A, // ......@* | |
| /* 02D8 */ 0xCD, 0x14, 0x2C, 0xE3, 0x14, 0xAC, 0x4E, 0x88, // ..,...N. | |
| /* 02E0 */ 0x5C, 0x06, 0x85, 0x44, 0x40, 0x68, 0x64, 0x86, // \..D@hd. | |
| /* 02E8 */ 0xF3, 0x21, 0xD1, 0x60, 0x06, 0xF1, 0xF9, 0xC0, // .!.`.... | |
| /* 02F0 */ 0x67, 0x0A, 0x9F, 0x9C, 0xF8, 0xFF, 0xFF, 0xE4, // g....... | |
| /* 02F8 */ 0x04, 0x9E, 0x83, 0xC9, 0x43, 0x05, 0x2C, 0x44, // ....C.,D | |
| /* 0300 */ 0x9F, 0x16, 0x38, 0x9C, 0xCF, 0x2C, 0x1C, 0xCE, // ..8..,.. | |
| /* 0308 */ 0x47, 0x12, 0x7E, 0x80, 0xE4, 0x47, 0x25, 0x70, // G.~..G%p | |
| /* 0310 */ 0x09, 0x3C, 0x34, 0x80, 0x02, 0xC8, 0xF7, 0x03, // .<4..... | |
| /* 0318 */ 0x9F, 0x03, 0x9E, 0x11, 0xD8, 0x1C, 0x1E, 0x09, // ........ | |
| /* 0320 */ 0x7C, 0x20, 0x60, 0xF0, 0x3C, 0xDA, 0xA8, 0xE8, // | `.<... | |
| /* 0328 */ 0xD1, 0xC6, 0xC3, 0xE3, 0x47, 0x06, 0xCF, 0xE7, // ....G... | |
| /* 0330 */ 0x81, 0xE0, 0x28, 0x1F, 0x09, 0x70, 0x18, 0xEF, // ..(..p.. | |
| /* 0338 */ 0x17, 0x1E, 0xA2, 0x4F, 0x39, 0xB0, 0x26, 0x72, // ...O9.&r | |
| /* 0340 */ 0xD4, 0x16, 0x7D, 0x22, 0x10, 0xE8, 0x33, 0x17, // ..}"..3. | |
| /* 0348 */ 0xE6, 0x94, 0x03, 0x9C, 0x82, 0x8F, 0x1E, 0x15, // ........ | |
| /* 0350 */ 0xF5, 0x40, 0x0A, 0xDA, 0x93, 0x82, 0xCF, 0x0A, // .@...... | |
| /* 0358 */ 0x3E, 0x7C, 0xC1, 0xFF, 0xFF, 0x1F, 0xBE, 0xE0, // >|...... | |
| /* 0360 */ 0xCC, 0xEB, 0x65, 0xCD, 0x07, 0x8E, 0x38, 0x67, // ..e...8g | |
| /* 0368 */ 0x71, 0xBA, 0xEF, 0x16, 0xF8, 0x13, 0x29, 0x30, // q.....)0 | |
| /* 0370 */ 0x0B, 0x72, 0x22, 0x45, 0xC1, 0xF8, 0x44, 0x0A, // .r"E..D. | |
| /* 0378 */ 0xD8, 0xBC, 0x05, 0x60, 0xAF, 0x0B, 0x4F, 0x22, // ...`..O" | |
| /* 0380 */ 0x30, 0xCE, 0x11, 0xCF, 0x58, 0x30, 0x0F, 0x55, // 0...X0.U | |
| /* 0388 */ 0xA7, 0xF8, 0x52, 0xF5, 0xC6, 0x10, 0xE1, 0xC9, // ..R..... | |
| /* 0390 */ 0xEA, 0x35, 0xEA, 0x01, 0xCB, 0x60, 0x2F, 0x02, // .5...`/. | |
| /* 0398 */ 0x86, 0x79, 0xC5, 0xF2, 0xE9, 0x2A, 0xC4, 0x03, // .y...*.. | |
| /* 03A0 */ 0x96, 0xCF, 0x5A, 0xD1, 0x42, 0x84, 0x8C, 0x12, // ..Z.B... | |
| /* 03A8 */ 0xEC, 0x15, 0xEB, 0x55, 0xC6, 0x47, 0x2A, 0x83, // ...U.G*. | |
| /* 03B0 */ 0x07, 0x0C, 0x1B, 0x2D, 0x52, 0x84, 0x47, 0x2C, // ...-R.G, | |
| /* 03B8 */ 0xFC, 0xFF, 0xFF, 0x88, 0x05, 0x1E, 0x09, 0x07, // ........ | |
| /* 03C0 */ 0x52, 0x80, 0x2A, 0x03, 0xC7, 0x1D, 0x48, 0x81, // R.*...H. | |
| /* 03C8 */ 0xFD, 0x69, 0x02, 0x7F, 0xBD, 0xF0, 0x78, 0xB0, // .i....x. | |
| /* 03D0 */ 0xFF, 0xFF, 0x73, 0x00, 0xF8, 0x0E, 0x31, 0xC0, // ..s...1. | |
| /* 03D8 */ 0x60, 0xC0, 0x30, 0x0E, 0x31, 0xC0, 0x43, 0xF0, // `.0.1.C. | |
| /* 03E0 */ 0xC9, 0x0C, 0xF4, 0xC7, 0x1D, 0xF8, 0xE3, 0xE0, // ........ | |
| /* 03E8 */ 0x19, 0x9F, 0x1C, 0x26, 0x50, 0x98, 0x13, 0x29, // ...&P..) | |
| /* 03F0 */ 0x0A, 0xC6, 0x27, 0x52, 0xC0, 0xD9, 0xFF, 0xFF, // ..'R.... | |
| /* 03F8 */ 0x70, 0x05, 0x86, 0xE3, 0x0D, 0xF8, 0x6F, 0x33, // p.....o3 | |
| /* 0400 */ 0x3E, 0x84, 0xFA, 0x7C, 0xE3, 0x0B, 0xA9, 0x21, // >..|...! | |
| /* 0408 */ 0x5E, 0x6C, 0xDE, 0xD4, 0x5E, 0x09, 0x5E, 0xDF, // ^l..^.^. | |
| /* 0410 */ 0xD9, 0xB5, 0xE6, 0xF5, 0xDD, 0xA7, 0x82, 0x27, // .......' | |
| /* 0418 */ 0xD1, 0x08, 0x21, 0xA3, 0xBC, 0xE4, 0x18, 0x24, // ..!....$ | |
| /* 0420 */ 0xC4, 0xEB, 0xA8, 0x01, 0x83, 0x05, 0x89, 0x78, // .......x | |
| /* 0428 */ 0x0A, 0x4F, 0x3B, 0x8F, 0x37, 0xE0, 0x15, 0x75, // .O;.7..u | |
| /* 0430 */ 0x20, 0x05, 0xE8, 0xF1, 0xFF, 0x3F, 0x90, 0x02, // ....?.. | |
| /* 0438 */ 0x83, 0x7B, 0x0A, 0xEC, 0x73, 0x0A, 0xE0, 0x29, // .{..s..) | |
| /* 0440 */ 0xF9, 0x89, 0x94, 0xA6, 0x3E, 0x91, 0xA2, 0x15, // ....>... | |
| /* 0448 */ 0x01, 0x69, 0xAA, 0x60, 0x21, 0x98, 0xFE, 0x44, // .i.`!..D | |
| /* 0450 */ 0x4A, 0x0F, 0x06, 0xCE, 0x4D, 0xA2, 0xE4, 0x43, // J...M..C | |
| /* 0458 */ 0xA3, 0x70, 0xCE, 0x7A, 0x20, 0xA1, 0x20, 0x06, // .p.z . . | |
| /* 0460 */ 0x74, 0x90, 0x43, 0x05, 0xFA, 0xAC, 0xE2, 0x03, // t.C..... | |
| /* 0468 */ 0xC9, 0x81, 0x3C, 0x22, 0x7A, 0x58, 0x3E, 0x54, // ..<"zX>T | |
| /* 0470 */ 0xFA, 0xAE, 0xE2, 0x73, 0x88, 0x8F, 0x14, 0x1E, // ...s.... | |
| /* 0478 */ 0xBF, 0x0F, 0x0B, 0xFC, 0x3F, 0xE3, 0xE3, 0x28, // ....?..( | |
| /* 0480 */ 0x03, 0xAF, 0xE6, 0xBC, 0x82, 0x02, 0xF3, 0x69, // .......i | |
| /* 0488 */ 0x14, 0xA3, 0xEB, 0x3E, 0x01, 0x92, 0xFF, 0xFF, // ...>.... | |
| /* 0490 */ 0xFC, 0xB8, 0xBE, 0xC3, 0x28, 0xC8, 0xD1, 0x79, // ....(..y | |
| /* 0498 */ 0xF8, 0xC9, 0xA2, 0xE2, 0x4E, 0x96, 0x82, 0x78, // ....N..x | |
| /* 04A0 */ 0xB2, 0x8E, 0x32, 0x59, 0xF4, 0x4C, 0x7C, 0xBB, // ..2Y.L|. | |
| /* 04A8 */ 0xF0, 0x8C, 0xDE, 0xBB, 0x7C, 0x83, 0x65, 0x37, // ....|.e7 | |
| /* 04B0 */ 0x59, 0x78, 0x97, 0x81, 0x90, 0x8F, 0x06, 0xBE, // Yx...... | |
| /* 04B8 */ 0xC9, 0xC2, 0x1D, 0x8B, 0x2F, 0x23, 0xE0, 0xBB, // ..../#.. | |
| /* 04C0 */ 0xC9, 0x02, 0x5E, 0x47, 0xE3, 0xB3, 0x05, 0x3B, // ..^G...; | |
| /* 04C8 */ 0x85, 0xF8, 0xBA, 0x06, 0x4B, 0xA1, 0x4D, 0x9F, // ....K.M. | |
| /* 04D0 */ 0x1A, 0x8D, 0x5A, 0xFD, 0xFF, 0x1B, 0x94, 0xA9, // ..Z..... | |
| /* 04D8 */ 0x51, 0xA6, 0x41, 0xAD, 0x3E, 0x95, 0x1A, 0x33, // Q.A.>..3 | |
| /* 04E0 */ 0x76, 0xA1, 0xB0, 0xB8, 0x0B, 0x06, 0x95, 0xB4, // v....... | |
| /* 04E8 */ 0x2C, 0x8D, 0xCB, 0x81, 0x40, 0x68, 0x80, 0x5B, // ,...@h.[ | |
| /* 04F0 */ 0xA9, 0x40, 0x1C, 0xFA, 0x0B, 0xA4, 0x53, 0x02, // .@....S. | |
| /* 04F8 */ 0xF9, 0x6A, 0x09, 0xC8, 0x62, 0x57, 0x25, 0x10, // .j..bW%. | |
| /* 0500 */ 0xCB, 0x54, 0x01, 0xD1, 0xC8, 0xDD, 0xC2, 0x20, // .T..... | |
| /* 0508 */ 0x02, 0x72, 0xBC, 0x4F, 0x8D, 0x40, 0x1D, 0x49, // .r.O.@.I | |
| /* 0510 */ 0x07, 0x10, 0x13, 0xE4, 0x63, 0xAC, 0xF4, 0x25, // ....c..% | |
| /* 0518 */ 0x20, 0x10, 0xCB, 0xA6, 0x15, 0xA0, 0xE5, 0x3A, // ......: | |
| /* 0520 */ 0x01, 0x62, 0x61, 0x41, 0x68, 0xC0, 0x5F, 0xB5, // .baAh._. | |
| /* 0528 */ 0x86, 0xE0, 0xB4, 0x20, 0x02, 0x72, 0x32, 0x2D, // ... .r2- | |
| /* 0530 */ 0x40, 0x2C, 0x27, 0x88, 0x80, 0xFC, 0xFF, 0x07 // @,'..... | |
| }) | |
| } | |
| Device (WMI3) | |
| { | |
| Name (_HID, EisaId ("PNP0C14") /* Windows Management Instrumentation Device */) // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Name (_WDG, /**** Is ResourceTemplate, but EndTag not at buffer end ****/ Buffer (0x3C) | |
| { | |
| /* 0000 */ 0x79, 0x36, 0x4D, 0x8F, 0x9E, 0x74, 0x79, 0x44, // y6M..tyD | |
| /* 0008 */ 0x9B, 0x16, 0xC6, 0x26, 0x01, 0xFD, 0x25, 0xF0, // ...&..%. | |
| /* 0010 */ 0x41, 0x42, 0x01, 0x02, 0x69, 0xE8, 0xD2, 0x85, // AB..i... | |
| /* 0018 */ 0x5A, 0x36, 0xCE, 0x4A, 0xA4, 0xD3, 0xCD, 0x69, // Z6.J...i | |
| /* 0020 */ 0x2B, 0x16, 0x98, 0xA0, 0x41, 0x43, 0x01, 0x02, // +...AC.. | |
| /* 0028 */ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, // !...f... | |
| /* 0030 */ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, // ......). | |
| /* 0038 */ 0x42, 0x43, 0x01, 0x00 // BC.. | |
| }) | |
| Method (WMAB, 3, NotSerialized) | |
| { | |
| CreateByteField (Arg2, 0x00, ASS0) | |
| CreateWordField (Arg2, 0x01, ASS1) | |
| CreateByteField (Arg2, 0x03, ASS2) | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| \WASB = ASS0 /* \_SB_.WMI3.WMAB.ASS0 */ | |
| \WASI = ASS1 /* \_SB_.WMI3.WMAB.ASS1 */ | |
| \WASD = ASS2 /* \_SB_.WMI3.WMAB.ASS2 */ | |
| \WMIS (0x0B, 0x00) | |
| Local0 = \WASS | |
| Release (\_SB.WMI1.MWMI) | |
| Return (Local0) | |
| } | |
| Method (WMAC, 3, NotSerialized) | |
| { | |
| CreateByteField (Arg2, 0x00, ASS0) | |
| CreateWordField (Arg2, 0x01, ASS1) | |
| Acquire (\_SB.WMI1.MWMI, 0xFFFF) | |
| \WASB = ASS0 /* \_SB_.WMI3.WMAC.ASS0 */ | |
| \WASI = ASS1 /* \_SB_.WMI3.WMAC.ASS1 */ | |
| \WMIS (0x0C, Arg1) | |
| Local0 = \WASS | |
| Release (\_SB.WMI1.MWMI) | |
| Return (Local0) | |
| } | |
| Name (WQBC, Buffer (0x040A) | |
| { | |
| /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, // FOMB.... | |
| /* 0008 */ 0xFA, 0x03, 0x00, 0x00, 0x32, 0x12, 0x00, 0x00, // ....2... | |
| /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, // DS...}.T | |
| /* 0018 */ 0x98, 0xC3, 0x88, 0x00, 0x01, 0x06, 0x18, 0x42, // .......B | |
| /* 0020 */ 0x10, 0x07, 0x10, 0x8A, 0x0D, 0x21, 0x02, 0x0B, // .....!.. | |
| /* 0028 */ 0x83, 0x50, 0x50, 0x18, 0x14, 0xA0, 0x45, 0x41, // .PP...EA | |
| /* 0030 */ 0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, // .....!.. | |
| /* 0038 */ 0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, // ..p.@... | |
| /* 0040 */ 0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, // (r.".... | |
| /* 0048 */ 0x31, 0x10, 0x88, 0x14, 0x40, 0x48, 0x28, 0x84, // 1...@H(. | |
| /* 0050 */ 0x44, 0x00, 0x53, 0x21, 0x70, 0x84, 0xA0, 0x5F, // D.S!p.._ | |
| /* 0058 */ 0x01, 0x08, 0x1D, 0x0A, 0x90, 0x29, 0xC0, 0xA0, // .....).. | |
| /* 0060 */ 0x00, 0xA7, 0x08, 0x22, 0x88, 0xD2, 0xB2, 0x00, // ...".... | |
| /* 0068 */ 0xDD, 0x02, 0x7C, 0x0B, 0xD0, 0x0E, 0x21, 0xB4, // ..|...!. | |
| /* 0070 */ 0x58, 0x07, 0x11, 0x21, 0xD2, 0x31, 0x34, 0x29, // X..!.14) | |
| /* 0078 */ 0x40, 0xA2, 0x00, 0x8B, 0x02, 0x64, 0xC3, 0xC8, // @....d.. | |
| /* 0080 */ 0x36, 0x22, 0x99, 0x87, 0x45, 0x0E, 0x02, 0x25, // 6"..E..% | |
| /* 0088 */ 0x66, 0x10, 0x28, 0x9D, 0xE0, 0xB2, 0x89, 0xAB, // f.(..... | |
| /* 0090 */ 0x41, 0x9C, 0x4C, 0x94, 0xF3, 0x88, 0x92, 0xE0, // A.L..... | |
| /* 0098 */ 0xA8, 0x0E, 0x22, 0x42, 0xEC, 0x72, 0x05, 0x48, // .."B.r.H | |
| /* 00A0 */ 0x1E, 0x80, 0x34, 0x4F, 0x4C, 0xD6, 0xE7, 0xA0, // ..4OL... | |
| /* 00A8 */ 0x91, 0xB1, 0x11, 0xF0, 0x94, 0x1A, 0x40, 0x58, // ......@X | |
| /* 00B0 */ 0xA0, 0x75, 0x2A, 0xE0, 0x7A, 0x0D, 0x43, 0x3D, // .u*.z.C= | |
| /* 00B8 */ 0x80, 0x48, 0xCE, 0x58, 0x51, 0xC0, 0xF6, 0x3A, // .H.XQ..: | |
| /* 00C0 */ 0x11, 0x8D, 0xEA, 0x40, 0x99, 0x24, 0x38, 0xD4, // ...@.$8. | |
| /* 00C8 */ 0x30, 0x3D, 0xB5, 0xE6, 0x27, 0xA6, 0x89, 0x9C, // 0=..'... | |
| /* 00D0 */ 0x5A, 0xD3, 0x43, 0x16, 0x24, 0x93, 0x36, 0x14, // Z.C.$.6. | |
| /* 00D8 */ 0xD4, 0xD8, 0x3D, 0xAD, 0x93, 0xF2, 0x4C, 0x23, // ..=...L# | |
| /* 00E0 */ 0x1E, 0x94, 0x61, 0x12, 0x78, 0x14, 0x0C, 0x8D, // ..a.x... | |
| /* 00E8 */ 0x13, 0x94, 0x75, 0x22, 0xA0, 0x03, 0xE5, 0x80, // ..u".... | |
| /* 00F0 */ 0x27, 0xE1, 0x39, 0x16, 0x2F, 0x40, 0xF8, 0x88, // '.9./@.. | |
| /* 00F8 */ 0xC9, 0xB4, 0x4D, 0xE0, 0x33, 0x81, 0x87, 0x79, // ..M.3..y | |
| /* 0100 */ 0xCC, 0xD8, 0x11, 0x85, 0x0B, 0x78, 0x3E, 0xC7, // .....x>. | |
| /* 0108 */ 0x10, 0x39, 0xEE, 0xA1, 0xC6, 0x38, 0x8A, 0xC8, // .9...8.. | |
| /* 0110 */ 0x47, 0x60, 0x24, 0x03, 0xC5, 0x2B, 0x08, 0x89, // G`$..+.. | |
| /* 0118 */ 0x80, 0xF8, 0x76, 0x70, 0x70, 0x91, 0xFC, 0xFF, // ..vpp... | |
| /* 0120 */ 0x47, 0x89, 0x11, 0x2A, 0xC6, 0xDB, 0x00, 0x6E, // G..*...n | |
| /* 0128 */ 0x5E, 0x09, 0x8A, 0x1E, 0x07, 0x4A, 0x06, 0x84, // ^....J.. | |
| /* 0130 */ 0x3C, 0x0A, 0xB0, 0x7A, 0x28, 0x20, 0x04, 0x16, // <..z( .. | |
| /* 0138 */ 0x27, 0x40, 0xE3, 0x38, 0x05, 0xD3, 0x99, 0x00, // '@.8.... | |
| /* 0140 */ 0x6D, 0x02, 0xBC, 0x09, 0x30, 0x27, 0xC0, 0x16, // m...0'.. | |
| /* 0148 */ 0x86, 0x80, 0x82, 0x9C, 0x59, 0x94, 0x20, 0x11, // ....Y. . | |
| /* 0150 */ 0x42, 0x31, 0x88, 0x0A, 0x05, 0x18, 0x43, 0x14, // B1....C. | |
| /* 0158 */ 0xCA, 0x3B, 0x41, 0x8C, 0xCA, 0x20, 0x74, 0x82, // .;A.. t. | |
| /* 0160 */ 0x08, 0x14, 0x3D, 0x78, 0x98, 0xD6, 0x40, 0x74, // ..=x..@t | |
| /* 0168 */ 0x89, 0xF0, 0xC8, 0xB1, 0x47, 0x00, 0x9F, 0x19, // ....G... | |
| /* 0170 */ 0xCE, 0xE9, 0x04, 0x1F, 0x01, 0xDE, 0x16, 0x4C, // .......L | |
| /* 0178 */ 0xE0, 0x79, 0xBF, 0x24, 0x1C, 0x6A, 0xD8, 0x03, // .y.$.j.. | |
| /* 0180 */ 0x8E, 0x1A, 0xE3, 0x28, 0x12, 0x58, 0xD0, 0x33, // ...(.X.3 | |
| /* 0188 */ 0x42, 0x16, 0x40, 0x14, 0x09, 0x1E, 0x75, 0x64, // B.@...ud | |
| /* 0190 */ 0xF0, 0xE1, 0xC0, 0x23, 0x3B, 0x72, 0xCF, 0xF0, // ...#;r.. | |
| /* 0198 */ 0x04, 0x82, 0x1C, 0xC2, 0x11, 0x3C, 0x36, 0x3C, // .....<6< | |
| /* 01A0 */ 0x15, 0x78, 0x0C, 0xEC, 0xBA, 0xE0, 0x73, 0x80, // .x....s. | |
| /* 01A8 */ 0x8F, 0x09, 0x78, 0xD7, 0x80, 0x9A, 0xF3, 0xD3, // ..x..... | |
| /* 01B0 */ 0x01, 0x9B, 0x72, 0x38, 0xCC, 0x70, 0x3D, 0xFD, // ..r8.p=. | |
| /* 01B8 */ 0x70, 0x27, 0x70, 0xD2, 0x06, 0x64, 0xB3, 0xF3, // p'p..d.. | |
| /* 01C0 */ 0xE0, 0x70, 0xE3, 0x3C, 0x99, 0x23, 0x2B, 0x55, // .p.<.#+U | |
| /* 01C8 */ 0x80, 0xD9, 0x13, 0x82, 0x4E, 0x13, 0x3E, 0x73, // ....N.>s | |
| /* 01D0 */ 0xB0, 0xBB, 0xC0, 0xF9, 0xF4, 0x0C, 0x49, 0xE4, // ......I. | |
| /* 01D8 */ 0x0F, 0x02, 0x35, 0x32, 0x43, 0xFB, 0x2C, 0xF0, // ..52C.,. | |
| /* 01E0 */ 0xEA, 0x61, 0xC8, 0x87, 0x85, 0xC3, 0x62, 0x62, // .a....bb | |
| /* 01E8 */ 0xCF, 0x1E, 0x74, 0x3C, 0xE0, 0x3F, 0x25, 0x3C, // ..t<.?%< | |
| /* 01F0 */ 0x6C, 0x78, 0xFA, 0x9E, 0xAF, 0x09, 0xA2, 0x3D, // lx.....= | |
| /* 01F8 */ 0x8F, 0x80, 0xE1, 0xFF, 0x7F, 0x1E, 0x81, 0x39, // .......9 | |
| /* 0200 */ 0x9C, 0x07, 0x84, 0x27, 0x07, 0x76, 0x80, 0xC0, // ...'.v.. | |
| /* 0208 */ 0x1C, 0x48, 0x80, 0xC9, 0xF9, 0x02, 0x77, 0x28, // .H....w( | |
| /* 0210 */ 0xF0, 0x10, 0xF8, 0x00, 0x1E, 0x25, 0xCE, 0xD1, // .....%.. | |
| /* 0218 */ 0x4A, 0x67, 0x86, 0x3C, 0xB9, 0x80, 0x2D, 0xFB, // Jg.<..-. | |
| /* 0220 */ 0x1B, 0x40, 0x07, 0x0F, 0xE7, 0x06, 0x91, 0x8D, // .@...... | |
| /* 0228 */ 0x57, 0x80, 0x09, 0x74, 0x38, 0xB1, 0x1E, 0x20, // W..t8.. | |
| /* 0230 */ 0x4D, 0x14, 0x0C, 0x04, 0xD3, 0xD3, 0x6B, 0x00, // M.....k. | |
| /* 0238 */ 0x3E, 0x15, 0x38, 0x37, 0x89, 0x92, 0x0F, 0x8C, // >.87.... | |
| /* 0240 */ 0xC2, 0x39, 0xEB, 0x79, 0x84, 0x82, 0x18, 0xD0, // .9.y.... | |
| /* 0248 */ 0x41, 0x20, 0xE4, 0xE4, 0xA0, 0x80, 0x3A, 0xAA, // A ....:. | |
| /* 0250 */ 0xF8, 0x3C, 0x72, 0xAA, 0x0F, 0x3D, 0x9E, 0x94, // .<r..=.. | |
| /* 0258 */ 0x47, 0xE1, 0xAB, 0x8A, 0x0F, 0x21, 0x3E, 0x4F, // G....!>O | |
| /* 0260 */ 0x78, 0xF4, 0x3E, 0x29, 0xF0, 0xEF, 0x8C, 0xAF, // x.>).... | |
| /* 0268 */ 0x0E, 0x46, 0xB7, 0x9A, 0xE3, 0x0A, 0x0A, 0xCC, // .F...... | |
| /* 0270 */ 0x67, 0x11, 0x4E, 0x50, 0xD7, 0x6D, 0x01, 0xFA, // g.NP.m.. | |
| /* 0278 */ 0x29, 0xE0, 0x08, 0x3C, 0x94, 0x77, 0x92, 0xC7, // )..<.w.. | |
| /* 0280 */ 0x90, 0x04, 0xF5, 0x9D, 0x16, 0x40, 0x01, 0xE4, // .....@.. | |
| /* 0288 */ 0x9B, 0x81, 0x4F, 0x02, 0x21, 0xFE, 0xFF, 0x4F, // ..O.!..O | |
| /* 0290 */ 0x07, 0x1E, 0xC3, 0xC3, 0x80, 0xD1, 0x8C, 0xCE, // ........ | |
| /* 0298 */ 0xC3, 0x4F, 0x16, 0x15, 0x77, 0xB2, 0x14, 0xC4, // .O..w... | |
| /* 02A0 */ 0x93, 0x75, 0x94, 0xC9, 0xA2, 0x67, 0xE2, 0xAB, // .u...g.. | |
| /* 02A8 */ 0x85, 0x27, 0x74, 0x4A, 0x41, 0xCE, 0xD1, 0x13, // .'tJA... | |
| /* 02B0 */ 0xF6, 0x55, 0x04, 0xD6, 0xF9, 0x20, 0xE4, 0x8B, // .U... .. | |
| /* 02B8 */ 0x81, 0xA7, 0x61, 0x38, 0x4F, 0x96, 0xC3, 0x79, // ..a8O..y | |
| /* 02C0 */ 0xB2, 0x7C, 0x2C, 0xBE, 0x6A, 0xC0, 0x1F, 0x2D, // .|,.j..- | |
| /* 02C8 */ 0x96, 0xA0, 0xC0, 0xD9, 0x82, 0x1C, 0x1E, 0x13, // ........ | |
| /* 02D0 */ 0x6F, 0x54, 0xF4, 0x46, 0xE4, 0xE1, 0xF1, 0xCB, // oT.F.... | |
| /* 02D8 */ 0x81, 0xE7, 0xF3, 0x8C, 0x70, 0x94, 0x6F, 0x12, // ....p.o. | |
| /* 02E0 */ 0x38, 0x8C, 0xC7, 0x12, 0x0F, 0xD1, 0x97, 0x23, // 8......# | |
| /* 02E8 */ 0x58, 0x13, 0x39, 0x69, 0xDF, 0x16, 0x4E, 0x36, // X.9i..N6 | |
| /* 02F0 */ 0xE8, 0x4B, 0x10, 0xBB, 0x1C, 0x01, 0xBF, 0x88, // .K...... | |
| /* 02F8 */ 0x26, 0x86, 0xC1, 0x22, 0x2D, 0x45, 0x11, 0x17, // &.."-E.. | |
| /* 0300 */ 0x45, 0x61, 0x7C, 0xC5, 0x82, 0xFD, 0xFF, 0xBF, // Ea|..... | |
| /* 0308 */ 0x62, 0x01, 0x16, 0x04, 0x0F, 0x1B, 0x34, 0x87, // b.....4. | |
| /* 0310 */ 0x83, 0x97, 0x1E, 0x36, 0x6B, 0x38, 0x07, 0x99, // ...6k8.. | |
| /* 0318 */ 0xD3, 0xF1, 0x48, 0x4E, 0x1B, 0xC6, 0x1D, 0x0B, // ..HN.... | |
| /* 0320 */ 0xFE, 0x9D, 0xEA, 0xA9, 0xCA, 0xD3, 0x8A, 0xF2, // ........ | |
| /* 0328 */ 0x64, 0xF5, 0x7A, 0xE5, 0x63, 0x96, 0xA1, 0xCE, // d.z.c... | |
| /* 0330 */ 0xE0, 0x1D, 0xCB, 0xB7, 0x3C, 0x4F, 0x21, 0x4A, // ....<O!J | |
| /* 0338 */ 0x9C, 0x97, 0x2D, 0x76, 0xC7, 0x32, 0x48, 0x50, // ..-v.2HP | |
| /* 0340 */ 0x23, 0x3F, 0x68, 0x31, 0x94, 0xE0, 0xF1, 0xDE, // #?h1.... | |
| /* 0348 */ 0xB1, 0x00, 0x6F, 0xFF, 0xFF, 0x3B, 0x16, 0x60, // ..o..;.` | |
| /* 0350 */ 0xFC, 0x04, 0xC1, 0x09, 0x7C, 0xC7, 0x02, 0x1C, // ....|... | |
| /* 0358 */ 0xC5, 0x7E, 0x37, 0xE8, 0x4A, 0x45, 0xEE, 0x58, // .~7.JE.X | |
| /* 0360 */ 0x28, 0x0E, 0xAB, 0xB9, 0x63, 0x41, 0x9C, 0x28, // (...cA.( | |
| /* 0368 */ 0xE6, 0x8A, 0x05, 0x86, 0xFF, 0xFF, 0x15, 0x0B, // ........ | |
| /* 0370 */ 0xE0, 0x75, 0xC0, 0x2B, 0x16, 0x68, 0xFE, 0xFF, // .u.+.h.. | |
| /* 0378 */ 0x57, 0x2C, 0xF0, 0x5E, 0x8E, 0x80, 0xDF, 0x09, // W,.^.... | |
| /* 0380 */ 0xD1, 0x77, 0x0D, 0x7E, 0x9A, 0xB6, 0xA2, 0xBB, // .w.~.... | |
| /* 0388 */ 0x06, 0x94, 0x19, 0xBE, 0x07, 0xF9, 0xB0, 0x13, // ........ | |
| /* 0390 */ 0x2C, 0xD2, 0xA3, 0x8D, 0x6F, 0x49, 0xE1, 0x7C, // ,...oI.| | |
| /* 0398 */ 0xDB, 0x00, 0xD8, 0xF2, 0xFF, 0xBF, 0x6D, 0x00, // ......m. | |
| /* 03A0 */ 0x4C, 0x19, 0xBF, 0x6F, 0x1B, 0xC0, 0x4F, 0xA1, // L..o..O. | |
| /* 03A8 */ 0x4D, 0x9F, 0x1A, 0x8D, 0x5A, 0x35, 0x28, 0x53, // M...Z5(S | |
| /* 03B0 */ 0xA3, 0x4C, 0x83, 0x5A, 0x7D, 0x2A, 0x35, 0x66, // .L.Z}*5f | |
| /* 03B8 */ 0x4C, 0xC9, 0xC1, 0xCE, 0x77, 0x0C, 0x2A, 0x6C, // L...w.*l | |
| /* 03C0 */ 0x65, 0x1A, 0x9A, 0x63, 0x81, 0xD0, 0x10, 0xC7, // e..c.... | |
| /* 03C8 */ 0x26, 0x19, 0x01, 0x51, 0x22, 0x10, 0x01, 0x59, // &..Q"..Y | |
| /* 03D0 */ 0xFD, 0x6F, 0x42, 0x40, 0xCE, 0x02, 0x22, 0x20, // .oB@.." | |
| /* 03D8 */ 0x2B, 0x58, 0x9A, 0xC0, 0x9D, 0xFF, 0xD8, 0x28, // +X.....( | |
| /* 03E0 */ 0x40, 0xA2, 0x02, 0x84, 0x29, 0x7D, 0x93, 0x09, // @...)}.. | |
| /* 03E8 */ 0xD4, 0xB2, 0x41, 0x04, 0xF4, 0xFF, 0x3F, 0x42, // ..A...?B | |
| /* 03F0 */ 0xD9, 0x00, 0x62, 0x82, 0x41, 0x04, 0x64, 0x91, // ..b.A.d. | |
| /* 03F8 */ 0x3E, 0x80, 0x98, 0x62, 0x10, 0x01, 0x59, 0xDD, // >..b..Y. | |
| /* 0400 */ 0xA3, 0x40, 0x40, 0xD6, 0x0A, 0x22, 0x20, 0xFF, // .@@.." . | |
| /* 0408 */ 0xFF, 0x01 // .. | |
| }) | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Mutex (BFWM, 0x07) | |
| Method (MHCF, 1, NotSerialized) | |
| { | |
| Local0 = \BFWC (Arg0) | |
| Return (Local0) | |
| } | |
| Method (MHPF, 1, NotSerialized) | |
| { | |
| Name (RETB, Buffer (0x25){}) | |
| Acquire (BFWM, 0xFFFF) | |
| If ((SizeOf (Arg0) <= 0x25)) | |
| { | |
| \BFWB = Arg0 | |
| If (\BFWP ()) | |
| { | |
| \_SB.PCI0.LPC.EC.CHKS () | |
| \BFWL () | |
| } | |
| RETB = \BFWB | |
| } | |
| Release (BFWM) | |
| Return (RETB) /* \_SB_.PCI0.LPC_.EC__.HKEY.MHPF.RETB */ | |
| } | |
| Method (MHIF, 1, NotSerialized) | |
| { | |
| Name (RETB, Buffer (0x0A){}) | |
| Acquire (BFWM, 0xFFFF) | |
| \BFWG (Arg0) | |
| RETB = \BFWB | |
| Release (BFWM) | |
| Return (RETB) /* \_SB_.PCI0.LPC_.EC__.HKEY.MHIF.RETB */ | |
| } | |
| Method (MHDM, 1, NotSerialized) | |
| { | |
| \BDMC (Arg0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (PSSG, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x00, 0x00)) | |
| } | |
| Method (PSSS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x01, Arg0)) | |
| } | |
| Method (PSBS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x02, Arg0)) | |
| } | |
| Method (BICG, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x03, Arg0)) | |
| } | |
| Method (BICS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x04, Arg0)) | |
| } | |
| Method (BCTG, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x05, Arg0)) | |
| } | |
| Method (BCCS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x06, Arg0)) | |
| } | |
| Method (BCSG, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x07, Arg0)) | |
| } | |
| Method (BCSS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x08, Arg0)) | |
| } | |
| Method (BDSG, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x09, Arg0)) | |
| } | |
| Method (BDSS, 1, NotSerialized) | |
| { | |
| Return (\PSIF (0x0A, Arg0)) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (GILN, 0, NotSerialized) | |
| { | |
| Return ((0x02 | \ILNF)) | |
| } | |
| Method (SILN, 1, NotSerialized) | |
| { | |
| If ((0x01 == Arg0)) | |
| { | |
| \ILNF = 0x01 | |
| BBLS = 0x00 | |
| Return (0x00) | |
| } | |
| ElseIf ((0x02 == Arg0)) | |
| { | |
| \ILNF = 0x00 | |
| BBLS = 0x01 | |
| Return (0x00) | |
| } | |
| Else | |
| { | |
| Return (0x01) | |
| } | |
| } | |
| Method (GLSI, 0, NotSerialized) | |
| { | |
| If (\H8DR) | |
| { | |
| Return ((0x02 + \_SB.PCI0.LPC.EC.HPLD)) | |
| } | |
| ElseIf ((\RBEC (0x46) & 0x04)) | |
| { | |
| Return (0x03) | |
| } | |
| Else | |
| { | |
| Return (0x02) | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (GDLN, 0, NotSerialized) | |
| { | |
| Return ((0x02 | \PLUX)) | |
| } | |
| Method (SDLN, 1, NotSerialized) | |
| { | |
| If ((0x01 == Arg0)) | |
| { | |
| \PLUX = 0x01 | |
| Return (0x00) | |
| } | |
| ElseIf ((0x02 == Arg0)) | |
| { | |
| \PLUX = 0x00 | |
| Return (0x00) | |
| } | |
| Else | |
| { | |
| Return (0x01) | |
| } | |
| } | |
| } | |
| Name (\VHCC, 0x00) | |
| Scope (\_SB.PCI0.PEG.VID) | |
| { | |
| Method (ISOP, 0, NotSerialized) | |
| { | |
| Return ((VDSP && (VIGD && VDSC))) | |
| } | |
| } | |
| Scope (\_SB.PCI0) | |
| { | |
| Name (OTM, "OTMACPI 2009-Nov-12 18:18:51") | |
| } | |
| Scope (\_SB.PCI0.PEG.VID) | |
| { | |
| Method (GOBT, 1, NotSerialized) | |
| { | |
| Name (OPVK, Buffer (0xE6) | |
| { | |
| /* 0000 */ 0xE4, 0xB8, 0x4F, 0x51, 0x50, 0x72, 0x8A, 0xC2, // ..OQPr.. | |
| /* 0008 */ 0x4B, 0x56, 0xE6, 0x00, 0x00, 0x00, 0x01, 0x00, // KV...... | |
| /* 0010 */ 0x31, 0x34, 0x38, 0x35, 0x39, 0x37, 0x34, 0x35, // 14859745 | |
| /* 0018 */ 0x36, 0x39, 0x38, 0x35, 0x47, 0x65, 0x6E, 0x75, // 6985Genu | |
| /* 0020 */ 0x69, 0x6E, 0x65, 0x20, 0x4E, 0x56, 0x49, 0x44, // ine NVID | |
| /* 0028 */ 0x49, 0x41, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, // IA Certi | |
| /* 0030 */ 0x66, 0x69, 0x65, 0x64, 0x20, 0x4F, 0x70, 0x74, // fied Opt | |
| /* 0038 */ 0x69, 0x6D, 0x75, 0x73, 0x20, 0x52, 0x65, 0x61, // imus Rea | |
| /* 0040 */ 0x64, 0x79, 0x20, 0x4D, 0x6F, 0x74, 0x68, 0x65, // dy Mothe | |
| /* 0048 */ 0x72, 0x62, 0x6F, 0x61, 0x72, 0x64, 0x20, 0x66, // rboard f | |
| /* 0050 */ 0x6F, 0x72, 0x20, 0x36, 0x38, 0x38, 0x33, 0x32, // or 68832 | |
| /* 0058 */ 0x35, 0x6E, 0x6F, 0x7A, 0x6F, 0x6D, 0x69, 0x32, // 5nozomi2 | |
| /* 0060 */ 0x31, 0x44, 0x35, 0x20, 0x20, 0x20, 0x20, 0x20, // 1D5 | |
| /* 0068 */ 0x2D, 0x20, 0x40, 0x4A, 0x20, 0x24, 0x55, 0x27, // - @J $U' | |
| /* 0070 */ 0x5C, 0x22, 0x54, 0x20, 0x29, 0x5F, 0x47, 0x42, // \"T )_GB | |
| /* 0078 */ 0x20, 0x50, 0x2F, 0x41, 0x4F, 0x5C, 0x37, 0x22, // P/AO\7" | |
| /* 0080 */ 0x3D, 0x46, 0x37, 0x39, 0x4B, 0x37, 0x2B, 0x5F, // =F79K7+_ | |
| /* 0088 */ 0x3F, 0x4B, 0x48, 0x5C, 0x5F, 0x46, 0x58, 0x48, // ?KH\_FXH | |
| /* 0090 */ 0x5F, 0x44, 0x57, 0x32, 0x26, 0x4A, 0x46, 0x50, // _DW2&JFP | |
| /* 0098 */ 0x52, 0x25, 0x24, 0x2F, 0x46, 0x24, 0x20, 0x2D, // R%$/F$ - | |
| /* 00A0 */ 0x20, 0x43, 0x6F, 0x70, 0x79, 0x72, 0x69, 0x67, // Copyrig | |
| /* 00A8 */ 0x68, 0x74, 0x20, 0x32, 0x30, 0x31, 0x30, 0x20, // ht 2010 | |
| /* 00B0 */ 0x4E, 0x56, 0x49, 0x44, 0x49, 0x41, 0x20, 0x43, // NVIDIA C | |
| /* 00B8 */ 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69, // orporati | |
| /* 00C0 */ 0x6F, 0x6E, 0x20, 0x41, 0x6C, 0x6C, 0x20, 0x52, // on All R | |
| /* 00C8 */ 0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x52, 0x65, // ights Re | |
| /* 00D0 */ 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2D, 0x31, // served-1 | |
| /* 00D8 */ 0x34, 0x38, 0x35, 0x39, 0x37, 0x34, 0x35, 0x36, // 48597456 | |
| /* 00E0 */ 0x39, 0x38, 0x35, 0x28, 0x52, 0x29 // 985(R) | |
| }) | |
| CreateWordField (Arg0, 0x02, USRG) | |
| If ((USRG == 0x564B)) | |
| { | |
| Return (OPVK) /* \_SB_.PCI0.PEG_.VID_.GOBT.OPVK */ | |
| } | |
| Return (Zero) | |
| } | |
| } | |
| Scope (\_SB.PCI0.PEG.VID) | |
| { | |
| Name (OMPR, 0x02) | |
| Name (HDAS, 0x00) | |
| Method (NVOP, 4, Serialized) | |
| { | |
| Debug = "------- NV OPTIMUS DSM --------" | |
| If ((Arg1 != 0x0100)) | |
| { | |
| Return (0x80000001) | |
| } | |
| Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| Divide (0x00, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Divide (0x1A, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Divide (0x1B, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Divide (0x10, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Return (Local0) | |
| } | |
| Case (0x1A) | |
| { | |
| CreateField (Arg3, 0x18, 0x02, OPCE) | |
| CreateField (Arg3, 0x00, 0x01, FLCH) | |
| If (ToInteger (FLCH)) | |
| { | |
| OMPR = OPCE /* \_SB_.PCI0.PEG_.VID_.NVOP.OPCE */ | |
| } | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| CreateField (Local0, 0x00, 0x01, OPEN) | |
| CreateField (Local0, 0x03, 0x02, CGCS) | |
| CreateField (Local0, 0x06, 0x01, SHPC) | |
| CreateField (Local0, 0x18, 0x03, DGPC) | |
| CreateField (Local0, 0x1B, 0x02, HDAC) | |
| OPEN = One | |
| SHPC = One | |
| DGPC = One | |
| If (\_SB.PCI0.PEG.VID._STA ()) | |
| { | |
| CGCS = 0x03 | |
| } | |
| HDAC = 0x02 | |
| Return (Local0) | |
| } | |
| Case (0x1B) | |
| { | |
| CreateField (Arg3, 0x00, 0x01, HDAU) | |
| CreateField (Arg3, 0x01, 0x01, HDAR) | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| CreateField (Local0, 0x02, 0x02, RQGS) | |
| CreateField (Local0, 0x04, 0x01, PWST) | |
| PWST = One | |
| RQGS = Zero | |
| If (ToInteger (HDAR)) | |
| { | |
| HDAS = ToInteger (HDAU) | |
| } | |
| Return (Local0) | |
| } | |
| Case (0x10) | |
| { | |
| Return (\_SB.PCI0.PEG.VID.GOBT (Arg3)) | |
| } | |
| } | |
| Return (0x80000002) | |
| } | |
| } | |
| Scope (\) | |
| { | |
| Method (CMPB, 2, NotSerialized) | |
| { | |
| Local1 = SizeOf (Arg0) | |
| If ((Local1 != SizeOf (Arg1))) | |
| { | |
| Return (0x00) | |
| } | |
| Local0 = 0x00 | |
| While ((Local0 < Local1)) | |
| { | |
| If ((DerefOf (Arg0 [Local0]) != DerefOf (Arg1 [Local0] | |
| ))) | |
| { | |
| Return (0x00) | |
| } | |
| Local0++ | |
| } | |
| Return (0x01) | |
| } | |
| } | |
| Scope (\_SB.PCI0.PEG.VID) | |
| { | |
| Name (CPPC, 0x00) | |
| Method (NVPS, 4, Serialized) | |
| { | |
| Debug = "------- NV GPS DSM --------" | |
| Switch (ToInteger (Arg2)) | |
| { | |
| Case (0x00) | |
| { | |
| Local0 = Buffer (0x08) | |
| { | |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // ........ | |
| } | |
| Local3 = Buffer (0x07) | |
| { | |
| 0x00, 0x20, 0x21, 0x22, 0x23, 0x2A, 0xFF // . !"#*. | |
| } | |
| Local4 = Zero | |
| Local5 = DerefOf (Local3 [Local4]) | |
| While ((Local5 != 0xFF)) | |
| { | |
| Divide (Local5, 0x08, Local2, Local1) | |
| Local2 = (0x01 << Local2) | |
| Local0 [Local1] = (DerefOf (Local0 [Local1]) | Local2) | |
| Local4++ | |
| Local5 = DerefOf (Local3 [Local4]) | |
| } | |
| Return (Local0) | |
| } | |
| Case (0x20) | |
| { | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| CreateField (Local0, 0x18, 0x01, CUIT) | |
| CreateField (Local0, 0x1E, 0x01, PSER) | |
| CUIT = One | |
| PSER = One | |
| Return (Local0) | |
| } | |
| Case (0x21) | |
| { | |
| Return (\_PR.CPU0._PSS) /* External reference */ | |
| } | |
| Case (0x22) | |
| { | |
| CreateField (Arg3, 0x00, 0x08, PPCV) | |
| CPPC = PPCV /* \_SB_.PCI0.PEG_.VID_.NVPS.PPCV */ | |
| \PNTF (0x80) | |
| Return (Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| }) | |
| } | |
| Case (0x23) | |
| { | |
| Local0 = Buffer (0x04) | |
| { | |
| 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| Local0 [0x00] = CPPC /* \_SB_.PCI0.PEG_.VID_.CPPC */ | |
| Return (Local0) | |
| } | |
| Case (0x2A) | |
| { | |
| Local0 = Buffer (0x24) | |
| { | |
| /* 0000 */ 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, // ........ | |
| /* 0008 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0018 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0020 */ 0x00, 0x00, 0x00, 0x00 // .... | |
| } | |
| Local0 [0x00] = DerefOf (Arg3 [0x00]) | |
| CreateField (Arg3, 0x00, 0x04, QTYP) | |
| Switch (ToInteger (QTYP)) | |
| { | |
| Case (0x00) | |
| { | |
| Local1 = \_SB.PCI0.LPC.EC.TMP0 | |
| Local0 [0x0C] = (Local1 & 0xFF) | |
| Return (Local0) | |
| } | |
| Case (0x01) | |
| { | |
| Local0 [0x0D] = 0x08 | |
| Local0 [0x01] = 0x03 | |
| Return (Local0) | |
| } | |
| Case (0x02) | |
| { | |
| Local0 [0x01] = 0x03 | |
| Local0 [0x08] = 0x59 | |
| Return (Local0) | |
| } | |
| } | |
| } | |
| } | |
| Return (Buffer (0x04) | |
| { | |
| 0x02, 0x00, 0x00, 0x80 // .... | |
| }) | |
| } | |
| } | |
| } | |
| Name (\_S0, Package (0x04) // _S0_: S0 System State | |
| { | |
| 0x00, | |
| 0x00, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (\_S3, Package (0x04) // _S3_: S3 System State | |
| { | |
| 0x05, | |
| 0x05, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (\_S4, Package (0x04) // _S4_: S4 System State | |
| { | |
| 0x06, | |
| 0x06, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Name (\_S5, Package (0x04) // _S5_: S5 System State | |
| { | |
| 0x07, | |
| 0x07, | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (\_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep | |
| { | |
| Local0 = 0x01 | |
| If ((Arg0 == \SPS)) | |
| { | |
| Local0 = 0x00 | |
| } | |
| If (((Arg0 == 0x00) || (Arg0 >= 0x06))) | |
| { | |
| Local0 = 0x00 | |
| } | |
| If (Local0) | |
| { | |
| \SPS = Arg0 | |
| \_SB.PCI0.LPC.EC.HKEY.MHKE (0x00) | |
| If (\_SB.PCI0.LPC.EC.KBLT) | |
| { | |
| \UCMS (0x0D) | |
| } | |
| If ((Arg0 == 0x01)) | |
| { | |
| \FNID = \_SB.PCI0.LPC.EC.HFNI | |
| \_SB.PCI0.LPC.EC.HFNI = 0x00 | |
| \_SB.PCI0.LPC.EC.HFSP = 0x00 | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| \VVPD (0x03) | |
| \TRAP () | |
| \ACST = \_SB.PCI0.LPC.EC.AC._PSR () | |
| If ((\FNWK == 0x01)) | |
| { | |
| If (\H8DR) | |
| { | |
| \_SB.PCI0.LPC.EC.HWFN = 0x00 | |
| } | |
| Else | |
| { | |
| \MBEC (0x32, 0xEF, 0x00) | |
| } | |
| } | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| If (VDSP) | |
| { | |
| SHA1 = Zero | |
| } | |
| \_SB.SLPB._PSW (0x00) | |
| \TRAP () | |
| \_SB.PCI0.LPC.TPM.CMOR () | |
| \AWON (0x04) | |
| } | |
| If ((Arg0 == 0x05)) | |
| { | |
| \TRAP () | |
| \_SB.PCI0.LPC.TPM.CMOR () | |
| \AWON (0x05) | |
| } | |
| \_SB.PCI0.LPC.EC.BPTS (Arg0) | |
| If ((Arg0 >= 0x04)) | |
| { | |
| \_SB.PCI0.LPC.EC.HWLB = 0x00 | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.HWLB = 0x01 | |
| } | |
| If ((Arg0 >= 0x03)) | |
| { | |
| \_SB.PCI0.LPC.EC.HCMU = 0x01 | |
| } | |
| If ((Arg0 != 0x05)) | |
| { | |
| \_SB.PCI0.EXP6.PDSF = \_SB.PCI0.EXP6.PDS | |
| } | |
| \_SB.PCI0.LPC.EC.HKEY.WGPS (Arg0) | |
| } | |
| } | |
| Name (WAKI, Package (0x02) | |
| { | |
| 0x00, | |
| 0x00 | |
| }) | |
| Method (\_WAK, 1, NotSerialized) // _WAK: Wake | |
| { | |
| If (((Arg0 == 0x00) || (Arg0 >= 0x05))) | |
| { | |
| Return (WAKI) /* \WAKI */ | |
| } | |
| \SPS = 0x00 | |
| \_SB.PCI0.LPC.EC.HCMU = 0x00 | |
| \_SB.PCI0.LPC.EC.EVNT (0x01) | |
| \_SB.PCI0.LPC.EC.HKEY.MHKE (0x01) | |
| \_SB.PCI0.LPC.EC.FNST () | |
| \UCMS (0x0D) | |
| \LIDB = 0x00 | |
| \_SB.PCI0.VID.VRSI () | |
| If ((Arg0 == 0x01)) | |
| { | |
| \FNID = \_SB.PCI0.LPC.EC.HFNI | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| \NVSS (0x00) | |
| \PWRS = \_SB.PCI0.LPC.EC.AC._PSR () | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| If ((\ACST != \_SB.PCI0.LPC.EC.AC._PSR ())) | |
| { | |
| \_SB.PCI0.LPC.EC.ATMC () | |
| } | |
| If (\SCRM) | |
| { | |
| \_SB.PCI0.LPC.EC.HFSP = 0x07 | |
| If (\MTAU) | |
| { | |
| Local2 = 0x03E8 | |
| While ((\_SB.PCI0.LPC.EC.PIBS && Local2)) | |
| { | |
| Sleep (0x01) | |
| Local2-- | |
| } | |
| If (Local2) | |
| { | |
| \_SB.PCI0.LPC.EC.PLSL = 0x01 | |
| \_SB.PCI0.LPC.EC.PLTU = \MTAU | |
| \_SB.PCI0.LPC.EC.PLLS = \PL1L | |
| \_SB.PCI0.LPC.EC.PLMS = \PL1M | |
| } | |
| } | |
| } | |
| \IOEN = 0x00 | |
| \IOST = 0x00 | |
| If ((\ISWK == 0x01)) | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6070) | |
| } | |
| } | |
| If (\VIGD) | |
| { | |
| \_SB.PCI0.VID.GLIS (\_SB.LID._LID ()) | |
| If (\WVIS) | |
| { | |
| \VBTD () | |
| } | |
| } | |
| ElseIf (\WVIS) | |
| { | |
| \_SB.PCI0.VID.GLIS (\_SB.LID._LID ()) | |
| \VBTD () | |
| } | |
| \VCMS (0x01, \_SB.LID._LID ()) | |
| \AWON (0x00) | |
| If (\CMPR) | |
| { | |
| Notify (\_SB.SLPB, 0x02) // Device Wake | |
| \CMPR = 0x00 | |
| } | |
| If ((\USBR || \_SB.PCI0.XHCI.XRST)) | |
| { | |
| If (((\XHCI == 0x02) || (\XHCI == 0x03))) | |
| { | |
| Local0 = 0x00 | |
| Local0 = (\_SB.PCI0.XHCI.PR3 & 0xFFFFFFC0) | |
| \_SB.PCI0.XHCI.PR3 = (Local0 | \_SB.PCI0.XHCI.PR3M) | |
| Local0 = 0x00 | |
| Local0 = (\_SB.PCI0.XHCI.PR2 & 0xFFFF8000) | |
| \_SB.PCI0.XHCI.PR2 = (Local0 | \_SB.PCI0.XHCI.PR2M) | |
| } | |
| } | |
| If ((\ISCT != 0x00)) | |
| { | |
| If (\VIGD) | |
| { | |
| If ((\_SB.PCI0.VID.TCHE & 0x0100)) | |
| { | |
| If ((\_SB.IAOE.GAOS & 0x01)) | |
| { | |
| If ((\_SB.IAOE.GSWR & 0x02)) | |
| { | |
| \_SB.PCI0.VID.STAT = ((\_SB.PCI0.VID.STAT & ~0x03) | 0x01) | |
| \_SB.PCI0.LPC.EC.SKEM = 0x01 | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| \NVSS (0x00) | |
| \_SB.PCI0.LPC.EC.HSPA = 0x00 | |
| \PWRS = \_SB.PCI0.LPC.EC.AC._PSR () | |
| If (\OSC4) | |
| { | |
| \PNTF (0x81) | |
| } | |
| \_SB.PCI0.LPC.EC.ATMC () | |
| If (\SCRM) | |
| { | |
| \_SB.PCI0.LPC.EC.HFSP = 0x07 | |
| If (\MTAU) | |
| { | |
| Local2 = 0x03E8 | |
| While ((\_SB.PCI0.LPC.EC.PIBS && Local2)) | |
| { | |
| Sleep (0x01) | |
| Local2-- | |
| } | |
| If (Local2) | |
| { | |
| \_SB.PCI0.LPC.EC.PLSL = 0x01 | |
| \_SB.PCI0.LPC.EC.PLTU = \MTAU | |
| \_SB.PCI0.LPC.EC.PLLS = \PL1L | |
| \_SB.PCI0.LPC.EC.PLMS = \PL1M | |
| } | |
| } | |
| } | |
| If (!\NBCF) | |
| { | |
| If (\VIGD) | |
| { | |
| \_SB.PCI0.LPC.EC.BRNS () | |
| } | |
| Else | |
| { | |
| \VBRC (\BRLV) | |
| } | |
| } | |
| \IOEN = 0x00 | |
| \IOST = 0x00 | |
| If ((\ISWK == 0x02)) | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6080) | |
| } | |
| } | |
| If (\_SB.PCI0.XHCI.XRST) | |
| { | |
| If (((\XHCI == 0x02) || (\XHCI == 0x03))) | |
| { | |
| Local0 = 0x00 | |
| Local0 = (\_SB.PCI0.XHCI.PR3 & 0xFFFFFFC0) | |
| \_SB.PCI0.XHCI.PR3 = (Local0 | \_SB.PCI0.XHCI.PR3M) | |
| Local0 = 0x00 | |
| Local0 = (\_SB.PCI0.XHCI.PR2 & 0xFFFF8000) | |
| \_SB.PCI0.XHCI.PR2 = (Local0 | \_SB.PCI0.XHCI.PR2M) | |
| } | |
| } | |
| } | |
| If ((\_SB.PCI0.EXP6.PDS ^ \_SB.PCI0.EXP6.PDSF)) | |
| { | |
| \_SB.PCI0.EXP6.PDSF = \_SB.PCI0.EXP6.PDS | |
| Notify (\_SB.PCI0.EXP6, 0x00) // Bus Check | |
| } | |
| \_SB.PCI0.LPC.EC.BATW (Arg0) | |
| \_SB.PCI0.LPC.EC.BWAK (Arg0) | |
| \_SB.PCI0.LPC.EC.HKEY.WGWK (Arg0) | |
| Notify (\_TZ.THM0, 0x80) // Thermal Status Change | |
| \VSLD (\_SB.LID._LID ()) | |
| If (\VIGD) | |
| { | |
| \_SB.PCI0.VID.GLIS (\_SB.LID._LID ()) | |
| } | |
| ElseIf (\WVIS) | |
| { | |
| \_SB.PCI0.VID.GLIS (\_SB.LID._LID ()) | |
| } | |
| If ((Arg0 < 0x04)) | |
| { | |
| If (((\RRBF & 0x02) || (\_SB.PCI0.LPC.EC.HWAC & 0x02))) | |
| { | |
| Local0 = (Arg0 << 0x08) | |
| Local0 = (0x2013 | Local0) | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (Local0) | |
| } | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| Local0 = 0x00 | |
| Local1 = \CSUM (0x00) | |
| If ((Local1 != \CHKC)) | |
| { | |
| Local0 = 0x01 | |
| \CHKC = Local1 | |
| } | |
| Local1 = \CSUM (0x01) | |
| If ((Local1 != \CHKE)) | |
| { | |
| Local0 = 0x01 | |
| \CHKE = Local1 | |
| } | |
| If (Local0) | |
| { | |
| Notify (\_SB, 0x00) // Bus Check | |
| } | |
| } | |
| \RRBF = Zero | |
| Return (WAKI) /* \WAKI */ | |
| } | |
| Scope (\_SI) | |
| { | |
| Method (_SST, 1, NotSerialized) // _SST: System Status | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0x00) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0x00) | |
| \_SB.PCI0.LPC.EC.LED (0x07, 0x00) | |
| } | |
| If ((Arg0 == 0x01)) | |
| { | |
| If ((\SPS || \WNTF)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x05) | |
| } | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0x80) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0x80) | |
| \_SB.PCI0.LPC.EC.LED (0x07, 0x00) | |
| } | |
| If ((Arg0 == 0x02)) | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0xC0) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0xC0) | |
| \_SB.PCI0.LPC.EC.LED (0x07, 0xC0) | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| If ((\SPS > 0x03)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x07) | |
| } | |
| ElseIf ((\SPS == 0x03)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x03) | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x04) | |
| } | |
| If ((\SPS == 0x03)){} | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0x80) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0x80) | |
| } | |
| \_SB.PCI0.LPC.EC.LED (0x07, 0xC0) | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0xC0) | |
| Stall (0x32) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0xC0) | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| \_SB.PCI0.LPC.EC.BEEP (0x03) | |
| \_SB.PCI0.LPC.EC.LED (0x07, 0xC0) | |
| \_SB.PCI0.LPC.EC.LED (0x00, 0xC0) | |
| \_SB.PCI0.LPC.EC.LED (0x0A, 0xC0) | |
| } | |
| } | |
| } | |
| Scope (\_GPE) | |
| { | |
| Method (_L1D, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| Local0 = \_SB.PCI0.LPC.EC.HWAC | |
| \RRBF = Local0 | |
| Sleep (0x0A) | |
| If ((Local0 & 0x02)){} | |
| If ((Local0 & 0x04)) | |
| { | |
| Notify (\_SB.LID, 0x02) // Device Wake | |
| } | |
| If ((Local0 & 0x08)) | |
| { | |
| Notify (\_SB.SLPB, 0x02) // Device Wake | |
| } | |
| If ((Local0 & 0x10)) | |
| { | |
| Notify (\_SB.SLPB, 0x02) // Device Wake | |
| } | |
| If ((Local0 & 0x40)){} | |
| If ((Local0 & 0x80)) | |
| { | |
| Notify (\_SB.SLPB, 0x02) // Device Wake | |
| } | |
| } | |
| Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| If (\_SB.PCI0.EXP1.PS) | |
| { | |
| \_SB.PCI0.EXP1.PS = 0x01 | |
| \_SB.PCI0.EXP1.PMCS = 0x01 | |
| Notify (\_SB.PCI0.EXP1, 0x02) // Device Wake | |
| } | |
| If (\_SB.PCI0.EXP2.PS) | |
| { | |
| \_SB.PCI0.EXP2.PS = 0x01 | |
| \_SB.PCI0.EXP2.PMCS = 0x01 | |
| Notify (\_SB.PCI0.EXP2, 0x02) // Device Wake | |
| } | |
| If (\_SB.PCI0.EXP3.PS) | |
| { | |
| \_SB.PCI0.EXP3.PS = 0x01 | |
| \_SB.PCI0.EXP3.PMCS = 0x01 | |
| Notify (\_SB.PCI0.EXP3, 0x02) // Device Wake | |
| } | |
| If (\_SB.PCI0.EXP6.PS) | |
| { | |
| \_SB.PCI0.EXP6.PS = 0x01 | |
| \_SB.PCI0.EXP6.PMCS = 0x01 | |
| Notify (\_SB.PCI0.EXP6, 0x02) // Device Wake | |
| } | |
| } | |
| Method (_L01, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| If (\_SB.PCI0.EXP6.HPCS) | |
| { | |
| Sleep (0x64) | |
| \_SB.PCI0.EXP6.HPCS = 0x01 | |
| If (\_SB.PCI0.EXP6.PDC) | |
| { | |
| \_SB.PCI0.EXP6.PDC = 0x01 | |
| \_SB.PCI0.EXP6.PDSF = \_SB.PCI0.EXP6.PDS | |
| Notify (\_SB.PCI0.EXP6, 0x00) // Bus Check | |
| } | |
| } | |
| } | |
| Method (_L02, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| \_SB.PCI0.LPC.SWGE = 0x00 | |
| If (CondRefOf (\_SB.PCCD.PENB)) | |
| { | |
| If ((\_SB.PCCD.PENB == 0x01)) | |
| { | |
| Notify (\_SB.PCCD, 0x80) // Status Change | |
| } | |
| } | |
| } | |
| Method (_L06, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| If (\_SB.PCI0.VID.GSSE (\_SB.PCI0.VID.GSCI ())){} | |
| Else | |
| { | |
| \_SB.PCI0.LPC.SCIS = 0x01 | |
| } | |
| } | |
| Name (GPFG, 0x00) | |
| Method (_L12, 0, NotSerialized) // _Lxx: Level-Triggered GPE | |
| { | |
| If ((GPFG && \_SB.PCI0.LPC.NFCI)) | |
| { | |
| GPFG = 0x00 | |
| Notify (\_SB.PCI0.SMBU.NFC, 0xC0) // Hardware-Specific | |
| } | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC.HKEY) | |
| { | |
| Method (MHQT, 1, NotSerialized) | |
| { | |
| If ((\WNTF && \TATC)) | |
| { | |
| If ((Arg0 == 0x00)) | |
| { | |
| Local0 = \TATC | |
| Return (Local0) | |
| } | |
| ElseIf ((Arg0 == 0x01)) | |
| { | |
| Local0 = \TDFA | |
| Local0 += (\TDTA << 0x04) | |
| Local0 += (\TDFD << 0x08) | |
| Local0 += (\TDTD << 0x0C) | |
| Local0 += (\TNFT << 0x10) | |
| Local0 += (\TNTT << 0x14) | |
| Return (Local0) | |
| } | |
| ElseIf ((Arg0 == 0x02)) | |
| { | |
| Local0 = \TCFA | |
| Local0 += (\TCTA << 0x04) | |
| Local0 += (\TCFD << 0x08) | |
| Local0 += (\TCTD << 0x0C) | |
| Return (Local0) | |
| } | |
| ElseIf ((Arg0 == 0x03)){} | |
| ElseIf ((Arg0 == 0x04)) | |
| { | |
| Local0 = \TATW | |
| Return (Local0) | |
| } | |
| Else | |
| { | |
| Noop | |
| } | |
| } | |
| Return (0x00) | |
| } | |
| Method (MHAT, 1, NotSerialized) | |
| { | |
| If ((\WNTF && \TATC)) | |
| { | |
| Local0 = (Arg0 & 0xFF) | |
| If (!ATMV (Local0)) | |
| { | |
| Return (0x00) | |
| } | |
| Local0 = ((Arg0 >> 0x08) & 0xFF) | |
| If (!ATMV (Local0)) | |
| { | |
| Return (0x00) | |
| } | |
| \TCFA = (Arg0 & 0x0F) | |
| \TCTA = ((Arg0 >> 0x04) & 0x0F) | |
| \TCFD = ((Arg0 >> 0x08) & 0x0F) | |
| \TCTD = ((Arg0 >> 0x0C) & 0x0F) | |
| ATMC () | |
| If ((\PPMF & 0x0100)) | |
| { | |
| Local1 = \FTPS | |
| If ((Arg0 & 0x00010000)) | |
| { | |
| \FTPS = 0x01 | |
| } | |
| Else | |
| { | |
| \FTPS = 0x00 | |
| } | |
| If ((\FTPS ^ Local1)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| } | |
| } | |
| Local2 = \SCRM | |
| If ((Arg0 & 0x00040000)) | |
| { | |
| \SCRM = 0x01 | |
| \_SB.PCI0.LPC.EC.HFSP = 0x07 | |
| } | |
| Else | |
| { | |
| \SCRM = 0x00 | |
| \_SB.PCI0.LPC.EC.HFSP = 0x80 | |
| } | |
| Local3 = \ETAU | |
| If ((Arg0 & 0x00020000)) | |
| { | |
| \ETAU = 0x01 | |
| } | |
| Else | |
| { | |
| \ETAU = 0x00 | |
| } | |
| If (\MTAU) | |
| { | |
| If (((\SCRM ^ Local2) || (\ETAU ^ Local3))) | |
| { | |
| Local4 = 0x03E8 | |
| While (\_SB.PCI0.LPC.EC.PIBS) | |
| { | |
| Sleep (0x01) | |
| Local4-- | |
| If (!Local4) | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| \_SB.PCI0.LPC.EC.PLSL = 0x01 | |
| If ((Arg0 & 0x00060000)) | |
| { | |
| \_SB.PCI0.LPC.EC.PLTU = \MTAU | |
| } | |
| Else | |
| { | |
| \_SB.PCI0.LPC.EC.PLTU = 0x1C | |
| } | |
| \_SB.PCI0.LPC.EC.PLLS = \PL1L | |
| \_SB.PCI0.LPC.EC.PLMS = \PL1M | |
| } | |
| } | |
| Return (0x01) | |
| } | |
| Return (0x00) | |
| } | |
| Method (MHGT, 1, NotSerialized) | |
| { | |
| If ((\WNTF && \TATC)) | |
| { | |
| Local0 = 0x01000000 | |
| If ((\PPMF & 0x0100)) | |
| { | |
| Local0 |= 0x08000000 | |
| } | |
| If (\SCRM) | |
| { | |
| Local0 |= 0x10000000 | |
| } | |
| If (\ETAU) | |
| { | |
| Local0 |= 0x04000000 | |
| } | |
| If (\FTPS) | |
| { | |
| Local0 |= 0x02000000 | |
| } | |
| Local0 += (\TSFT << 0x10) | |
| Local0 += (\TSTT << 0x14) | |
| Local1 = (Arg0 & 0xFF) | |
| If (!ATMV (Local1)) | |
| { | |
| Local0 |= 0xFFFF | |
| Return (Local0) | |
| } | |
| Local1 = (Arg0 & 0x0F) | |
| If ((Local1 == 0x00)) | |
| { | |
| Local0 += \TIF0 | |
| } | |
| ElseIf ((Local1 == 0x01)) | |
| { | |
| Local0 += \TIF1 | |
| } | |
| ElseIf ((Local1 == 0x02)) | |
| { | |
| Local0 += \TIF2 | |
| } | |
| Else | |
| { | |
| Local0 += 0xFF | |
| } | |
| Local1 = ((Arg0 >> 0x04) & 0x0F) | |
| If ((Local1 == 0x00)) | |
| { | |
| Local0 += (\TIT0 << 0x08) | |
| } | |
| ElseIf ((Local1 == 0x01)) | |
| { | |
| Local0 += (\TIT1 << 0x08) | |
| } | |
| ElseIf ((Local1 == 0x02)) | |
| { | |
| Local0 += (\TIT2 << 0x08) | |
| } | |
| Else | |
| { | |
| Local0 += (0xFF << 0x08) | |
| } | |
| Return (Local0) | |
| } | |
| Return (0x00) | |
| } | |
| Method (ATMV, 1, NotSerialized) | |
| { | |
| Local1 = (Arg0 & 0x0F) | |
| Local0 = \TNFT | |
| If ((Local1 >= Local0)) | |
| { | |
| Return (0x00) | |
| } | |
| Local2 = ((Arg0 >> 0x04) & 0x0F) | |
| Local0 = \TNTT | |
| If ((Local2 >= Local0)) | |
| { | |
| Return (0x00) | |
| } | |
| If (\TATL) | |
| { | |
| If ((Local1 ^ Local2)) | |
| { | |
| Return (0x00) | |
| } | |
| } | |
| Return (0x01) | |
| } | |
| Method (MHCT, 1, NotSerialized) | |
| { | |
| Local0 = 0x00 | |
| If (\SPEN) | |
| { | |
| Local0 = \LWST | |
| Local0++ | |
| Local0 <<= 0x08 | |
| } | |
| Local1 = 0x08 | |
| Local1 <<= 0x08 | |
| If ((Arg0 == 0xFFFFFFFF)) | |
| { | |
| Local1 |= \TPCR | |
| If (\SPEN) | |
| { | |
| Local0 |= \PPCR | |
| If (!(\PPMF && 0x02000000)) | |
| { | |
| Local1 |= 0x80 | |
| } | |
| If (!(\PPMF && 0x08000000)) | |
| { | |
| Local1 |= 0x40 | |
| } | |
| } | |
| Else | |
| { | |
| Local1 |= 0xC0 | |
| } | |
| } | |
| Else | |
| { | |
| If (((\OSPX || \CPPX) && \SPEN)) | |
| { | |
| Local2 = (Arg0 & 0x00FF0000) | |
| Local2 >>= 0x10 | |
| Local0 |= Local2 | |
| If ((Local2 ^ \PPCR)) | |
| { | |
| \PPCA = Local2 | |
| \PNTF (0x80) | |
| } | |
| } | |
| If (\WVIS) | |
| { | |
| Local2 = (Arg0 & 0x1F) | |
| Local1 |= Local2 | |
| If ((Local2 ^ \TPCR)) | |
| { | |
| \TPCA = Local2 | |
| \PNTF (0x82) | |
| } | |
| } | |
| } | |
| Local0 <<= 0x10 | |
| Local0 |= Local1 | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (ATMC, 0, NotSerialized) | |
| { | |
| If ((\WNTF && \TATC)) | |
| { | |
| If (HPAC) | |
| { | |
| Local0 = \TCFA | |
| Local1 = \TCTA | |
| Local2 = ((Local1 << 0x04) | Local0) | |
| Local3 = (Local2 ^ ATMX) /* \_SB_.PCI0.LPC_.EC__.ATMX */ | |
| ATMX = Local2 | |
| If ((\TCTA == 0x00)) | |
| { | |
| \TCRT = \TCR0 | |
| \TPSV = \TPS0 | |
| } | |
| ElseIf ((\TCTA == 0x01)) | |
| { | |
| \TCRT = \TCR1 | |
| \TPSV = \TPS1 | |
| } | |
| Else | |
| { | |
| } | |
| } | |
| Else | |
| { | |
| Local0 = \TCFD | |
| Local1 = \TCTD | |
| Local2 = ((Local1 << 0x04) | Local0) | |
| Local3 = (Local2 ^ ATMX) /* \_SB_.PCI0.LPC_.EC__.ATMX */ | |
| ATMX = Local2 | |
| If ((\TCTD == 0x00)) | |
| { | |
| \TCRT = \TCR0 | |
| \TPSV = \TPS0 | |
| } | |
| ElseIf ((\TCTD == 0x01)) | |
| { | |
| \TCRT = \TCR1 | |
| \TPSV = \TPS1 | |
| } | |
| Else | |
| { | |
| } | |
| } | |
| If (Local3) | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6030) | |
| } | |
| } | |
| Notify (\_TZ.THM0, 0x81) // Thermal Trip Point Change | |
| } | |
| } | |
| } | |
| Scope (\_TZ) | |
| { | |
| ThermalZone (THM0) | |
| { | |
| Method (_CRT, 0, NotSerialized) // _CRT: Critical Temperature | |
| { | |
| Return (\TCRT) | |
| } | |
| Method (_TMP, 0, NotSerialized) // _TMP: Temperature | |
| { | |
| If (\H8DR) | |
| { | |
| Local0 = \_SB.PCI0.LPC.EC.TMP0 | |
| Local1 = \_SB.PCI0.LPC.EC.TSL2 | |
| Local2 = \_SB.PCI0.LPC.EC.TSL3 | |
| } | |
| Else | |
| { | |
| Local0 = \RBEC (0x78) | |
| Local1 = (\RBEC (0x8A) & 0x7F) | |
| Local2 = (\RBEC (0x8B) & 0x7F) | |
| } | |
| If ((Local0 == 0x80)) | |
| { | |
| Local0 = 0x30 | |
| } | |
| If (Local2) | |
| { | |
| \TSDL () | |
| Return (C2K (0x80)) | |
| } | |
| If (!\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| If (Local1) | |
| { | |
| \TSDL () | |
| Return (C2K (0x80)) | |
| } | |
| } | |
| Return (C2K (Local0)) | |
| } | |
| } | |
| Method (C2K, 1, NotSerialized) | |
| { | |
| Local0 = ((Arg0 * 0x0A) + 0x0AAC) | |
| If ((Local0 <= 0x0AAC)) | |
| { | |
| Local0 = 0x0BB8 | |
| } | |
| If ((Local0 > 0x0FAC)) | |
| { | |
| Local0 = 0x0BB8 | |
| } | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB.PCI0.LPC.EC) | |
| { | |
| Method (_Q40, 0, NotSerialized) // _Qxx: EC Query | |
| { | |
| Notify (\_TZ.THM0, 0x80) // Thermal Status Change | |
| If (\H8DR) | |
| { | |
| Local1 = \_SB.PCI0.LPC.EC.TSL2 | |
| } | |
| Else | |
| { | |
| Local1 = (\RBEC (0x8A) & 0x7F) | |
| } | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| If (Local1) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6022) | |
| } | |
| } | |
| If (VIGD) | |
| { | |
| Noop | |
| } | |
| Else | |
| { | |
| \VTHR () | |
| } | |
| If ((\PPMF & 0x01)) | |
| { | |
| If ((\OSPX || \CPPX)) | |
| { | |
| \PNTF (0x80) | |
| } | |
| Else | |
| { | |
| Local2 = (\_SB.PCI0.LPC.EC.TSL0 & 0x77) | |
| If (Local2) | |
| { | |
| \STEP (0x09) | |
| } | |
| Else | |
| { | |
| \STEP (0x0A) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Name (GPIC, 0x00) | |
| Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model | |
| { | |
| \GPIC = Arg0 | |
| } | |
| OperationRegion (SMI0, SystemIO, 0xB2, 0x01) | |
| Field (SMI0, ByteAcc, NoLock, Preserve) | |
| { | |
| APMC, 8 | |
| } | |
| Field (MNVS, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0xFC0), | |
| CMD, 8, | |
| ERR, 32, | |
| PAR0, 32, | |
| PAR1, 32, | |
| PAR2, 32, | |
| PAR3, 32 | |
| } | |
| Mutex (MSMI, 0x07) | |
| Method (SMI, 5, NotSerialized) | |
| { | |
| Acquire (MSMI, 0xFFFF) | |
| CMD = Arg0 | |
| ERR = 0x01 | |
| PAR0 = Arg1 | |
| PAR1 = Arg2 | |
| PAR2 = Arg3 | |
| PAR3 = Arg4 | |
| APMC = 0xF5 | |
| While ((ERR == 0x01)) | |
| { | |
| Sleep (0x01) | |
| APMC = 0xF5 | |
| } | |
| Local0 = PAR0 /* \PAR0 */ | |
| Release (MSMI) | |
| Return (Local0) | |
| } | |
| Method (RPCI, 1, NotSerialized) | |
| { | |
| Return (SMI (0x00, 0x00, Arg0, 0x00, 0x00)) | |
| } | |
| Method (WPCI, 2, NotSerialized) | |
| { | |
| SMI (0x00, 0x01, Arg0, Arg1, 0x00) | |
| } | |
| Method (MPCI, 3, NotSerialized) | |
| { | |
| SMI (0x00, 0x02, Arg0, Arg1, Arg2) | |
| } | |
| Method (RBEC, 1, NotSerialized) | |
| { | |
| Return (SMI (0x00, 0x03, Arg0, 0x00, 0x00)) | |
| } | |
| Method (WBEC, 2, NotSerialized) | |
| { | |
| SMI (0x00, 0x04, Arg0, Arg1, 0x00) | |
| } | |
| Method (MBEC, 3, NotSerialized) | |
| { | |
| SMI (0x00, 0x05, Arg0, Arg1, Arg2) | |
| } | |
| Method (RISA, 1, NotSerialized) | |
| { | |
| Return (SMI (0x00, 0x06, Arg0, 0x00, 0x00)) | |
| } | |
| Method (WISA, 2, NotSerialized) | |
| { | |
| SMI (0x00, 0x07, Arg0, Arg1, 0x00) | |
| } | |
| Method (MISA, 3, NotSerialized) | |
| { | |
| SMI (0x00, 0x08, Arg0, Arg1, Arg2) | |
| } | |
| Method (VEXP, 0, NotSerialized) | |
| { | |
| SMI (0x01, 0x00, 0x00, 0x00, 0x00) | |
| } | |
| Method (VUPS, 1, NotSerialized) | |
| { | |
| SMI (0x01, 0x01, Arg0, 0x00, 0x00) | |
| } | |
| Method (VSDS, 2, NotSerialized) | |
| { | |
| SMI (0x01, 0x02, Arg0, Arg1, 0x00) | |
| } | |
| Method (VDDC, 0, NotSerialized) | |
| { | |
| SMI (0x01, 0x03, 0x00, 0x00, 0x00) | |
| } | |
| Method (VVPD, 1, NotSerialized) | |
| { | |
| SMI (0x01, 0x04, Arg0, 0x00, 0x00) | |
| } | |
| Method (VNRS, 1, NotSerialized) | |
| { | |
| SMI (0x01, 0x05, Arg0, 0x00, 0x00) | |
| } | |
| Method (GLPW, 0, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x06, 0x00, 0x00, 0x00)) | |
| } | |
| Method (VSLD, 1, NotSerialized) | |
| { | |
| SMI (0x01, 0x07, Arg0, 0x00, 0x00) | |
| } | |
| Method (VEVT, 1, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x08, Arg0, 0x00, 0x00)) | |
| } | |
| Method (VTHR, 0, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x09, 0x00, 0x00, 0x00)) | |
| } | |
| Method (VBRC, 1, NotSerialized) | |
| { | |
| SMI (0x01, 0x0A, Arg0, 0x00, 0x00) | |
| } | |
| Method (VBRG, 0, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x0E, 0x00, 0x00, 0x00)) | |
| } | |
| Method (VCMS, 2, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x0B, Arg0, Arg1, 0x00)) | |
| } | |
| Method (VBTD, 0, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x0F, 0x00, 0x00, 0x00)) | |
| } | |
| Method (VHYB, 2, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x10, Arg0, Arg1, 0x00)) | |
| } | |
| Method (VDYN, 2, NotSerialized) | |
| { | |
| Return (SMI (0x01, 0x11, Arg0, Arg1, 0x00)) | |
| } | |
| Method (UCMS, 1, NotSerialized) | |
| { | |
| Return (SMI (0x02, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (BHDP, 2, NotSerialized) | |
| { | |
| Return (SMI (0x03, 0x00, Arg0, Arg1, 0x00)) | |
| } | |
| Method (STEP, 1, NotSerialized) | |
| { | |
| SMI (0x04, Arg0, 0x00, 0x00, 0x00) | |
| } | |
| Method (TRAP, 0, NotSerialized) | |
| { | |
| SMI (0x05, 0x00, 0x00, 0x00, 0x00) | |
| } | |
| Method (CBRI, 0, NotSerialized) | |
| { | |
| SMI (0x05, 0x01, 0x00, 0x00, 0x00) | |
| } | |
| Method (BCHK, 0, NotSerialized) | |
| { | |
| Return (SMI (0x05, 0x04, 0x00, 0x00, 0x00)) | |
| } | |
| Method (BYRS, 0, NotSerialized) | |
| { | |
| SMI (0x05, 0x05, 0x00, 0x00, 0x00) | |
| } | |
| Method (LCHK, 1, NotSerialized) | |
| { | |
| Return (SMI (0x05, 0x06, Arg0, 0x00, 0x00)) | |
| } | |
| Method (BLTH, 1, NotSerialized) | |
| { | |
| Return (SMI (0x06, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (PRSM, 2, NotSerialized) | |
| { | |
| Return (SMI (0x07, 0x00, Arg0, Arg1, 0x00)) | |
| } | |
| Method (IFRS, 2, NotSerialized) | |
| { | |
| Return (SMI (0x07, 0x01, Arg0, Arg1, 0x00)) | |
| } | |
| Method (TDPC, 1, NotSerialized) | |
| { | |
| Return (SMI (0x07, 0x02, Arg0, 0x00, 0x00)) | |
| } | |
| Method (ISOC, 1, NotSerialized) | |
| { | |
| Return (SMI (0x07, 0x03, Arg0, 0x00, 0x00)) | |
| } | |
| Method (WGSV, 1, NotSerialized) | |
| { | |
| Return (SMI (0x09, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (SWTT, 1, NotSerialized) | |
| { | |
| If (SMI (0x0A, 0x02, Arg0, 0x00, 0x00)) | |
| { | |
| If (\_SB.PCI0.LPC.EC.HKEY.DHKC) | |
| { | |
| \_SB.PCI0.LPC.EC.HKEY.MHKQ (0x6030) | |
| } | |
| } | |
| } | |
| Method (TSDL, 0, NotSerialized) | |
| { | |
| Return (SMI (0x0A, 0x03, 0x00, 0x00, 0x00)) | |
| } | |
| Method (SITT, 1, NotSerialized) | |
| { | |
| Return (SMI (0x0A, 0x04, Arg0, 0x00, 0x00)) | |
| } | |
| Method (TPHY, 1, NotSerialized) | |
| { | |
| SMI (0x0C, Arg0, 0x00, 0x00, 0x00) | |
| } | |
| Method (CSUM, 1, NotSerialized) | |
| { | |
| Return (SMI (0x0E, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (NVSS, 1, NotSerialized) | |
| { | |
| Return (SMI (0x0F, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (WMIS, 2, NotSerialized) | |
| { | |
| Return (SMI (0x10, Arg0, Arg1, 0x00, 0x00)) | |
| } | |
| Method (AWON, 1, NotSerialized) | |
| { | |
| Return (SMI (0x12, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (PMON, 2, NotSerialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| Name (TSTR, Buffer (Local0){}) | |
| TSTR = Arg0 | |
| \DBGS = TSTR /* \PMON.TSTR */ | |
| SMI (0x11, Arg1, 0x00, 0x00, 0x00) | |
| } | |
| Method (UAWS, 1, NotSerialized) | |
| { | |
| Return (SMI (0x13, Arg0, 0x00, 0x00, 0x00)) | |
| } | |
| Method (BFWC, 1, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x00, Arg0, 0x00, 0x00)) | |
| } | |
| Method (BFWP, 0, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x01, 0x00, 0x00, 0x00)) | |
| } | |
| Method (BFWL, 0, NotSerialized) | |
| { | |
| SMI (0x14, 0x02, 0x00, 0x00, 0x00) | |
| } | |
| Method (BFWG, 1, NotSerialized) | |
| { | |
| SMI (0x14, 0x03, Arg0, 0x00, 0x00) | |
| } | |
| Method (BDMC, 1, NotSerialized) | |
| { | |
| SMI (0x14, 0x04, Arg0, 0x00, 0x00) | |
| } | |
| Method (PSIF, 2, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x05, Arg0, Arg1, 0x00)) | |
| } | |
| Method (FNSC, 2, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x06, Arg0, Arg1, 0x00)) | |
| } | |
| Method (AUDC, 2, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x07, Arg0, Arg1, 0x00)) | |
| } | |
| Method (SYBC, 2, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x08, Arg0, Arg1, 0x00)) | |
| } | |
| Method (KBLS, 2, NotSerialized) | |
| { | |
| Return (SMI (0x14, 0x09, Arg0, Arg1, 0x00)) | |
| } | |
| Method (UBIS, 1, NotSerialized) | |
| { | |
| Return (SMI (0x15, 0x00, Arg0, 0x00, 0x00)) | |
| } | |
| Method (DPIO, 2, NotSerialized) | |
| { | |
| If (!Arg0) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 > 0xF0)) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 > 0xB4)) | |
| { | |
| If (Arg1) | |
| { | |
| Return (0x02) | |
| } | |
| Else | |
| { | |
| Return (0x01) | |
| } | |
| } | |
| If ((Arg0 > 0x78)) | |
| { | |
| Return (0x03) | |
| } | |
| Return (0x04) | |
| } | |
| Method (DUDM, 2, NotSerialized) | |
| { | |
| If (!Arg1) | |
| { | |
| Return (0xFF) | |
| } | |
| If ((Arg0 > 0x5A)) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 > 0x3C)) | |
| { | |
| Return (0x01) | |
| } | |
| If ((Arg0 > 0x2D)) | |
| { | |
| Return (0x02) | |
| } | |
| If ((Arg0 > 0x1E)) | |
| { | |
| Return (0x03) | |
| } | |
| If ((Arg0 > 0x14)) | |
| { | |
| Return (0x04) | |
| } | |
| Return (0x05) | |
| } | |
| Method (DMDM, 2, NotSerialized) | |
| { | |
| If (Arg1) | |
| { | |
| Return (0x00) | |
| } | |
| If (!Arg0) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg0 > 0x96)) | |
| { | |
| Return (0x01) | |
| } | |
| If ((Arg0 > 0x78)) | |
| { | |
| Return (0x02) | |
| } | |
| Return (0x03) | |
| } | |
| Method (UUDM, 2, NotSerialized) | |
| { | |
| If (!(Arg0 & 0x04)) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg1 & 0x20)) | |
| { | |
| Return (0x14) | |
| } | |
| If ((Arg1 & 0x10)) | |
| { | |
| Return (0x1E) | |
| } | |
| If ((Arg1 & 0x08)) | |
| { | |
| Return (0x2D) | |
| } | |
| If ((Arg1 & 0x04)) | |
| { | |
| Return (0x3C) | |
| } | |
| If ((Arg1 & 0x02)) | |
| { | |
| Return (0x5A) | |
| } | |
| If ((Arg1 & 0x01)) | |
| { | |
| Return (0x78) | |
| } | |
| Return (0x00) | |
| } | |
| Method (UMDM, 4, NotSerialized) | |
| { | |
| If (!(Arg0 & 0x02)) | |
| { | |
| Return (0x00) | |
| } | |
| If ((Arg1 & 0x04)) | |
| { | |
| Return (Arg3) | |
| } | |
| If ((Arg1 & 0x02)) | |
| { | |
| If ((Arg3 <= 0x78)) | |
| { | |
| Return (0xB4) | |
| } | |
| Else | |
| { | |
| Return (Arg3) | |
| } | |
| } | |
| If ((Arg2 & 0x04)) | |
| { | |
| If ((Arg3 <= 0xB4)) | |
| { | |
| Return (0xF0) | |
| } | |
| Else | |
| { | |
| Return (Arg3) | |
| } | |
| } | |
| Return (0x00) | |
| } | |
| Method (UPIO, 4, NotSerialized) | |
| { | |
| If (!(Arg0 & 0x02)) | |
| { | |
| If ((Arg2 == 0x02)) | |
| { | |
| Return (0xF0) | |
| } | |
| Else | |
| { | |
| Return (0x0384) | |
| } | |
| } | |
| If ((Arg1 & 0x02)) | |
| { | |
| Return (Arg3) | |
| } | |
| If ((Arg1 & 0x01)) | |
| { | |
| If ((Arg3 <= 0x78)) | |
| { | |
| Return (0xB4) | |
| } | |
| Else | |
| { | |
| Return (Arg3) | |
| } | |
| } | |
| If ((Arg2 == 0x02)) | |
| { | |
| Return (0xF0) | |
| } | |
| Else | |
| { | |
| Return (0x0384) | |
| } | |
| } | |
| Method (FDMA, 2, NotSerialized) | |
| { | |
| If ((Arg1 != 0xFF)) | |
| { | |
| Return ((Arg1 | 0x40)) | |
| } | |
| If ((Arg0 >= 0x03)) | |
| { | |
| Return (((Arg0 - 0x02) | 0x20)) | |
| } | |
| If (Arg0) | |
| { | |
| Return (0x12) | |
| } | |
| Return (0x00) | |
| } | |
| Method (FPIO, 1, NotSerialized) | |
| { | |
| If ((Arg0 >= 0x03)) | |
| { | |
| Return ((Arg0 | 0x08)) | |
| } | |
| If ((Arg0 == 0x01)) | |
| { | |
| Return (0x01) | |
| } | |
| Return (0x00) | |
| } | |
| Method (SCMP, 2, NotSerialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| If ((Local0 != SizeOf (Arg1))) | |
| { | |
| Return (One) | |
| } | |
| Local0++ | |
| Name (STR1, Buffer (Local0){}) | |
| Name (STR2, Buffer (Local0){}) | |
| STR1 = Arg0 | |
| STR2 = Arg1 | |
| Local1 = Zero | |
| While ((Local1 < Local0)) | |
| { | |
| Local2 = DerefOf (STR1 [Local1]) | |
| Local3 = DerefOf (STR2 [Local1]) | |
| If ((Local2 != Local3)) | |
| { | |
| Return (One) | |
| } | |
| Local1++ | |
| } | |
| Return (Zero) | |
| } | |
| Name (SPS, 0x00) | |
| Name (OSIF, 0x00) | |
| Name (WNTF, 0x00) | |
| Name (WXPF, 0x00) | |
| Name (WVIS, 0x00) | |
| Name (WIN7, 0x00) | |
| Name (WIN8, 0x00) | |
| Name (WSPV, 0x00) | |
| Name (LNUX, 0x00) | |
| Name (H8DR, 0x00) | |
| Name (MEMX, 0x00) | |
| Name (ACST, 0x00) | |
| Name (FMBL, 0x01) | |
| Name (FDTP, 0x02) | |
| Name (FUPS, 0x03) | |
| Name (FNID, 0x00) | |
| Name (RRBF, 0x00) | |
| Name (NBCF, 0x00) | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment