Created
July 26, 2022 15:37
-
-
Save coolbho3k/47e4eeb37c8927ff703c40fab2bb4e11 to your computer and use it in GitHub Desktop.
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 20211217 (64-bit version) | |
| * Copyright (c) 2000 - 2021 Intel Corporation | |
| * | |
| * Disassembling to symbolic ASL+ operators | |
| * | |
| * Disassembly of dsdt.dat, Mon Jul 25 13:26:19 2022 | |
| * | |
| * Original Table Header: | |
| * Signature "DSDT" | |
| * Length 0x00007F74 (32628) | |
| * Revision 0x01 **** 32-bit table (V1), no 64-bit math support | |
| * Checksum 0x78 | |
| * OEM ID "AMDYDE" | |
| * OEM Table ID "EDK2 " | |
| * OEM Revision 0x00000002 (2) | |
| * Compiler ID "ACPI" | |
| * Compiler Version 0x00040000 (262144) | |
| */ | |
| DefinitionBlock ("", "DSDT", 1, "AMDYDE", "EDK2 ", 0x00000002) | |
| { | |
| External (_PR_.C000.PPCV, IntObj) | |
| External (_PR_.C001.PPCV, IntObj) | |
| External (_PR_.C002.PPCV, IntObj) | |
| External (_PR_.C003.PPCV, IntObj) | |
| External (_PR_.C004.PPCV, IntObj) | |
| External (_PR_.C005.PPCV, IntObj) | |
| External (_PR_.C006.PPCV, IntObj) | |
| External (_PR_.C007.PPCV, IntObj) | |
| External (_SB_.ALIB, MethodObj) // 2 Arguments | |
| External (_SB_.APTS, MethodObj) // 1 Arguments | |
| External (_SB_.AWAK, MethodObj) // 1 Arguments | |
| External (_SB_.PCI0.GFX0.VGA_.LCD_, DeviceObj) | |
| External (_SB_.PCI0.VGA_.LCD_, DeviceObj) | |
| External (_SB_.TPM2.PTS_, MethodObj) // 1 Arguments | |
| External (AFN4, MethodObj) // 1 Arguments | |
| External (MPTS, MethodObj) // 1 Arguments | |
| External (MWAK, MethodObj) // 1 Arguments | |
| External (UBTC, DeviceObj) | |
| OperationRegion (EC6C, SystemIO, 0x6C, One) | |
| Field (EC6C, ByteAcc, NoLock, Preserve) | |
| { | |
| IO6C, 8 | |
| } | |
| OperationRegion (DBG0, SystemIO, 0x80, One) | |
| Field (DBG0, ByteAcc, NoLock, Preserve) | |
| { | |
| IO80, 8 | |
| } | |
| OperationRegion (DBG1, SystemIO, 0x80, 0x02) | |
| Field (DBG1, WordAcc, NoLock, Preserve) | |
| { | |
| P80H, 16 | |
| } | |
| OperationRegion (ACMS, SystemIO, 0x72, 0x02) | |
| Field (ACMS, ByteAcc, NoLock, Preserve) | |
| { | |
| ACMX, 8, | |
| ACMA, 8 | |
| } | |
| IndexField (ACMX, ACMA, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xB9), | |
| IMEN, 8 | |
| } | |
| OperationRegion (PSMI, SystemIO, 0xB0, 0x02) | |
| Field (PSMI, ByteAcc, NoLock, Preserve) | |
| { | |
| APMC, 8, | |
| APMD, 8 | |
| } | |
| OperationRegion (PMRG, SystemIO, 0x0CD6, 0x02) | |
| Field (PMRG, ByteAcc, NoLock, Preserve) | |
| { | |
| PMRI, 8, | |
| PMRD, 8 | |
| } | |
| IndexField (PMRI, PMRD, ByteAcc, NoLock, Preserve) | |
| { | |
| , 6, | |
| HPEN, 1, | |
| Offset (0x60), | |
| P1EB, 16, | |
| Offset (0xF0), | |
| , 3, | |
| RSTU, 1 | |
| } | |
| OperationRegion (GSMG, SystemMemory, 0xFED81500, 0x03FF) | |
| Field (GSMG, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x5C), | |
| Offset (0x5E), | |
| GS23, 1, | |
| , 5, | |
| GV23, 1, | |
| GE23, 1, | |
| Offset (0xA0), | |
| Offset (0xA2), | |
| GS40, 1, | |
| , 5, | |
| GV40, 1, | |
| GE40, 1, | |
| Offset (0x164), | |
| Offset (0x166), | |
| GID1, 1, | |
| , 5, | |
| , 1, | |
| Offset (0x167), | |
| Offset (0x168), | |
| Offset (0x16A), | |
| GID2, 1, | |
| , 5, | |
| , 1, | |
| Offset (0x16B), | |
| Offset (0x208), | |
| Offset (0x20A), | |
| GID0, 1, | |
| , 5, | |
| , 1, | |
| Offset (0x20B) | |
| } | |
| OperationRegion (GSMM, SystemMemory, 0xFED80000, 0x1000) | |
| Field (GSMM, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x288), | |
| , 1, | |
| CLPS, 1, | |
| Offset (0x2B0), | |
| , 2, | |
| SLPS, 2, | |
| Offset (0x3BB), | |
| , 6, | |
| PWDE, 1, | |
| Offset (0x3E4), | |
| BLNK, 2 | |
| } | |
| OperationRegion (P1E0, SystemIO, P1EB, 0x04) | |
| Field (P1E0, ByteAcc, NoLock, Preserve) | |
| { | |
| , 14, | |
| PEWS, 1, | |
| WSTA, 1, | |
| , 14, | |
| PEWD, 1 | |
| } | |
| OperationRegion (IOCC, SystemIO, 0x0400, 0x80) | |
| Field (IOCC, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x01), | |
| , 2, | |
| RTCS, 1 | |
| } | |
| Name (PRWP, Package (0x02) | |
| { | |
| Zero, | |
| Zero | |
| }) | |
| Method (GPRW, 2, NotSerialized) | |
| { | |
| PRWP [Zero] = Arg0 | |
| PRWP [One] = Arg1 | |
| If ((DAS3 == Zero)) | |
| { | |
| If ((Arg1 <= 0x03)) | |
| { | |
| PRWP [One] = Zero | |
| } | |
| } | |
| Return (PRWP) /* \PRWP */ | |
| } | |
| Method (SPTS, 1, NotSerialized) | |
| { | |
| If ((Arg0 == 0x03)) | |
| { | |
| BLNK = One | |
| } | |
| If (((Arg0 == 0x04) || (Arg0 == 0x05))) | |
| { | |
| BLNK = Zero | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| RSTU = Zero | |
| } | |
| CLPS = One | |
| SLPS = One | |
| If ((One == PEWS)) | |
| { | |
| PEWS = One | |
| } | |
| } | |
| Method (SWAK, 1, NotSerialized) | |
| { | |
| BLNK = 0x03 | |
| If ((Arg0 == 0x03)) | |
| { | |
| RSTU = One | |
| } | |
| If ((One == PEWS)) | |
| { | |
| PEWS = One | |
| } | |
| PWDE = One | |
| PEWD = Zero | |
| } | |
| OperationRegion (DBG2, SystemIO, 0x80, 0x04) | |
| Field (DBG2, DWordAcc, NoLock, Preserve) | |
| { | |
| P80D, 32 | |
| } | |
| Method (TPST, 1, Serialized) | |
| { | |
| Local0 = (Arg0 + 0xB0000000) | |
| P80D = Local0 | |
| } | |
| OperationRegion (GNVS, SystemMemory, 0x7BF3EA98, 0x0000018A) | |
| Field (GNVS, AnyAcc, NoLock, Preserve) | |
| { | |
| SMIF, 8, | |
| PRM0, 8, | |
| PRM1, 8, | |
| BRTL, 8, | |
| TLST, 8, | |
| IGDS, 8, | |
| LCDA, 16, | |
| CSTE, 16, | |
| NSTE, 16, | |
| CADL, 16, | |
| PADL, 16, | |
| LIDS, 8, | |
| PWRS, 8, | |
| BVAL, 32, | |
| ADDL, 16, | |
| BCMD, 8, | |
| SBFN, 8, | |
| DID, 32, | |
| INFO, 2048, | |
| TOML, 8, | |
| TOMH, 8, | |
| CEBP, 8, | |
| C0LS, 8, | |
| C1LS, 8, | |
| C0HS, 8, | |
| C1HS, 8, | |
| ROMS, 32, | |
| MUXF, 8, | |
| PDDN, 8, | |
| CNSB, 8, | |
| RDHW, 8, | |
| DAS3, 8, | |
| TNBH, 8, | |
| TCP0, 8, | |
| TCP1, 8, | |
| ATNB, 8, | |
| PCP0, 8, | |
| PCP1, 8, | |
| PWMN, 8, | |
| LPTY, 8, | |
| M92D, 8, | |
| WKPM, 8, | |
| ALST, 8, | |
| AFUC, 8, | |
| EXUS, 8, | |
| GV0E, 8, | |
| WLSH, 8, | |
| TSSS, 8, | |
| AOZP, 8, | |
| TZFG, 8, | |
| BPS0, 8, | |
| NAPC, 8, | |
| PCBA, 32, | |
| PCBL, 32, | |
| WLAN, 8, | |
| BLTH, 8, | |
| GPSS, 8, | |
| NFCS, 8, | |
| SBTY, 8, | |
| BDID, 16, | |
| MWTT, 8, | |
| ACPM, 8, | |
| KBCS, 8, | |
| ACEC, 8, | |
| DPTC, 8, | |
| ECTL, 8, | |
| MM64, 8, | |
| HMB1, 64, | |
| HMB2, 64, | |
| HMM1, 64, | |
| HMM2, 64, | |
| HML1, 64, | |
| HML2, 64, | |
| WOVS, 8, | |
| TCNT, 8 | |
| } | |
| OperationRegion (OGNS, SystemMemory, 0x7BF3ED18, 0x00000100) | |
| Field (OGNS, AnyAcc, Lock, Preserve) | |
| { | |
| OG00, 8, | |
| OG01, 8, | |
| M2WL, 8, | |
| THPN, 8, | |
| PBAR, 8, | |
| THPD, 8, | |
| DTEN, 8, | |
| SDMO, 8, | |
| TBEN, 8, | |
| TBNH, 8, | |
| RV2I, 8, | |
| ISDS, 8, | |
| UBCB, 32, | |
| DCLK, 32, | |
| TPEN, 8, | |
| ALSE, 8, | |
| SMAE, 8, | |
| AUCE, 8 | |
| } | |
| Name (WNOS, Zero) | |
| Name (MYOS, Zero) | |
| Name (HTTS, Zero) | |
| Name (OSTB, Ones) | |
| Name (TPOS, Zero) | |
| Name (LINX, Zero) | |
| Name (OSSP, Zero) | |
| Method (SEQL, 2, Serialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| Local1 = SizeOf (Arg1) | |
| If ((Local0 != Local1)) | |
| { | |
| Return (Zero) | |
| } | |
| Local2 = Zero | |
| While ((Local2 < Local0)) | |
| { | |
| Local3 = DerefOf (Arg0 [Local2]) | |
| Local4 = DerefOf (Arg1 [Local2]) | |
| If ((Local3 != Local4)) | |
| { | |
| Return (Zero) | |
| } | |
| Local2++ | |
| } | |
| Return (One) | |
| } | |
| Method (OSTP, 0, NotSerialized) | |
| { | |
| If ((OSTB == Ones)) | |
| { | |
| If (CondRefOf (\_OSI)) | |
| { | |
| OSTB = Zero | |
| TPOS = Zero | |
| If (_OSI ("Windows 2001")) | |
| { | |
| OSTB = 0x08 | |
| TPOS = 0x08 | |
| } | |
| If (_OSI ("Windows 2001.1")) | |
| { | |
| OSTB = 0x20 | |
| TPOS = 0x20 | |
| } | |
| If (_OSI ("Windows 2001 SP1")) | |
| { | |
| OSTB = 0x10 | |
| TPOS = 0x10 | |
| } | |
| If (_OSI ("Windows 2001 SP2")) | |
| { | |
| OSTB = 0x11 | |
| TPOS = 0x11 | |
| } | |
| If (_OSI ("Windows 2001 SP3")) | |
| { | |
| OSTB = 0x12 | |
| TPOS = 0x12 | |
| } | |
| If (_OSI ("Windows 2006")) | |
| { | |
| OSTB = 0x40 | |
| TPOS = 0x40 | |
| } | |
| If (_OSI ("Windows 2006 SP1")) | |
| { | |
| OSTB = 0x41 | |
| TPOS = 0x41 | |
| OSSP = One | |
| } | |
| If (_OSI ("Windows 2009")) | |
| { | |
| OSSP = One | |
| OSTB = 0x50 | |
| TPOS = 0x50 | |
| } | |
| If (_OSI ("Windows 2012")) | |
| { | |
| OSSP = One | |
| OSTB = 0x60 | |
| TPOS = 0x60 | |
| } | |
| If (_OSI ("Windows 2013")) | |
| { | |
| OSSP = One | |
| OSTB = 0x61 | |
| TPOS = 0x61 | |
| } | |
| If (_OSI ("Windows 2015")) | |
| { | |
| OSSP = One | |
| OSTB = 0x70 | |
| TPOS = 0x70 | |
| } | |
| If (_OSI ("Linux")) | |
| { | |
| LINX = One | |
| OSTB = 0x80 | |
| TPOS = 0x80 | |
| } | |
| } | |
| ElseIf (CondRefOf (\_OS)) | |
| { | |
| If (SEQL (_OS, "Microsoft Windows")) | |
| { | |
| OSTB = One | |
| TPOS = One | |
| } | |
| ElseIf (SEQL (_OS, "Microsoft WindowsME: Millennium Edition")) | |
| { | |
| OSTB = 0x02 | |
| TPOS = 0x02 | |
| } | |
| ElseIf (SEQL (_OS, "Microsoft Windows NT")) | |
| { | |
| OSTB = 0x04 | |
| TPOS = 0x04 | |
| } | |
| Else | |
| { | |
| OSTB = Zero | |
| TPOS = Zero | |
| } | |
| } | |
| Else | |
| { | |
| OSTB = Zero | |
| TPOS = Zero | |
| } | |
| } | |
| Return (OSTB) /* \OSTB */ | |
| } | |
| Name (BUFN, Zero) | |
| Name (MBUF, Buffer (0x1000){}) | |
| OperationRegion (MDBG, SystemMemory, 0x7BEF5018, 0x00001004) | |
| Field (MDBG, AnyAcc, Lock, Preserve) | |
| { | |
| MDG0, 32768 | |
| } | |
| Method (DB2H, 1, Serialized) | |
| { | |
| SHOW (Arg0) | |
| MDGC (0x20) | |
| MDG0 = MBUF /* \MBUF */ | |
| } | |
| Method (DW2H, 1, Serialized) | |
| { | |
| Local0 = Arg0 | |
| Local1 = (Arg0 >> 0x08) | |
| Local0 &= 0xFF | |
| Local1 &= 0xFF | |
| DB2H (Local1) | |
| BUFN-- | |
| DB2H (Local0) | |
| } | |
| Method (DD2H, 1, Serialized) | |
| { | |
| Local0 = Arg0 | |
| Local1 = (Arg0 >> 0x10) | |
| Local0 &= 0xFFFF | |
| Local1 &= 0xFFFF | |
| DW2H (Local1) | |
| BUFN-- | |
| DW2H (Local0) | |
| } | |
| Method (MBGS, 1, Serialized) | |
| { | |
| Local0 = SizeOf (Arg0) | |
| Name (BUFS, Buffer (Local0){}) | |
| BUFS = Arg0 | |
| MDGC (0x20) | |
| While (Local0) | |
| { | |
| MDGC (DerefOf (BUFS [(SizeOf (Arg0) - Local0)])) | |
| Local0-- | |
| } | |
| MDG0 = MBUF /* \MBUF */ | |
| } | |
| Method (SHOW, 1, Serialized) | |
| { | |
| MDGC (NTOC ((Arg0 >> 0x04))) | |
| MDGC (NTOC (Arg0)) | |
| } | |
| Method (LINE, 0, Serialized) | |
| { | |
| Local0 = BUFN /* \BUFN */ | |
| Local0 &= 0x0F | |
| While (Local0) | |
| { | |
| MDGC (Zero) | |
| Local0++ | |
| Local0 &= 0x0F | |
| } | |
| } | |
| Method (MDGC, 1, Serialized) | |
| { | |
| MBUF [BUFN] = Arg0 | |
| BUFN += One | |
| If ((BUFN > 0x0FFF)) | |
| { | |
| BUFN &= 0x0FFF | |
| UP_L (One) | |
| } | |
| } | |
| Method (UP_L, 1, Serialized) | |
| { | |
| Local2 = Arg0 | |
| Local2 <<= 0x04 | |
| MOVE (Local2) | |
| Local3 = (0x1000 - Local2) | |
| While (Local2) | |
| { | |
| MBUF [Local3] = Zero | |
| Local3++ | |
| Local2-- | |
| } | |
| } | |
| Method (MOVE, 1, Serialized) | |
| { | |
| Local4 = Arg0 | |
| BUFN = Zero | |
| Local5 = (0x1000 - Local4) | |
| While (Local5) | |
| { | |
| Local5-- | |
| MBUF [BUFN] = DerefOf (MBUF [Local4]) | |
| BUFN++ | |
| Local4++ | |
| } | |
| } | |
| Method (NTOC, 1, Serialized) | |
| { | |
| Local0 = (Arg0 & 0x0F) | |
| If ((Local0 < 0x0A)) | |
| { | |
| Local0 += 0x30 | |
| } | |
| Else | |
| { | |
| Local0 += 0x37 | |
| } | |
| Return (Local0) | |
| } | |
| Scope (_SB) | |
| { | |
| Device (PLTF) | |
| { | |
| Name (_HID, "ACPI0010" /* Processor Container Device */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0A05") /* Generic Container Device */) // _CID: Compatible ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Device (C000) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| } | |
| Device (C001) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| } | |
| Device (C002) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| } | |
| Device (C003) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| } | |
| Device (C004) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| } | |
| Device (C005) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x05) // _UID: Unique ID | |
| } | |
| Device (C006) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x06) // _UID: Unique ID | |
| } | |
| Device (C007) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x07) // _UID: Unique ID | |
| } | |
| Device (C008) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x08) // _UID: Unique ID | |
| } | |
| Device (C009) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x09) // _UID: Unique ID | |
| } | |
| Device (C00A) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0A) // _UID: Unique ID | |
| } | |
| Device (C00B) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0B) // _UID: Unique ID | |
| } | |
| Device (C00C) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0C) // _UID: Unique ID | |
| } | |
| Device (C00D) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0D) // _UID: Unique ID | |
| } | |
| Device (C00E) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0E) // _UID: Unique ID | |
| } | |
| Device (C00F) | |
| { | |
| Name (_HID, "ACPI0007" /* Processor Device */) // _HID: Hardware ID | |
| Name (_UID, 0x0F) // _UID: Unique ID | |
| } | |
| } | |
| } | |
| Name (_S0, Package (0x04) // _S0_: S0 System State | |
| { | |
| Zero, | |
| Zero, | |
| Zero, | |
| Zero | |
| }) | |
| If ((DAS3 == One)) | |
| { | |
| Name (_S3, Package (0x04) // _S3_: S3 System State | |
| { | |
| 0x03, | |
| 0x03, | |
| Zero, | |
| Zero | |
| }) | |
| } | |
| Name (_S4, Package (0x04) // _S4_: S4 System State | |
| { | |
| 0x04, | |
| 0x04, | |
| Zero, | |
| Zero | |
| }) | |
| Name (_S5, Package (0x04) // _S5_: S5 System State | |
| { | |
| 0x05, | |
| 0x05, | |
| Zero, | |
| Zero | |
| }) | |
| Scope (_GPE) | |
| { | |
| Method (_L08, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF | |
| { | |
| If ((TBEN == Zero)) | |
| { | |
| Notify (\_SB.PCI0.GPP0, 0x02) // Device Wake | |
| Notify (\_SB.PCI0.GPP1, 0x02) // Device Wake | |
| } | |
| Notify (\_SB.PCI0.GPP5, 0x02) // Device Wake | |
| Notify (\_SB.PCI0.GP17, 0x02) // Device Wake | |
| Notify (\_SB.PCI0.GP18, 0x02) // Device Wake | |
| } | |
| Method (_L0D, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF | |
| { | |
| Notify (\_SB.PCI0.GPP2, 0x02) // Device Wake | |
| } | |
| Method (_L0E, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF | |
| { | |
| Notify (\_SB.PCI0.GPP4, 0x02) // Device Wake | |
| } | |
| Method (_L0F, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF | |
| { | |
| Notify (\_SB.PCI0.GPP3, 0x02) // Device Wake | |
| } | |
| Method (_L19, 0, NotSerialized) // _Lxx: Level-Triggered GPE, xx=0x00-0xFF | |
| { | |
| Notify (\_SB.PCI0.GP17.XHC0, 0x02) // Device Wake | |
| Notify (\_SB.PCI0.GP17.XHC1, 0x02) // Device Wake | |
| Notify (\_SB.PCI0.GP19.XHC2, 0x02) // Device Wake | |
| } | |
| } | |
| Name (PICM, Zero) | |
| Name (GPIC, Zero) | |
| Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model | |
| { | |
| PICM = Arg0 | |
| GPIC = Arg0 | |
| If (PICM) | |
| { | |
| \_SB.DSPI () | |
| If (NAPC) | |
| { | |
| \_SB.PCI0.NAPE () | |
| } | |
| } | |
| } | |
| Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep | |
| { | |
| IO6C = 0xCF | |
| SPTS (Arg0) | |
| If ((Arg0 == One)) | |
| { | |
| \_SB.S80H (0x51) | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| \_SB.S80H (0x53) | |
| SLPS = One | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| \_SB.S80H (0x54) | |
| SLPS = One | |
| RSTU = One | |
| \_SB.PCI0.LPC0.EC0.PRTC = One | |
| } | |
| If ((Arg0 == 0x05)) | |
| { | |
| \_SB.S80H (0x55) | |
| If ((WKPM == One)) | |
| { | |
| PWDE = One | |
| } | |
| BCMD = 0x90 | |
| \_SB.BSMI (Zero) | |
| \_SB.GSMI (0x03) | |
| } | |
| If (CondRefOf (\_SB.TPM2.PTS)) | |
| { | |
| \_SB.TPM2.PTS (Arg0) | |
| } | |
| \_SB.PCI0.LPC0.EC0.BTSM = Zero | |
| \_SB.PCI0.LPC0.EC0.BTBM = Zero | |
| \_SB.APTS (Arg0) | |
| MPTS (Arg0) | |
| } | |
| Method (_WAK, 1, NotSerialized) // _WAK: Wake | |
| { | |
| SWAK (Arg0) | |
| \_SB.AWAK (Arg0) | |
| If (((Arg0 == 0x03) || (Arg0 == 0x04))) | |
| { | |
| If ((GPIC != Zero)) | |
| { | |
| \_SB.DSPI () | |
| If (NAPC) | |
| { | |
| \_SB.PCI0.NAPE () | |
| } | |
| } | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| \_SB.S80H (0xE3) | |
| Notify (\_SB.PWRB, 0x02) // Device Wake | |
| } | |
| If ((Arg0 == 0x04)) | |
| { | |
| \_SB.S80H (0xE4) | |
| Notify (\_SB.PWRB, 0x02) // Device Wake | |
| } | |
| \_SB.ACAD.ACDC = 0xFF | |
| MWAK (Arg0) | |
| Return (Zero) | |
| } | |
| Scope (_SB) | |
| { | |
| Device (PWRB) | |
| { | |
| Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0B) | |
| } | |
| } | |
| Device (PCI0) | |
| { | |
| Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID | |
| Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_BBN, Zero) // _BBN: BIOS Bus Number | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| If ((GPIC != Zero)) | |
| { | |
| DSPI () | |
| If (NAPC) | |
| { | |
| NAPE () | |
| } | |
| } | |
| OSTP () | |
| } | |
| Name (SUPP, Zero) | |
| Name (CTRL, Zero) | |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities | |
| { | |
| CreateDWordField (Arg3, Zero, CDW1) | |
| CreateDWordField (Arg3, 0x04, CDW2) | |
| CreateDWordField (Arg3, 0x08, CDW3) | |
| If ((Arg0 == ToUUID ("33db4d5b-1ff7-401c-9657-7441c03dd766") /* PCI Host Bridge Device */)) | |
| { | |
| SUPP = CDW2 /* \_SB_.PCI0._OSC.CDW2 */ | |
| CTRL = CDW3 /* \_SB_.PCI0._OSC.CDW3 */ | |
| If ((TBEN == One)) | |
| { | |
| If ((TBNH != Zero)) | |
| { | |
| CTRL &= 0xFFFFFFF5 | |
| } | |
| Else | |
| { | |
| CTRL &= 0xFFFFFFF4 | |
| } | |
| } | |
| If (((SUPP & 0x16) != 0x16)) | |
| { | |
| CTRL &= 0x1E | |
| } | |
| CTRL &= 0x1D | |
| If (~(CDW1 & One)) | |
| { | |
| If ((CTRL & One)){} | |
| If ((CTRL & 0x04)){} | |
| If ((CTRL & 0x10)){} | |
| } | |
| If ((Arg1 != One)) | |
| { | |
| CDW1 |= 0x08 | |
| } | |
| If ((CDW3 != CTRL)) | |
| { | |
| CDW1 |= 0x10 | |
| } | |
| CDW3 = CTRL /* \_SB_.PCI0.CTRL */ | |
| Return (Arg3) | |
| } | |
| Else | |
| { | |
| CDW1 |= 0x04 | |
| Return (Arg3) | |
| } | |
| } | |
| Method (TOM, 0, NotSerialized) | |
| { | |
| Local0 = (TOML * 0x00010000) | |
| Local1 = (TOMH * 0x01000000) | |
| Local0 += Local1 | |
| Return (Local0) | |
| } | |
| Name (CRES, ResourceTemplate () | |
| { | |
| WordBusNumber (ResourceProducer, MinFixed, MaxFixed, SubDecode, | |
| 0x0000, // Granularity | |
| 0x0000, // Range Minimum | |
| 0x00FF, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0x0100, // Length | |
| 0x00,, ) | |
| WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, | |
| 0x0000, // Granularity | |
| 0x0000, // Range Minimum | |
| 0x0CF7, // Range Maximum | |
| 0x0000, // Translation Offset | |
| 0x0CF8, // Length | |
| 0x00,, , 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, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000A0000, // Range Minimum | |
| 0x000BFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00020000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadOnly, | |
| 0x00000000, // Granularity | |
| 0x000C0000, // Range Minimum | |
| 0x000C3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadOnly, | |
| 0x00000000, // Granularity | |
| 0x000C4000, // Range Minimum | |
| 0x000C7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly, | |
| 0x00000000, // Granularity | |
| 0x000C8000, // Range Minimum | |
| 0x000CBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadOnly, | |
| 0x00000000, // Granularity | |
| 0x000CC000, // Range Minimum | |
| 0x000CFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D0000, // Range Minimum | |
| 0x000D3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D4000, // Range Minimum | |
| 0x000D7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000D8000, // Range Minimum | |
| 0x000DBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000DC000, // Range Minimum | |
| 0x000DFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E0000, // Range Minimum | |
| 0x000E3FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E4000, // Range Minimum | |
| 0x000E7FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000E8000, // Range Minimum | |
| 0x000EBFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x000EC000, // Range Minimum | |
| 0x000EFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00004000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0x80000000, // Range Minimum | |
| 0xF7FFFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x78000000, // Length | |
| 0x00,, _Y00, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFC000000, // Range Minimum | |
| 0xFEAFFFFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x02B00000, // Length | |
| 0x00,, _Y01, AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFED45000, // Range Minimum | |
| 0xFED814FF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x0003C500, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFED81900, // Range Minimum | |
| 0xFED81FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00000700, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFEDC0000, // Range Minimum | |
| 0xFEDC0FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00001000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| DWordMemory (ResourceProducer, SubDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x00000000, // Granularity | |
| 0xFEDC6000, // Range Minimum | |
| 0xFEDC6FFF, // Range Maximum | |
| 0x00000000, // Translation Offset | |
| 0x00001000, // Length | |
| 0x00,, , AddressRangeMemory, TypeStatic) | |
| IO (Decode16, | |
| 0x0CF8, // Range Minimum | |
| 0x0CF8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| ) | |
| QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x0000000000000000, // Granularity | |
| 0x0000000000000000, // Range Minimum | |
| 0x0000000000000000, // Range Maximum | |
| 0x0000000000000000, // Translation Offset | |
| 0x0000000000000000, // Length | |
| ,, _Y02, AddressRangeMemory, TypeStatic) | |
| QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, | |
| 0x0000000000000000, // Granularity | |
| 0x0000000000000000, // Range Minimum | |
| 0x0000000000000000, // Range Maximum | |
| 0x0000000000000000, // Translation Offset | |
| 0x0000000000000000, // Length | |
| ,, _Y03, AddressRangeMemory, TypeStatic) | |
| }) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateDWordField (CRES, \_SB.PCI0._Y00._MIN, BTMN) // _MIN: Minimum Base Address | |
| CreateDWordField (CRES, \_SB.PCI0._Y00._MAX, BTMX) // _MAX: Maximum Base Address | |
| CreateDWordField (CRES, \_SB.PCI0._Y00._LEN, BTLN) // _LEN: Length | |
| CreateDWordField (CRES, \_SB.PCI0._Y01._MIN, BTN1) // _MIN: Minimum Base Address | |
| CreateDWordField (CRES, \_SB.PCI0._Y01._MAX, BTX1) // _MAX: Maximum Base Address | |
| CreateDWordField (CRES, \_SB.PCI0._Y01._LEN, BTL1) // _LEN: Length | |
| BTMN = TOM () | |
| BTMX = (PCBA - One) | |
| BTLN = (PCBA - BTMN) /* \_SB_.PCI0._CRS.BTMN */ | |
| BTN1 = (PCBL + One) | |
| BTL1 = (BTX1 - BTN1) /* \_SB_.PCI0._CRS.BTN1 */ | |
| BTL1 += One | |
| If ((MM64 == One)) | |
| { | |
| CreateQWordField (CRES, \_SB.PCI0._Y02._MIN, M1MN) // _MIN: Minimum Base Address | |
| CreateQWordField (CRES, \_SB.PCI0._Y02._MAX, M1MX) // _MAX: Maximum Base Address | |
| CreateQWordField (CRES, \_SB.PCI0._Y02._LEN, M1LN) // _LEN: Length | |
| M1MN = HMB1 /* \HMB1 */ | |
| M1MX = HMM1 /* \HMM1 */ | |
| M1LN = HML1 /* \HML1 */ | |
| CreateQWordField (CRES, \_SB.PCI0._Y03._MIN, M2MN) // _MIN: Minimum Base Address | |
| CreateQWordField (CRES, \_SB.PCI0._Y03._MAX, M2MX) // _MAX: Maximum Base Address | |
| CreateQWordField (CRES, \_SB.PCI0._Y03._LEN, M2LN) // _LEN: Length | |
| M2MN = HMB2 /* \HMB2 */ | |
| M2MX = HMM2 /* \HMM2 */ | |
| M2LN = HML2 /* \HML2 */ | |
| } | |
| Return (CRES) /* \_SB_.PCI0.CRES */ | |
| } | |
| Device (MEMR) | |
| { | |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
| Name (BAR3, 0xA0000000) | |
| Name (MEM1, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadWrite, | |
| 0x00000000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y04) | |
| Memory32Fixed (ReadWrite, | |
| 0x00000000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y05) | |
| Memory32Fixed (ReadWrite, | |
| 0x00000000, // Address Base | |
| 0x00000000, // Address Length | |
| _Y06) | |
| }) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y04._BAS, MB01) // _BAS: Base Address | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y04._LEN, ML01) // _LEN: Length | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y05._BAS, MB02) // _BAS: Base Address | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y05._LEN, ML02) // _LEN: Length | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y06._BAS, MB03) // _BAS: Base Address | |
| CreateDWordField (MEM1, \_SB.PCI0.MEMR._Y06._LEN, ML03) // _LEN: Length | |
| If (GPIC) | |
| { | |
| MB01 = 0xFEC00000 | |
| MB02 = 0xFEE00000 | |
| ML01 = 0x1000 | |
| If (NAPC) | |
| { | |
| ML01 += 0x1000 | |
| } | |
| ML02 = 0x1000 | |
| } | |
| If ((BAR3 != 0xFFF00000)) | |
| { | |
| MB03 = BAR3 /* \_SB_.PCI0.MEMR.BAR3 */ | |
| ML03 = 0x00100000 | |
| } | |
| Return (MEM1) /* \_SB_.PCI0.MEMR.MEM1 */ | |
| } | |
| } | |
| Mutex (NAPM, 0x00) | |
| Method (NAPE, 0, NotSerialized) | |
| { | |
| Acquire (NAPM, 0xFFFF) | |
| Local0 = (PCBA + 0xB8) | |
| OperationRegion (VARM, SystemMemory, Local0, 0x08) | |
| Field (VARM, DWordAcc, NoLock, Preserve) | |
| { | |
| NAPX, 32, | |
| NAPD, 32 | |
| } | |
| Local1 = NAPX /* \_SB_.PCI0.NAPE.NAPX */ | |
| NAPX = 0x14300000 | |
| Local0 = NAPD /* \_SB_.PCI0.NAPE.NAPD */ | |
| Local0 &= 0xFFFFFFEF | |
| NAPD = Local0 | |
| NAPX = Local1 | |
| Release (NAPM) | |
| } | |
| Name (PR00, Package (0x0E) | |
| { | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| Zero, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| One, | |
| LNKF, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x02, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x03, | |
| LNKH, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x03, | |
| LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (AR00, Package (0x0E) | |
| { | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| Zero, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| One, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x02, | |
| Zero, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| Zero, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| One, | |
| Zero, | |
| 0x15 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x02, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0002FFFF, | |
| 0x03, | |
| Zero, | |
| 0x17 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| Zero, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| One, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| 0x02, | |
| Zero, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| Zero, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| One, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x02, | |
| Zero, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x03, | |
| Zero, | |
| 0x13 | |
| } | |
| }) | |
| Name (NR00, Package (0x0E) | |
| { | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| Zero, | |
| Zero, | |
| 0x20 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| One, | |
| Zero, | |
| 0x21 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x02, | |
| Zero, | |
| 0x22 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x03, | |
| Zero, | |
| 0x23 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x04, | |
| Zero, | |
| 0x20 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x05, | |
| Zero, | |
| 0x21 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0001FFFF, | |
| 0x06, | |
| Zero, | |
| 0x22 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| Zero, | |
| Zero, | |
| 0x24 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| One, | |
| Zero, | |
| 0x25 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0008FFFF, | |
| 0x02, | |
| Zero, | |
| 0x26 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| Zero, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| One, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x02, | |
| Zero, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0x0014FFFF, | |
| 0x03, | |
| Zero, | |
| 0x13 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR00) /* \_SB_.PCI0.NR00 */ | |
| } | |
| Else | |
| { | |
| Return (AR00) /* \_SB_.PCI0.AR00 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR00) /* \_SB_.PCI0.PR00 */ | |
| } | |
| } | |
| Device (GPP0) | |
| { | |
| Name (_ADR, 0x00010001) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x08, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x08, Zero)) | |
| } | |
| } | |
| Name (PR01, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (AR01, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x10 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x11 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x12 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x13 | |
| } | |
| }) | |
| Name (NR01, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x18 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x19 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x1A | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x1B | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR01) /* \_SB_.PCI0.GPP0.NR01 */ | |
| } | |
| Else | |
| { | |
| Return (AR01) /* \_SB_.PCI0.GPP0.AR01 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR01) /* \_SB_.PCI0.GPP0.PR01 */ | |
| } | |
| } | |
| Device (VGA) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Name (DOSA, Zero) | |
| Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
| { | |
| DOSA = Arg0 | |
| } | |
| Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
| { | |
| Return (Package (0x05) | |
| { | |
| 0x00010110, | |
| 0x00010210, | |
| 0x00010220, | |
| 0x00010230, | |
| 0x00010240 | |
| }) | |
| } | |
| Device (LCD) | |
| { | |
| Name (_ADR, 0x0110) // _ADR: Address | |
| Name (BCLB, Package (0x34) | |
| { | |
| 0x5A, | |
| 0x3C, | |
| 0x02, | |
| 0x04, | |
| 0x06, | |
| 0x08, | |
| 0x0A, | |
| 0x0C, | |
| 0x0E, | |
| 0x10, | |
| 0x12, | |
| 0x14, | |
| 0x16, | |
| 0x18, | |
| 0x1A, | |
| 0x1C, | |
| 0x1E, | |
| 0x20, | |
| 0x22, | |
| 0x24, | |
| 0x26, | |
| 0x28, | |
| 0x2A, | |
| 0x2C, | |
| 0x2E, | |
| 0x30, | |
| 0x32, | |
| 0x34, | |
| 0x36, | |
| 0x38, | |
| 0x3A, | |
| 0x3C, | |
| 0x3E, | |
| 0x40, | |
| 0x42, | |
| 0x44, | |
| 0x46, | |
| 0x48, | |
| 0x4A, | |
| 0x4C, | |
| 0x4E, | |
| 0x50, | |
| 0x52, | |
| 0x54, | |
| 0x56, | |
| 0x58, | |
| 0x5A, | |
| 0x5C, | |
| 0x5E, | |
| 0x60, | |
| 0x62, | |
| 0x64 | |
| }) | |
| Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels | |
| { | |
| Return (BCLB) /* \_SB_.PCI0.GPP0.VGA_.LCD_.BCLB */ | |
| } | |
| Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method | |
| { | |
| BRTL = Arg0 | |
| } | |
| } | |
| Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Device (HDAU) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (GPP1) | |
| { | |
| Name (_ADR, 0x00010002) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x08, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x08, Zero)) | |
| } | |
| } | |
| Name (PR02, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKF, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKH, | |
| Zero | |
| } | |
| }) | |
| Name (AR02, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x15 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x17 | |
| } | |
| }) | |
| Name (NR02, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x1C | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x1D | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x1E | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x1F | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR02) /* \_SB_.PCI0.GPP1.NR02 */ | |
| } | |
| Else | |
| { | |
| Return (AR02) /* \_SB_.PCI0.GPP1.AR02 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR02) /* \_SB_.PCI0.GPP1.PR02 */ | |
| } | |
| } | |
| Device (DEV0) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Device (DEV1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| Method (_RMV, 0, NotSerialized) // _RMV: Removal Status | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (GPP2) | |
| { | |
| Name (_ADR, 0x00010003) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x08, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x08, Zero)) | |
| } | |
| } | |
| Name (PR03, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (AR03, 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 (NR03, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x20 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x21 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x22 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x23 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR03) /* \_SB_.PCI0.GPP2.NR03 */ | |
| } | |
| Else | |
| { | |
| Return (AR03) /* \_SB_.PCI0.GPP2.AR03 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR03) /* \_SB_.PCI0.GPP2.PR03 */ | |
| } | |
| } | |
| Device (WWAN) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (GPP3) | |
| { | |
| Name (_ADR, 0x00010004) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x0F, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x0F, Zero)) | |
| } | |
| } | |
| Name (PR04, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKF, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKH, | |
| Zero | |
| } | |
| }) | |
| Name (AR04, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x15 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x17 | |
| } | |
| }) | |
| Name (NR04, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x24 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x25 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x26 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x27 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR04) /* \_SB_.PCI0.GPP3.NR04 */ | |
| } | |
| Else | |
| { | |
| Return (AR04) /* \_SB_.PCI0.GPP3.AR04 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR04) /* \_SB_.PCI0.GPP3.PR04 */ | |
| } | |
| } | |
| Device (RTL8) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (GPP4) | |
| { | |
| Name (_ADR, 0x00010005) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x0E, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x0E, Zero)) | |
| } | |
| } | |
| Name (PR05, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (AR05, 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 (NR05, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x28 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x29 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x2A | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x2B | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR05) /* \_SB_.PCI0.GPP4.NR05 */ | |
| } | |
| Else | |
| { | |
| Return (AR05) /* \_SB_.PCI0.GPP4.AR05 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR05) /* \_SB_.PCI0.GPP4.PR05 */ | |
| } | |
| } | |
| } | |
| Device (GPP5) | |
| { | |
| Name (_ADR, 0x00010006) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x08, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x08, Zero)) | |
| } | |
| } | |
| Name (PR06, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKF, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKH, | |
| Zero | |
| } | |
| }) | |
| Name (AR06, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x15 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x17 | |
| } | |
| }) | |
| Name (NR06, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x2C | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x2D | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x2E | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x2F | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR06) /* \_SB_.PCI0.GPP5.NR06 */ | |
| } | |
| Else | |
| { | |
| Return (AR06) /* \_SB_.PCI0.GPP5.AR06 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR06) /* \_SB_.PCI0.GPP5.PR06 */ | |
| } | |
| } | |
| } | |
| Device (GPP6) | |
| { | |
| Name (_ADR, 0x00010007) // _ADR: Address | |
| Name (PR07, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKB, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKD, | |
| Zero | |
| } | |
| }) | |
| Name (AR07, 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 (NR07, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x30 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x31 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x32 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x33 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR07) /* \_SB_.PCI0.GPP6.NR07 */ | |
| } | |
| Else | |
| { | |
| Return (AR07) /* \_SB_.PCI0.GPP6.AR07 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR07) /* \_SB_.PCI0.GPP6.PR07 */ | |
| } | |
| } | |
| } | |
| Device (GP17) | |
| { | |
| Name (_ADR, 0x00080001) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x19, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x19, Zero)) | |
| } | |
| } | |
| Name (PR17, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKH, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKF, | |
| Zero | |
| } | |
| }) | |
| Name (AR17, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x17 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x15 | |
| } | |
| }) | |
| Name (NR17, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x32 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x33 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x30 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x31 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR17) /* \_SB_.PCI0.GP17.NR17 */ | |
| } | |
| Else | |
| { | |
| Return (AR17) /* \_SB_.PCI0.GP17.AR17 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR17) /* \_SB_.PCI0.GP17.PR17 */ | |
| } | |
| } | |
| Device (VGA) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Name (DOSA, Zero) | |
| Method (_DOS, 1, NotSerialized) // _DOS: Disable Output Switching | |
| { | |
| DOSA = Arg0 | |
| } | |
| Method (_DOD, 0, NotSerialized) // _DOD: Display Output Devices | |
| { | |
| Return (Package (0x07) | |
| { | |
| 0x00010110, | |
| 0x00010210, | |
| 0x00010220, | |
| 0x00010230, | |
| 0x00010240, | |
| 0x00031000, | |
| 0x00032000 | |
| }) | |
| } | |
| Device (LCD) | |
| { | |
| Name (_ADR, 0x0110) // _ADR: Address | |
| Name (BCLB, Package (0x34) | |
| { | |
| 0x5A, | |
| 0x3C, | |
| 0x02, | |
| 0x04, | |
| 0x06, | |
| 0x08, | |
| 0x0A, | |
| 0x0C, | |
| 0x0E, | |
| 0x10, | |
| 0x12, | |
| 0x14, | |
| 0x16, | |
| 0x18, | |
| 0x1A, | |
| 0x1C, | |
| 0x1E, | |
| 0x20, | |
| 0x22, | |
| 0x24, | |
| 0x26, | |
| 0x28, | |
| 0x2A, | |
| 0x2C, | |
| 0x2E, | |
| 0x30, | |
| 0x32, | |
| 0x34, | |
| 0x36, | |
| 0x38, | |
| 0x3A, | |
| 0x3C, | |
| 0x3E, | |
| 0x40, | |
| 0x42, | |
| 0x44, | |
| 0x46, | |
| 0x48, | |
| 0x4A, | |
| 0x4C, | |
| 0x4E, | |
| 0x50, | |
| 0x52, | |
| 0x54, | |
| 0x56, | |
| 0x58, | |
| 0x5A, | |
| 0x5C, | |
| 0x5E, | |
| 0x60, | |
| 0x62, | |
| 0x64 | |
| }) | |
| Method (_BCL, 0, NotSerialized) // _BCL: Brightness Control Levels | |
| { | |
| Return (BCLB) /* \_SB_.PCI0.GP17.VGA_.LCD_.BCLB */ | |
| } | |
| Method (_BCM, 1, NotSerialized) // _BCM: Brightness Control Method | |
| { | |
| BRTL = Arg0 | |
| } | |
| } | |
| } | |
| Device (PSP) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| } | |
| Device (ACP) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| Method (_WOV, 0, NotSerialized) | |
| { | |
| Return (WOVS) /* \WOVS */ | |
| } | |
| Device (AFD) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Name (_DSD, Package (0x04) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "acp-dsd-number-of-resources", | |
| 0x02 | |
| } | |
| }, | |
| ToUUID ("dbb8e3e6-5886-4ba6-8795-1319f52a966b") /* Hierarchical Data Extension */, | |
| Package (0x02) | |
| { | |
| Package (0x02) | |
| { | |
| "acp-dsd-resource-0", | |
| "RES0" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-dsd-resource-1", | |
| "RES1" | |
| } | |
| } | |
| }) | |
| Name (RES0, Package (0x02) | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x09) | |
| { | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-vendor-codec-name", | |
| "nuvoton" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-vendor-codec-id", | |
| 0x2020 | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-instance", | |
| "sp" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-mode", | |
| "master" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-format-mode", | |
| Zero | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-tx-enabled", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-rx-enabled", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-dsd-render-endpoint-category", | |
| "headphones" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-dsd-capture-endpoint-category", | |
| "headphones" | |
| } | |
| } | |
| }) | |
| Name (RES1, Package (0x02) | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x08) | |
| { | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-vendor-codec-name", | |
| "cirrus" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-vendor-codec-id", | |
| 0x00035A40 | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-instance", | |
| "hs" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-mode", | |
| "master" | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-controller-format-mode", | |
| Zero | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-tx-enabled", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-i2s-dsd-rx-enabled", | |
| Zero | |
| }, | |
| Package (0x02) | |
| { | |
| "acp-dsd-render-endpoint-category", | |
| "speakers" | |
| } | |
| } | |
| }) | |
| } | |
| } | |
| Device (AZAL) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| } | |
| Device (HDAU) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| } | |
| Device (XHC0) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (GPRW (0x19, 0x04)) | |
| } | |
| Device (RHUB) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Device (PRT1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x09, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC0.RHUB.PRT1.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x69, 0x0C, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, // i....... | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC0.RHUB.PRT1.PLD1 */ | |
| } | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x09, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC0.RHUB.PRT2.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x69, 0x0C, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, // i....... | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC0.RHUB.PRT2.PLD1 */ | |
| } | |
| } | |
| } | |
| } | |
| Device (XHC1) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (GPRW (0x19, 0x04)) | |
| } | |
| Device (RHUB) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Device (PRT1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x03, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT1.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x11, 0x0C, 0x80, 0x02, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT1.PLD1 */ | |
| } | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| Zero, | |
| 0xFF, | |
| Zero, | |
| Zero | |
| }) | |
| Name (UPC2, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x03, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT2.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x10, 0x0C, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT2.PLD1 */ | |
| } | |
| } | |
| Device (PRT3) | |
| { | |
| Name (_ADR, 0x03) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| Zero, | |
| 0xFF, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT3.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x91, 0x1C, 0x80, 0x03, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT3.PLD1 */ | |
| } | |
| } | |
| Device (PRT4) | |
| { | |
| Name (_ADR, 0x04) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| Zero, | |
| 0xFF, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT4.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x91, 0x1D, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT4.PLD1 */ | |
| } | |
| } | |
| Device (PRT5) | |
| { | |
| Name (_ADR, 0x05) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| Zero, | |
| 0xFF, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT5.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x91, 0x1D, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT5.PLD1 */ | |
| } | |
| } | |
| Device (PRT6) | |
| { | |
| Name (_ADR, 0x06) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x03, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT6.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x11, 0x0C, 0x80, 0x05, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT6.PLD1 */ | |
| } | |
| } | |
| Device (PRT7) | |
| { | |
| Name (_ADR, 0x07) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x03, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT7.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x11, 0x0C, 0x80, 0x02, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT7.PLD1 */ | |
| } | |
| } | |
| Device (PRT8) | |
| { | |
| Name (_ADR, 0x08) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0xFF, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT8.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x10, 0x0C, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP17.XHC1.RHUB.PRT8.PLD1 */ | |
| } | |
| } | |
| } | |
| } | |
| Device (MP2C) | |
| { | |
| Name (_ADR, 0x07) // _ADR: Address | |
| } | |
| } | |
| Device (GP18) | |
| { | |
| Name (_ADR, 0x00080002) // _ADR: Address | |
| Name (PR18, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKC, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKD, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKA, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKB, | |
| Zero | |
| } | |
| }) | |
| Name (AR18, 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 (NR18, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x2E | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x2F | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x2C | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x2D | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR18) /* \_SB_.PCI0.GP18.NR18 */ | |
| } | |
| Else | |
| { | |
| Return (AR18) /* \_SB_.PCI0.GP18.AR18 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR18) /* \_SB_.PCI0.GP18.PR18 */ | |
| } | |
| } | |
| Device (SATA) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| } | |
| } | |
| Device (GP19) | |
| { | |
| Name (_ADR, 0x00080003) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| If ((WKPM == One)) | |
| { | |
| Return (GPRW (0x08, 0x04)) | |
| } | |
| Else | |
| { | |
| Return (GPRW (0x08, Zero)) | |
| } | |
| } | |
| Name (PR19, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| LNKG, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| LNKH, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| LNKE, | |
| Zero | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| LNKF, | |
| Zero | |
| } | |
| }) | |
| Name (AR19, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x16 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x17 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x14 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x15 | |
| } | |
| }) | |
| Name (NR19, Package (0x04) | |
| { | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| Zero, | |
| Zero, | |
| 0x2A | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| One, | |
| Zero, | |
| 0x2B | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x02, | |
| Zero, | |
| 0x28 | |
| }, | |
| Package (0x04) | |
| { | |
| 0xFFFF, | |
| 0x03, | |
| Zero, | |
| 0x29 | |
| } | |
| }) | |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table | |
| { | |
| If (PICM) | |
| { | |
| If (NAPC) | |
| { | |
| Return (NR19) /* \_SB_.PCI0.GP19.NR19 */ | |
| } | |
| Else | |
| { | |
| Return (AR19) /* \_SB_.PCI0.GP19.AR19 */ | |
| } | |
| } | |
| Else | |
| { | |
| Return (PR19) /* \_SB_.PCI0.GP19.PR19 */ | |
| } | |
| } | |
| Device (XHC2) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake | |
| { | |
| Return (GPRW (0x19, 0x04)) | |
| } | |
| Device (RHUB) | |
| { | |
| Name (_ADR, Zero) // _ADR: Address | |
| Device (PRT1) | |
| { | |
| Name (_ADR, One) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x09, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP19.XHC2.RHUB.PRT1.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x11, 0x0C, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP19.XHC2.RHUB.PRT1.PLD1 */ | |
| } | |
| } | |
| Device (PRT2) | |
| { | |
| Name (_ADR, 0x02) // _ADR: Address | |
| Name (UPC1, Package (0x04) | |
| { | |
| 0xFF, | |
| 0x09, | |
| Zero, | |
| Zero | |
| }) | |
| Method (_UPC, 0, Serialized) // _UPC: USB Port Capabilities | |
| { | |
| Return (UPC1) /* \_SB_.PCI0.GP19.XHC2.RHUB.PRT2.UPC1 */ | |
| } | |
| Name (PLD1, Package (0x01) | |
| { | |
| Buffer (0x14) | |
| { | |
| /* 0000 */ 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ........ | |
| /* 0008 */ 0x11, 0x0C, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, // ........ | |
| /* 0010 */ 0xFF, 0xFF, 0xFF, 0xFF // .... | |
| } | |
| }) | |
| Method (_PLD, 0, Serialized) // _PLD: Physical Location of Device | |
| { | |
| Return (PLD1) /* \_SB_.PCI0.GP19.XHC2.RHUB.PRT2.PLD1 */ | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Device (HPET) | |
| { | |
| Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((HPEN == One)) | |
| { | |
| If ((OSTB >= 0x40)) | |
| { | |
| Return (0x0F) | |
| } | |
| HPEN = Zero | |
| Return (One) | |
| } | |
| Return (One) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IRQNoFlags () | |
| {0} | |
| IRQNoFlags () | |
| {8} | |
| Memory32Fixed (ReadOnly, | |
| 0xFED00000, // Address Base | |
| 0x00000400, // Address Length | |
| _Y07) | |
| }) | |
| CreateDWordField (BUF0, \_SB.PCI0.HPET._CRS._Y07._BAS, HPEB) // _BAS: Base Address | |
| Local0 = 0xFED00000 | |
| HPEB = (Local0 & 0xFFFFFC00) | |
| Return (BUF0) /* \_SB_.PCI0.HPET._CRS.BUF0 */ | |
| } | |
| } | |
| Device (SMBS) | |
| { | |
| Name (_ADR, 0x00140000) // _ADR: Address | |
| } | |
| Device (LPC0) | |
| { | |
| Name (_ADR, 0x00140003) // _ADR: Address | |
| 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, | |
| 0x0081, // Range Minimum | |
| 0x0081, // Range Maximum | |
| 0x01, // Alignment | |
| 0x0F, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00C0, // Range Minimum | |
| 0x00C0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x20, // Length | |
| ) | |
| DMA (Compatibility, NotBusMaster, Transfer8_16, ) | |
| {4} | |
| }) | |
| } | |
| Device (COPR) | |
| { | |
| Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x00F0, // Range Minimum | |
| 0x00F0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x0F, // Length | |
| ) | |
| IRQNoFlags () | |
| {13} | |
| }) | |
| } | |
| 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 | |
| ) | |
| IRQNoFlags () | |
| {2} | |
| }) | |
| } | |
| Device (RTC) | |
| { | |
| Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0070, // Range Minimum | |
| 0x0070, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| }) | |
| Name (BUF1, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0070, // Range Minimum | |
| 0x0070, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IRQNoFlags () | |
| {8} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| If ((HPEN == One)) | |
| { | |
| Return (BUF0) /* \_SB_.PCI0.LPC0.RTC_.BUF0 */ | |
| } | |
| Return (BUF1) /* \_SB_.PCI0.LPC0.RTC_.BUF1 */ | |
| } | |
| } | |
| 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 (TMR) | |
| { | |
| Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0040, // Range Minimum | |
| 0x0040, // Range Maximum | |
| 0x01, // Alignment | |
| 0x04, // Length | |
| ) | |
| }) | |
| Name (BUF1, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0040, // Range Minimum | |
| 0x0040, // Range Maximum | |
| 0x01, // Alignment | |
| 0x04, // Length | |
| ) | |
| IRQNoFlags () | |
| {0} | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| If ((HPEN == One)) | |
| { | |
| Return (BUF0) /* \_SB_.PCI0.LPC0.TMR_.BUF0 */ | |
| } | |
| Return (BUF1) /* \_SB_.PCI0.LPC0.TMR_.BUF1 */ | |
| } | |
| } | |
| Device (KBC0) | |
| { | |
| Name (_HID, EisaId ("FUJ7401")) // _HID: Hardware ID | |
| 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 (SYSR) | |
| { | |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IO (Decode16, | |
| 0x0010, // Range Minimum | |
| 0x0010, // Range Maximum | |
| 0x01, // Alignment | |
| 0x10, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0072, // Range Minimum | |
| 0x0072, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0080, // Range Minimum | |
| 0x0080, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x00B0, // Range Minimum | |
| 0x00B0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0092, // Range Minimum | |
| 0x0092, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0400, // Range Minimum | |
| 0x0400, // Range Maximum | |
| 0x01, // Alignment | |
| 0xD0, // Length | |
| ) | |
| IO (Decode16, | |
| 0x04D0, // Range Minimum | |
| 0x04D0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x04D6, // Range Minimum | |
| 0x04D6, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0C00, // Range Minimum | |
| 0x0C00, // Range Maximum | |
| 0x01, // Alignment | |
| 0x02, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0C14, // Range Minimum | |
| 0x0C14, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0C50, // Range Minimum | |
| 0x0C50, // Range Maximum | |
| 0x01, // Alignment | |
| 0x03, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0C6C, // Range Minimum | |
| 0x0C6C, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0C6F, // Range Minimum | |
| 0x0C6F, // Range Maximum | |
| 0x01, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0CD0, // Range Minimum | |
| 0x0CD0, // Range Maximum | |
| 0x01, // Alignment | |
| 0x0C, // Length | |
| ) | |
| }) | |
| } | |
| Device (MEM) | |
| { | |
| Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID | |
| Name (MSRC, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadOnly, | |
| 0x000E0000, // Address Base | |
| 0x00020000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFFF00000, // Address Base | |
| 0x00100000, // Address Length | |
| _Y08) | |
| }) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateDWordField (MSRC, \_SB.PCI0.LPC0.MEM._Y08._LEN, PSIZ) // _LEN: Length | |
| CreateDWordField (MSRC, \_SB.PCI0.LPC0.MEM._Y08._BAS, PBAS) // _BAS: Base Address | |
| PSIZ = ROMS /* \ROMS */ | |
| Local0 = (ROMS - One) | |
| PBAS = (Ones - Local0) | |
| Return (MSRC) /* \_SB_.PCI0.LPC0.MEM_.MSRC */ | |
| } | |
| } | |
| Method (ECOK, 0, NotSerialized) | |
| { | |
| If ((^EC0.OKEC == One)) | |
| { | |
| Return (One) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Device (EC0) | |
| { | |
| Name (_HID, EisaId ("PNP0C09") /* Embedded Controller Device */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_GPE, 0x0A) // _GPE: General Purpose Events | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Name (OKEC, Zero) | |
| Name (BATO, Zero) | |
| Name (BATN, Zero) | |
| Name (BATF, 0xC0) | |
| Mutex (Z009, 0x00) | |
| Mutex (QEVT, 0x00) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x0062, // Range Minimum | |
| 0x0062, // Range Maximum | |
| 0x00, // Alignment | |
| 0x01, // Length | |
| ) | |
| IO (Decode16, | |
| 0x0066, // Range Minimum | |
| 0x0066, // Range Maximum | |
| 0x00, // Alignment | |
| 0x01, // Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFE700000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Return (BUF0) /* \_SB_.PCI0.LPC0.EC0_._CRS.BUF0 */ | |
| } | |
| OperationRegion (ERAM, EmbeddedControl, Zero, 0xFF) | |
| Field (ERAM, ByteAcc, NoLock, Preserve) | |
| { | |
| SMPR, 8, | |
| SMST, 8, | |
| SMAD, 8, | |
| SMCM, 8, | |
| SMD0, 256, | |
| BCNT, 8, | |
| SMAA, 8, | |
| Offset (0x40), | |
| SW2S, 1, | |
| , 2, | |
| SCCT, 1, | |
| TRPM, 1, | |
| Offset (0x41), | |
| WIN7, 1, | |
| , 3, | |
| LXFG, 1, | |
| , 1, | |
| , 1, | |
| Offset (0x42), | |
| , 5, | |
| RWFG, 2, | |
| AVCF, 1, | |
| BBDA, 1, | |
| CIRB, 1, | |
| , 1, | |
| FNOV, 1, | |
| GFXT, 1, | |
| , 1, | |
| GP12, 1, | |
| Offset (0x44), | |
| Offset (0x45), | |
| , 2, | |
| NUCR, 1, | |
| , 1, | |
| WIN8, 1, | |
| Offset (0x46), | |
| Offset (0x47), | |
| CPTJ, 8, | |
| BTCR, 8, | |
| Offset (0x4B), | |
| MUTS, 1, | |
| MUTA, 1, | |
| BLEX, 1, | |
| , 1, | |
| , 1, | |
| , 1, | |
| , 1, | |
| Offset (0x4C), | |
| HKOK, 8, | |
| USBM, 1, | |
| SLMO, 1, | |
| , 1, | |
| LOSD, 1, | |
| , 3, | |
| Offset (0x4E), | |
| Offset (0x4F), | |
| F2DA, 8, | |
| DWNK, 1, | |
| Offset (0x51), | |
| Offset (0x52), | |
| LIDS, 1, | |
| WBSS, 1, | |
| , 1, | |
| PRDS, 1, | |
| Offset (0x53), | |
| Offset (0x58), | |
| RTMP, 8, | |
| ECT1, 8, | |
| ECT2, 8, | |
| RG5B, 8, | |
| FSPD, 16, | |
| Offset (0x5F), | |
| , 3, | |
| ENTP, 1, | |
| Offset (0x60), | |
| Offset (0x62), | |
| ECTH, 8, | |
| ECTL, 8, | |
| Offset (0x65), | |
| CMDF, 4, | |
| Offset (0x66), | |
| Offset (0x67), | |
| , 2, | |
| G6AC, 1, | |
| G6RE, 1, | |
| , 3, | |
| UCSP, 1, | |
| VOVA, 8, | |
| Offset (0x6B), | |
| DCBR, 8, | |
| GWKR, 8, | |
| Offset (0x6E), | |
| BTLW, 8, | |
| Offset (0x70), | |
| DSCP, 16, | |
| LACP, 16, | |
| DSVG, 16, | |
| Offset (0x77), | |
| BANA, 64, | |
| Offset (0x81), | |
| PL1S, 3, | |
| Offset (0x82), | |
| MBST, 8, | |
| MCUR, 16, | |
| MBRM, 16, | |
| MBCV, 16, | |
| LKBR, 8, | |
| LKBG, 8, | |
| LKBB, 8, | |
| Offset (0xA0), | |
| QBHK, 8, | |
| Offset (0xA3), | |
| CBSC, 8, | |
| MBTS, 1, | |
| MBTF, 1, | |
| , 5, | |
| BACR, 1, | |
| MBTC, 1, | |
| , 2, | |
| MBNH, 1, | |
| Offset (0xA6), | |
| , 4, | |
| , 1, | |
| BLWK, 1, | |
| , 1, | |
| Offset (0xA7), | |
| , 2, | |
| BERR, 1, | |
| FPRP, 1, | |
| , 3, | |
| TDEN, 1, | |
| Offset (0xAA), | |
| LKCC, 1, | |
| LKBE, 1, | |
| LKBC, 1, | |
| LKBS, 1, | |
| LKBA, 4, | |
| Offset (0xB2), | |
| RPM1, 8, | |
| RPM2, 8, | |
| Offset (0xB7), | |
| VGAT, 8, | |
| UCS0, 1, | |
| UCS3, 1, | |
| UCS5, 1, | |
| Offset (0xB9), | |
| CBLW, 8, | |
| PXST, 8, | |
| CMAX, 8, | |
| MCEA, 8, | |
| Offset (0xC0), | |
| , 1, | |
| JPKB, 1, | |
| , 3, | |
| IDCU, 1, | |
| , 1, | |
| RGBK, 1, | |
| LKBL, 4, | |
| LKBM, 4, | |
| TMOD, 8, | |
| Offset (0xC6), | |
| MCPE, 1, | |
| MCPW, 1, | |
| , 1, | |
| S5PO, 1, | |
| Offset (0xC7), | |
| Offset (0xCA), | |
| FN1R, 16, | |
| FN2R, 16, | |
| Offset (0xCF), | |
| DLYC, 8, | |
| EBPL, 1, | |
| Offset (0xD1), | |
| Offset (0xD4), | |
| PSHD, 8, | |
| PSLD, 8, | |
| Offset (0xDA), | |
| PSIN, 8, | |
| PSKB, 1, | |
| PSTP, 1, | |
| , 1, | |
| PWOL, 1, | |
| PRTC, 1, | |
| , 1, | |
| , 1, | |
| USBW, 1, | |
| OWNR, 8, | |
| Offset (0xDF), | |
| ECBW, 1, | |
| Offset (0xE0), | |
| DLYT, 8, | |
| DLY2, 8, | |
| VBRT, 8, | |
| BADJ, 8, | |
| Offset (0xE6), | |
| SFHK, 8, | |
| Offset (0xF0), | |
| ENDT, 8, | |
| Offset (0xF2), | |
| , 5, | |
| WLPW, 1, | |
| WLPS, 1, | |
| Offset (0xF3), | |
| Offset (0xF4), | |
| SFAN, 8, | |
| Offset (0xF8), | |
| BAAE, 1, | |
| S3WA, 1, | |
| BNAC, 1, | |
| , 1, | |
| EFS3, 1, | |
| S3WK, 1, | |
| RSAL, 1, | |
| Offset (0xF9), | |
| Offset (0xFA), | |
| VERN, 32 | |
| } | |
| OperationRegion (XEC1, SystemMemory, 0xFE700100, 0x0100) | |
| Field (XEC1, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x86), | |
| CTMP, 8 | |
| } | |
| OperationRegion (XEC3, SystemMemory, 0xFE700300, 0x0100) | |
| Field (XEC3, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x34), | |
| ATEL, 8, | |
| ATEH, 8, | |
| ATFL, 8, | |
| ATFH, 8, | |
| Offset (0x40), | |
| XW2S, 1, | |
| , 2, | |
| XCCT, 1, | |
| XRPM, 1, | |
| Offset (0x41), | |
| XIN7, 1, | |
| , 3, | |
| XXFG, 1, | |
| , 1, | |
| , 1, | |
| Offset (0x42), | |
| BTSM, 1, | |
| BTBM, 1, | |
| , 1, | |
| , 2, | |
| XWFG, 2, | |
| XVCF, 1, | |
| XBDA, 1, | |
| XIRB, 1, | |
| , 1, | |
| XNOV, 1, | |
| XFXT, 1, | |
| , 1, | |
| XP12, 1, | |
| Offset (0x44), | |
| Offset (0x45), | |
| , 2, | |
| XUCR, 1, | |
| , 1, | |
| XIN8, 1, | |
| Offset (0x46), | |
| Offset (0x47), | |
| XPTJ, 8, | |
| XTCR, 8, | |
| Offset (0x4A), | |
| XTPT, 1, | |
| Offset (0x4B), | |
| XUTS, 1, | |
| XUTA, 1, | |
| XLEX, 1, | |
| , 1, | |
| , 1, | |
| , 1, | |
| , 1, | |
| Offset (0x4C), | |
| XKOK, 8, | |
| XSBM, 1, | |
| XLMO, 1, | |
| , 1, | |
| XOSD, 1, | |
| , 3, | |
| Offset (0x4E), | |
| Offset (0x4F), | |
| X2DA, 8, | |
| XWNK, 1, | |
| Offset (0x52), | |
| XIDS, 1, | |
| XBSS, 1, | |
| , 1, | |
| XRDS, 1, | |
| Offset (0x58), | |
| XTMP, 8, | |
| XCT1, 8, | |
| XCT2, 8, | |
| XG5B, 8, | |
| XSPD, 16, | |
| Offset (0x5F), | |
| , 3, | |
| XNTP, 1, | |
| Offset (0x60), | |
| Offset (0x62), | |
| XCTH, 8, | |
| XCTL, 8, | |
| Offset (0x65), | |
| XMDF, 4, | |
| Offset (0x66), | |
| Offset (0x67), | |
| , 2, | |
| X6AC, 1, | |
| X6RE, 1, | |
| , 3, | |
| XCSP, 1, | |
| XOVA, 8, | |
| Offset (0x6B), | |
| XCBR, 8, | |
| XWKR, 8, | |
| Offset (0x6E), | |
| XTLW, 8, | |
| Offset (0x70), | |
| XSCP, 16, | |
| XACP, 16, | |
| XSVG, 16, | |
| Offset (0x77), | |
| XANA, 64, | |
| Offset (0x81), | |
| XL1S, 3, | |
| Offset (0x82), | |
| XBST, 8, | |
| XCUR, 16, | |
| XBRM, 16, | |
| XBCV, 16, | |
| XKBR, 8, | |
| XKBG, 8, | |
| XKBB, 8, | |
| Offset (0x9F), | |
| FNCK, 1, | |
| Offset (0xA0), | |
| XBHK, 8, | |
| Offset (0xA2), | |
| Offset (0xA3), | |
| XBSC, 8, | |
| XBTS, 1, | |
| XBTF, 1, | |
| , 5, | |
| XACR, 1, | |
| XBTC, 1, | |
| , 2, | |
| XBNH, 1, | |
| Offset (0xA6), | |
| , 4, | |
| , 1, | |
| XLWK, 1, | |
| , 1, | |
| Offset (0xA7), | |
| , 2, | |
| XERR, 1, | |
| XPRP, 1, | |
| , 3, | |
| XDEN, 1, | |
| ENWD, 1, | |
| TMPR, 1, | |
| Offset (0xAA), | |
| XKCC, 1, | |
| XKBE, 1, | |
| XKBC, 1, | |
| XKBS, 1, | |
| XKBA, 4, | |
| Offset (0xAF), | |
| Offset (0xB0), | |
| FNRL, 8, | |
| FNRH, 8, | |
| XPM1, 8, | |
| XPM2, 8, | |
| Offset (0xB7), | |
| XGAT, 8, | |
| XCS0, 1, | |
| XCS3, 1, | |
| XCS5, 1, | |
| Offset (0xB9), | |
| XBLW, 8, | |
| XXST, 8, | |
| XMAX, 8, | |
| XCEA, 8, | |
| XBID, 8, | |
| Offset (0xC0), | |
| , 1, | |
| XPKB, 1, | |
| , 3, | |
| XDCU, 1, | |
| , 1, | |
| XGBK, 1, | |
| XKBL, 4, | |
| XKBM, 4, | |
| XMOD, 8, | |
| Offset (0xC6), | |
| XCPE, 1, | |
| XCPW, 1, | |
| , 1, | |
| X5PO, 1, | |
| Offset (0xCA), | |
| XN1R, 16, | |
| XN2R, 16, | |
| Offset (0xCF), | |
| XLYC, 8, | |
| XBPL, 1, | |
| Offset (0xD4), | |
| XSHD, 8, | |
| XSLD, 8, | |
| Offset (0xDA), | |
| XSIN, 8, | |
| XSKB, 1, | |
| XSTP, 1, | |
| , 1, | |
| XWOL, 1, | |
| XRTC, 1, | |
| , 1, | |
| , 1, | |
| XSBW, 1, | |
| XWNR, 8, | |
| Offset (0xDF), | |
| XCBW, 1, | |
| Offset (0xE0), | |
| XLYT, 8, | |
| XLY2, 8, | |
| XBRT, 8, | |
| XADJ, 8, | |
| Offset (0xE6), | |
| XFHK, 8, | |
| Offset (0xF0), | |
| XNDT, 8, | |
| Offset (0xF2), | |
| , 5, | |
| XLPW, 1, | |
| XLPS, 1, | |
| Offset (0xF4), | |
| XFAN, 8, | |
| Offset (0xF8), | |
| XAAE, 1, | |
| X3WA, 1, | |
| XNAC, 1, | |
| , 1, | |
| XFS3, 1, | |
| X3WK, 1, | |
| XSAL, 1, | |
| Offset (0xFA), | |
| XERN, 32 | |
| } | |
| OperationRegion (XEC4, SystemMemory, 0xFE700400, 0x0100) | |
| Field (XEC4, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x6E), | |
| BATH, 8, | |
| BATL, 8 | |
| } | |
| OperationRegion (XECB, SystemMemory, 0xFE700B00, 0x0100) | |
| Field (XECB, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x90), | |
| CRLO, 8, | |
| CRHI, 8, | |
| FSLO, 8, | |
| FSHI, 8, | |
| CPUT, 8, | |
| GNLO, 8, | |
| GNHI, 8, | |
| FRPR, 8, | |
| HYST, 8, | |
| Offset (0xA0), | |
| Offset (0xA1), | |
| Offset (0xA2), | |
| Offset (0xA3), | |
| LPWM, 8, | |
| ANXC, 8, | |
| ANXD, 8, | |
| ANXO, 8, | |
| ANWD, 32, | |
| ANRD, 32 | |
| } | |
| OperationRegion (XECC, SystemMemory, 0xFE700C00, 0x0100) | |
| Field (XECC, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x01), | |
| PDCT, 8, | |
| Offset (0x4C), | |
| PDFV, 16, | |
| Offset (0x56), | |
| PDVH, 8, | |
| PVLI, 8, | |
| PDAH, 8, | |
| PDAL, 8 | |
| } | |
| OperationRegion (XECD, SystemMemory, 0xFE700D00, 0x0100) | |
| Field (XECD, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA0), | |
| VER1, 8, | |
| VER2, 8, | |
| RSV1, 8, | |
| RSV2, 8, | |
| CCI0, 8, | |
| CCI1, 8, | |
| CCI2, 8, | |
| CCI3, 8, | |
| CTL0, 8, | |
| CTL1, 8, | |
| CTL2, 8, | |
| CTL3, 8, | |
| CTL4, 8, | |
| CTL5, 8, | |
| CTL6, 8, | |
| CTL7, 8, | |
| MGI0, 8, | |
| MGI1, 8, | |
| MGI2, 8, | |
| MGI3, 8, | |
| MGI4, 8, | |
| MGI5, 8, | |
| MGI6, 8, | |
| MGI7, 8, | |
| MGI8, 8, | |
| MGI9, 8, | |
| MGIA, 8, | |
| MGIB, 8, | |
| MGIC, 8, | |
| MGID, 8, | |
| MGIE, 8, | |
| MGIF, 8, | |
| MGO0, 8, | |
| MGO1, 8, | |
| MGO2, 8, | |
| MGO3, 8, | |
| MGO4, 8, | |
| MGO5, 8, | |
| MGO6, 8, | |
| MGO7, 8, | |
| MGO8, 8, | |
| MGO9, 8, | |
| MGOA, 8, | |
| MGOB, 8, | |
| MGOC, 8, | |
| MGOD, 8, | |
| MGOE, 8, | |
| MGOF, 8 | |
| } | |
| Method (_REG, 2, NotSerialized) // _REG: Region Availability | |
| { | |
| If ((Arg0 == 0x03)) | |
| { | |
| OKEC = Arg1 | |
| GBAS () | |
| } | |
| } | |
| Method (_Q01, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = One | |
| } | |
| Method (_Q02, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x02 | |
| } | |
| Method (_Q03, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x03 | |
| } | |
| Method (_Q04, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x04 | |
| } | |
| Method (_Q09, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x09 | |
| } | |
| Method (_Q0C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x0C | |
| } | |
| Method (_Q0D, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x0D | |
| } | |
| Method (_Q10, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x10 | |
| } | |
| Method (_Q11, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x11 | |
| } | |
| Method (_Q15, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x15 | |
| } | |
| Method (GBAS, 0, NotSerialized) | |
| { | |
| If ((OKEC == One)) | |
| { | |
| BATF = Zero | |
| Local0 = MBTS /* \_SB_.PCI0.LPC0.EC0_.MBTS */ | |
| Local1 = SW2S /* \_SB_.PCI0.LPC0.EC0_.SW2S */ | |
| Local0 <<= 0x06 | |
| Local1 <<= One | |
| If (((BATO & 0x40) != Local0)) | |
| { | |
| BATF |= 0x40 | |
| } | |
| If (((BATO & 0x02) != Local1)) | |
| { | |
| BATF |= 0x02 | |
| } | |
| BATO = Zero | |
| BATO = (Local0 | Local1) | |
| } | |
| } | |
| Method (_Q20, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x20 | |
| If ((OKEC == One)) | |
| { | |
| GBAS () | |
| If ((0x40 & BATF)) | |
| { | |
| Notify (BAT1, 0x81) // Information Change | |
| } | |
| If ((0x02 & BATF)) | |
| { | |
| Notify (ACAD, 0x80) // Status Change | |
| } | |
| Notify (BAT1, 0x80) // Status Change | |
| } | |
| } | |
| Method (_Q21, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x21 | |
| } | |
| Method (_Q22, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x22 | |
| } | |
| Method (_Q28, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x28 | |
| } | |
| Method (_Q2A, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x2A | |
| Notify (BAT1, 0x81) // Information Change | |
| Notify (BAT1, 0x80) // Status Change | |
| } | |
| Method (_Q2E, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x2E | |
| BACR = Zero | |
| Notify (BAT1, 0x80) // Status Change | |
| } | |
| Method (_Q30, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x30 | |
| } | |
| Method (_Q31, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x31 | |
| } | |
| Method (_Q32, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x32 | |
| } | |
| Method (_Q33, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x33 | |
| } | |
| Method (_Q34, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x34 | |
| ENWD = Zero | |
| } | |
| Method (_Q37, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x37 | |
| } | |
| Method (_Q38, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x38 | |
| } | |
| Method (_Q39, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x39 | |
| } | |
| Method (_Q40, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x40 | |
| } | |
| Method (_Q46, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x46 | |
| } | |
| Method (_Q47, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x47 | |
| } | |
| Method (_Q49, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x49 | |
| } | |
| Method (_Q4C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x4C | |
| } | |
| Method (_Q4D, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x4D | |
| } | |
| Method (_Q50, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x50 | |
| } | |
| Method (_Q51, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x51 | |
| } | |
| Method (_Q52, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x52 | |
| } | |
| Method (_Q60, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x60 | |
| } | |
| Method (_Q69, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x69 | |
| } | |
| Method (_Q6E, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x6E | |
| } | |
| Method (_Q70, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x70 | |
| } | |
| Method (_Q71, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x71 | |
| } | |
| Method (_Q75, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x75 | |
| } | |
| Method (_Q76, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x76 | |
| } | |
| Method (_Q77, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x77 | |
| } | |
| Method (_Q78, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x78 | |
| } | |
| Method (_Q80, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x80 | |
| } | |
| Method (_Q83, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x83 | |
| } | |
| Method (_Q87, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x87 | |
| } | |
| Method (_Q88, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x88 | |
| } | |
| Method (_Q89, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x89 | |
| } | |
| Method (_Q8A, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8A | |
| } | |
| Method (_Q8B, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8B | |
| } | |
| Method (_Q8C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8C | |
| } | |
| Method (_Q8D, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8D | |
| } | |
| Method (_Q8E, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8E | |
| } | |
| Method (_Q8F, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x8F | |
| } | |
| Method (_Q91, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x91 | |
| } | |
| Method (_Q92, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x92 | |
| } | |
| Method (_Q93, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x93 | |
| } | |
| Method (_Q94, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x94 | |
| } | |
| Method (_Q96, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x96 | |
| } | |
| Method (_Q99, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x99 | |
| } | |
| Method (_Q9C, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0x9C | |
| If ((^VFCD.VPME == One)) | |
| { | |
| Notify (VFCD, 0x80) // Status Change | |
| } | |
| } | |
| Method (_QA0, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xA0 | |
| } | |
| Method (_QA8, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xA8 | |
| } | |
| Method (_QE2, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xE2 | |
| } | |
| Method (_QE3, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xE3 | |
| } | |
| Method (_QF1, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xF1 | |
| } | |
| Method (_QF2, 0, NotSerialized) // _Qxx: EC Query, xx=0x00-0xFF | |
| { | |
| P80H = 0xF2 | |
| } | |
| Scope (\_SB.PCI0.LPC0.EC0) | |
| { | |
| Device (VFCD) | |
| { | |
| Name (_HID, EisaId ("VLV0100")) // _HID: Hardware ID | |
| Name (VPME, Zero) | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| VPME = One | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| Method (SCHG, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| If ((One == Arg0)) | |
| { | |
| IO6C = 0xCC | |
| } | |
| Else | |
| { | |
| IO6C = 0xCD | |
| } | |
| Release (Z009) | |
| } | |
| } | |
| Method (STCT, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = Arg0 | |
| Local0 &= 0x7F | |
| CPUT = Local0 | |
| Release (Z009) | |
| } | |
| } | |
| Method (SGAN, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local1 = Zero | |
| Local0 = Arg0 | |
| Local1 = (Arg0 >> 0x08) | |
| Local0 &= 0xFF | |
| Local1 &= 0xFF | |
| GNHI = Local1 | |
| GNLO = Local0 | |
| Release (Z009) | |
| } | |
| } | |
| Method (SFRR, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = Arg0 | |
| Local0 &= 0xFF | |
| FRPR = Local0 | |
| Release (Z009) | |
| } | |
| } | |
| Method (SHTS, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = Arg0 | |
| Local0 &= 0xFF | |
| HYST = Local0 | |
| Release (Z009) | |
| } | |
| } | |
| Method (FANS, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local1 = Zero | |
| Local0 = Arg0 | |
| Local1 = (Arg0 >> 0x08) | |
| If (((Local0 >= Zero) & (Local0 <= 0x1C84))) | |
| { | |
| Local0 &= 0xFF | |
| Local1 &= 0xFF | |
| FSHI = Local1 | |
| FSLO = Local0 | |
| } | |
| ElseIf ((Local0 > 0x1C84)) | |
| { | |
| FSHI = 0x1C | |
| FSLO = 0x84 | |
| } | |
| Release (Z009) | |
| } | |
| } | |
| Method (FSSR, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = (FSHI << 0x08) | |
| Local0 += FSLO /* \_SB_.PCI0.LPC0.EC0_.FSLO */ | |
| Release (Z009) | |
| } | |
| Return (Local0) | |
| } | |
| Method (FANR, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = (FNRH << 0x08) | |
| Local0 += FNRL /* \_SB_.PCI0.LPC0.EC0_.FNRL */ | |
| Release (Z009) | |
| } | |
| Return (Local0) | |
| } | |
| Method (FANC, 0, NotSerialized) | |
| { | |
| If ((FNCK == One)) | |
| { | |
| Return (One) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (CHGR, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local1 = Zero | |
| Local0 = Arg0 | |
| Local1 = (Arg0 >> 0x08) | |
| If (((Local0 >= 0xFA) & (Local0 <= 0x09C4))) | |
| { | |
| Local0 &= 0xFF | |
| Local1 &= 0xFF | |
| CRHI = Local1 | |
| CRLO = Local0 | |
| } | |
| Release (Z009) | |
| } | |
| } | |
| Method (CHBV, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = Arg0 | |
| If (((Local0 >= Zero) & (Local0 <= 0x64))) | |
| { | |
| Local0 &= 0x7F | |
| LPWM = Local0 | |
| } | |
| Release (Z009) | |
| } | |
| } | |
| Method (RDDI, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x08) | |
| Local0 += 0x06 | |
| ANW4 (0x0C, 0x6C, 0x0137) | |
| ANW4 (0x0C, 0x6C, Local0) | |
| Sleep (0x14) | |
| ANR4 (0xC0, 0x70) | |
| Release (Z009) | |
| } | |
| Return (ANRD) /* \_SB_.PCI0.LPC0.EC0_.ANRD */ | |
| } | |
| Method (CABC, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x5515 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (GAMA, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x2615 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (WDBV, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x5115 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (WCDV, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x5315 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (WCMB, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x5E15 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (NORO, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = 0x1305 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (INOF, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = 0x2005 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (INON, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = 0x2105 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (MDAC, 1, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = (Arg0 << 0x10) | |
| Local0 += 0x3615 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (WRNE, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = 0x3905 | |
| ANW1 (0x08, 0x19, 0x10) | |
| ANW4 (0xC0, 0x6C, Local0) | |
| Release (Z009) | |
| } | |
| } | |
| Method (ANR1, 2, NotSerialized) | |
| { | |
| ANRD = Zero | |
| ANXD = Arg0 | |
| ANXO = Arg1 | |
| ANXC = 0x81 | |
| While ((ANXC & 0x80)) | |
| { | |
| Sleep (One) | |
| } | |
| } | |
| Method (ANW1, 3, NotSerialized) | |
| { | |
| ANWD = Zero | |
| ANXD = Arg0 | |
| ANXO = Arg1 | |
| Local0 = Arg2 | |
| ANWD = (Local0 & 0xFF) | |
| ANXC = 0x82 | |
| While ((ANXC & 0x80)) | |
| { | |
| Sleep (One) | |
| } | |
| } | |
| Method (ANR4, 2, NotSerialized) | |
| { | |
| ANRD = Zero | |
| ANXD = Arg0 | |
| ANXO = Arg1 | |
| ANXC = 0x83 | |
| While ((ANXC & 0x80)) | |
| { | |
| Sleep (One) | |
| } | |
| } | |
| Method (ANW4, 3, NotSerialized) | |
| { | |
| ANWD = Zero | |
| ANXD = Arg0 | |
| ANXO = Arg1 | |
| ANWD = Arg2 | |
| ANXC = 0x84 | |
| While ((ANXC & 0x80)) | |
| { | |
| Sleep (One) | |
| } | |
| } | |
| Method (DPCY, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| IO6C = 0xCB | |
| Release (Z009) | |
| } | |
| } | |
| Method (BATT, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = (BATH << 0x08) | |
| Local0 += BATL /* \_SB_.PCI0.LPC0.EC0_.BATL */ | |
| Local0 = ((Local0 - 0x0AAC) / 0x0A) | |
| Release (Z009) | |
| } | |
| Return (Local0) | |
| } | |
| Method (PDFW, 0, NotSerialized) | |
| { | |
| Return (PDFV) /* \_SB_.PCI0.LPC0.EC0_.PDFV */ | |
| } | |
| Method (BOID, 0, NotSerialized) | |
| { | |
| Return (XBID) /* \_SB_.PCI0.LPC0.EC0_.XBID */ | |
| } | |
| Method (PDCS, 0, NotSerialized) | |
| { | |
| Return (PDCT) /* \_SB_.PCI0.LPC0.EC0_.PDCT */ | |
| } | |
| Method (PDVL, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = (PDVH << 0x08) | |
| Local0 += PVLI /* \_SB_.PCI0.LPC0.EC0_.PVLI */ | |
| Release (Z009) | |
| } | |
| Return ((Local0 * 0x32)) | |
| } | |
| Method (PDAM, 0, NotSerialized) | |
| { | |
| If (!Acquire (Z009, 0x012C)) | |
| { | |
| Local0 = Zero | |
| Local0 = (PDAH << 0x08) | |
| Local0 += PDAL /* \_SB_.PCI0.LPC0.EC0_.PDAL */ | |
| Release (Z009) | |
| } | |
| Return ((Local0 * 0x0A)) | |
| } | |
| } | |
| } | |
| } | |
| Mutex (PSMX, 0x00) | |
| } | |
| } | |
| OperationRegion (PIRQ, SystemIO, 0x0C00, 0x02) | |
| Field (PIRQ, ByteAcc, NoLock, Preserve) | |
| { | |
| PIDX, 8, | |
| PDAT, 8 | |
| } | |
| IndexField (PIDX, PDAT, ByteAcc, NoLock, Preserve) | |
| { | |
| PIRA, 8, | |
| PIRB, 8, | |
| PIRC, 8, | |
| PIRD, 8, | |
| PIRE, 8, | |
| PIRF, 8, | |
| PIRG, 8, | |
| PIRH, 8, | |
| Offset (0x0C), | |
| SIRA, 8, | |
| SIRB, 8, | |
| SIRC, 8, | |
| SIRD, 8, | |
| PIRS, 8, | |
| Offset (0x13), | |
| HDAD, 8, | |
| Offset (0x17), | |
| SDCL, 8, | |
| Offset (0x1A), | |
| SDIO, 8, | |
| Offset (0x30), | |
| USB1, 8, | |
| Offset (0x34), | |
| USB3, 8, | |
| Offset (0x41), | |
| SATA, 8, | |
| Offset (0x62), | |
| GIOC, 8, | |
| Offset (0x70), | |
| I2C0, 8, | |
| I2C1, 8, | |
| I2C2, 8, | |
| I2C3, 8, | |
| URT0, 8, | |
| URT1, 8 | |
| } | |
| OperationRegion (KBDD, SystemIO, 0x64, One) | |
| Field (KBDD, ByteAcc, NoLock, Preserve) | |
| { | |
| PD64, 8 | |
| } | |
| Method (DSPI, 0, NotSerialized) | |
| { | |
| INTA (0x1F) | |
| INTB (0x1F) | |
| INTC (0x1F) | |
| INTD (0x1F) | |
| Local1 = PD64 /* \_SB_.PD64 */ | |
| If (Local1) | |
| { | |
| Local1 = Zero | |
| } | |
| PIRE = 0x1F | |
| PIRF = 0x1F | |
| PIRG = 0x1F | |
| PIRH = 0x1F | |
| } | |
| Method (INTA, 1, NotSerialized) | |
| { | |
| PIRA = Arg0 | |
| If (PICM) | |
| { | |
| HDAD = Arg0 | |
| SDCL = Arg0 | |
| } | |
| } | |
| Method (INTB, 1, NotSerialized) | |
| { | |
| PIRB = Arg0 | |
| } | |
| Method (INTC, 1, NotSerialized) | |
| { | |
| PIRC = Arg0 | |
| If (PICM) | |
| { | |
| USB1 = Arg0 | |
| USB3 = Arg0 | |
| } | |
| } | |
| Method (INTD, 1, NotSerialized) | |
| { | |
| PIRD = Arg0 | |
| If (PICM) | |
| { | |
| SATA = Arg0 | |
| } | |
| } | |
| Name (PRS1, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {3,5,6,10,11} | |
| }) | |
| Name (BUFA, ResourceTemplate () | |
| { | |
| IRQ (Level, ActiveLow, Shared, ) | |
| {15} | |
| }) | |
| Device (LNKA) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRA && (PIRA != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| INTA (0x1F) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRA) /* \_SB_.PIRA */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRA = Local0 | |
| } | |
| } | |
| Device (LNKB) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRB && (PIRB != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| INTB (0x1F) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRB) /* \_SB_.PIRB */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRB = Local0 | |
| } | |
| } | |
| Device (LNKC) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRC && (PIRC != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| INTC (0x1F) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRC) /* \_SB_.PIRC */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRC = Local0 | |
| } | |
| } | |
| Device (LNKD) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRD && (PIRD != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| INTD (0x1F) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRD) /* \_SB_.PIRD */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRD = Local0 | |
| } | |
| } | |
| Device (LNKE) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x05) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRE && (PIRE != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| PIRE = 0x1F | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRE) /* \_SB_.PIRE */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRE = Local0 | |
| } | |
| } | |
| 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 ((PIRF && (PIRF != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| PIRF = 0x1F | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRF) /* \_SB_.PIRF */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRF = Local0 | |
| } | |
| } | |
| Device (LNKG) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x07) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRG && (PIRG != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| PIRG = 0x1F | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRG) /* \_SB_.PIRG */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRG = Local0 | |
| } | |
| } | |
| Device (LNKH) | |
| { | |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID | |
| Name (_UID, 0x08) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((PIRH && (PIRH != 0x1F))) | |
| { | |
| Return (0x0B) | |
| } | |
| Else | |
| { | |
| Return (0x09) | |
| } | |
| } | |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings | |
| { | |
| Return (PRS1) /* \_SB_.PRS1 */ | |
| } | |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device | |
| { | |
| PIRH = 0x1F | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| CreateWordField (BUFA, One, IRQX) | |
| IRQX = (One << PIRH) /* \_SB_.PIRH */ | |
| Return (BUFA) /* \_SB_.BUFA */ | |
| } | |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings | |
| { | |
| CreateWordField (Arg0, One, IRA) | |
| FindSetRightBit (IRA, Local0) | |
| Local0-- | |
| PIRH = Local0 | |
| } | |
| } | |
| Method (GSMI, 1, NotSerialized) | |
| { | |
| APMD = Arg0 | |
| APMC = 0xE4 | |
| Sleep (0x02) | |
| } | |
| Method (S80H, 1, NotSerialized) | |
| { | |
| P80H = Arg0 | |
| } | |
| Method (BSMI, 1, NotSerialized) | |
| { | |
| APMD = Arg0 | |
| APMC = 0xBE | |
| Sleep (One) | |
| } | |
| Device (LID) | |
| { | |
| Name (_HID, EisaId ("PNP0C0D") /* Lid Device */) // _HID: Hardware ID | |
| Method (_LID, 0, NotSerialized) // _LID: Lid Status | |
| { | |
| Return (One) | |
| } | |
| } | |
| Device (ACAD) | |
| { | |
| Name (_HID, "ACPI0003" /* Power Source Device */) // _HID: Hardware ID | |
| Name (_PCL, Package (0x01) // _PCL: Power Consumer List | |
| { | |
| _SB | |
| }) | |
| Name (XX00, Buffer (0x03){}) | |
| Name (ACDC, 0xFF) | |
| Method (_PSR, 0, NotSerialized) // _PSR: Power Source | |
| { | |
| CreateWordField (XX00, Zero, SSZE) | |
| CreateByteField (XX00, 0x02, ACST) | |
| SSZE = 0x03 | |
| If (!Acquire (^^PCI0.LPC0.EC0.Z009, 0x012C)) | |
| { | |
| If ((^^PCI0.LPC0.EC0.OKEC == One)) | |
| { | |
| Local0 = ^^PCI0.LPC0.EC0.SW2S /* \_SB_.PCI0.LPC0.EC0_.SW2S */ | |
| } | |
| Else | |
| { | |
| Local0 = Zero | |
| } | |
| If ((Local0 != ACDC)) | |
| { | |
| If (Local0) | |
| { | |
| P80H = 0xECAC | |
| AFN4 (One) | |
| ACST = Zero | |
| } | |
| Else | |
| { | |
| P80H = 0xECDC | |
| AFN4 (0x02) | |
| ACST = One | |
| } | |
| ALIB (One, XX00) | |
| ACDC = Local0 | |
| } | |
| Release (^^PCI0.LPC0.EC0.Z009) | |
| } | |
| Return (Local0) | |
| } | |
| } | |
| Scope (\_SB) | |
| { | |
| Method (POSW, 1, NotSerialized) | |
| { | |
| If ((Arg0 & 0x8000)) | |
| { | |
| If ((Arg0 == 0xFFFF)) | |
| { | |
| Return (Ones) | |
| } | |
| Else | |
| { | |
| Local0 = ~Arg0 | |
| Local0++ | |
| Local0 &= 0xFFFF | |
| Return (Local0) | |
| } | |
| } | |
| Else | |
| { | |
| Return (Arg0) | |
| } | |
| } | |
| Device (BAT1) | |
| { | |
| Name (_HID, EisaId ("PNP0C0A") /* Control Method Battery */) // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Method (_PCL, 0, NotSerialized) // _PCL: Power Consumer List | |
| { | |
| Return (_SB) /* \_SB_ */ | |
| } | |
| Name (BTUR, Zero) | |
| Name (PBIF, Package (0x0D) | |
| { | |
| One, | |
| Ones, | |
| Ones, | |
| One, | |
| Ones, | |
| 0x64, | |
| 0x32, | |
| 0x0A, | |
| 0x19, | |
| "BAT1", | |
| " ", | |
| " ", | |
| " " | |
| }) | |
| Name (PBST, Package (0x04) | |
| { | |
| Zero, | |
| Ones, | |
| Ones, | |
| 0x2710 | |
| }) | |
| Name (B1ST, 0x0F) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (^^PCI0.LPC0.EC0.OKEC) | |
| { | |
| If (^^PCI0.LPC0.EC0.MBTS) | |
| { | |
| B1ST = 0x1F | |
| } | |
| Else | |
| { | |
| B1ST = 0x0F | |
| } | |
| } | |
| Else | |
| { | |
| B1ST = 0x0F | |
| } | |
| Return (B1ST) /* \_SB_.BAT1.B1ST */ | |
| } | |
| Method (_BIF, 0, NotSerialized) // _BIF: Battery Information | |
| { | |
| If (!Acquire (^^PCI0.LPC0.EC0.Z009, 0x012C)) | |
| { | |
| If (^^PCI0.LPC0.EC0.OKEC) | |
| { | |
| If (^^PCI0.LPC0.EC0.MBTS) | |
| { | |
| UPBI () | |
| } | |
| Else | |
| { | |
| IVBI () | |
| } | |
| } | |
| Else | |
| { | |
| IVBI () | |
| } | |
| Release (^^PCI0.LPC0.EC0.Z009) | |
| } | |
| Return (PBIF) /* \_SB_.BAT1.PBIF */ | |
| } | |
| Method (_BST, 0, NotSerialized) // _BST: Battery Status | |
| { | |
| If (!Acquire (^^PCI0.LPC0.EC0.Z009, 0x012C)) | |
| { | |
| If (^^PCI0.LPC0.EC0.OKEC) | |
| { | |
| If (^^PCI0.LPC0.EC0.MBTS) | |
| { | |
| UPBS () | |
| } | |
| Else | |
| { | |
| IVBS () | |
| } | |
| } | |
| Else | |
| { | |
| IVBS () | |
| } | |
| Release (^^PCI0.LPC0.EC0.Z009) | |
| } | |
| Return (PBST) /* \_SB_.BAT1.PBST */ | |
| } | |
| Method (UPBI, 0, NotSerialized) | |
| { | |
| PBIF [One] = ^^PCI0.LPC0.EC0.DSCP /* \_SB_.PCI0.LPC0.EC0_.DSCP */ | |
| PBIF [0x02] = ^^PCI0.LPC0.EC0.LACP /* \_SB_.PCI0.LPC0.EC0_.LACP */ | |
| PBIF [0x04] = ^^PCI0.LPC0.EC0.DSVG /* \_SB_.PCI0.LPC0.EC0_.DSVG */ | |
| PBIF [0x05] = (^^PCI0.LPC0.EC0.DSCP / 0x0A) | |
| PBIF [0x06] = (^^PCI0.LPC0.EC0.DSCP / 0x64) | |
| PBIF [0x09] = "MWL32b" | |
| If ((^^PCI0.LPC0.EC0.DSCP < 0x1770)) | |
| { | |
| PBIF [0x09] = "MWL32b" | |
| } | |
| If ((^^PCI0.LPC0.EC0.DSCP < 0x0BB8)) | |
| { | |
| PBIF [0x09] = "MWL31b" | |
| } | |
| } | |
| Method (UPBS, 0, NotSerialized) | |
| { | |
| If ((^^PCI0.LPC0.EC0.MBRM == Zero)) | |
| { | |
| BTUR = One | |
| } | |
| ElseIf ((BTUR == One)) | |
| { | |
| Notify (BAT1, 0x81) // Information Change | |
| Notify (BAT1, 0x80) // Status Change | |
| BTUR = Zero | |
| } | |
| Local5 = ^^PCI0.LPC0.EC0.MCUR /* \_SB_.PCI0.LPC0.EC0_.MCUR */ | |
| PBST [One] = POSW (Local5) | |
| Local5 = ^^PCI0.LPC0.EC0.MBRM /* \_SB_.PCI0.LPC0.EC0_.MBRM */ | |
| If ((^^PCI0.LPC0.EC0.BACR == One)) | |
| { | |
| Local5 = ((^^PCI0.LPC0.EC0.DSCP / 0x32) + ^^PCI0.LPC0.EC0.MBRM) /* \_SB_.PCI0.LPC0.EC0_.MBRM */ | |
| } | |
| Local5 = ^^PCI0.LPC0.EC0.MBRM /* \_SB_.PCI0.LPC0.EC0_.MBRM */ | |
| If (!(Local5 & 0x8000)) | |
| { | |
| If ((Local5 != DerefOf (PBST [0x02]))) | |
| { | |
| PBST [0x02] = Local5 | |
| } | |
| } | |
| PBST [0x03] = ^^PCI0.LPC0.EC0.MBCV /* \_SB_.PCI0.LPC0.EC0_.MBCV */ | |
| PBST [Zero] = ^^PCI0.LPC0.EC0.MBST /* \_SB_.PCI0.LPC0.EC0_.MBST */ | |
| } | |
| Method (IVBI, 0, NotSerialized) | |
| { | |
| PBIF [One] = Ones | |
| PBIF [0x02] = Ones | |
| PBIF [0x04] = Ones | |
| PBIF [0x09] = "Bad" | |
| PBIF [0x0A] = "Bad" | |
| PBIF [0x0B] = "Bad" | |
| PBIF [0x0C] = "Bad" | |
| ^^PCI0.LPC0.EC0.BANA = Zero | |
| } | |
| Method (IVBS, 0, NotSerialized) | |
| { | |
| PBST [Zero] = Zero | |
| PBST [One] = Ones | |
| PBST [0x02] = Ones | |
| PBST [0x03] = 0x2710 | |
| } | |
| Method (_BCT, 1, NotSerialized) // _BCT: Battery Charge Time | |
| { | |
| If (((Arg0 > 0x64) || (Arg0 < One))) | |
| { | |
| Return (Zero) | |
| } | |
| If (^^PCI0.LPC0.EC0.OKEC) | |
| { | |
| Local0 = Zero | |
| Local1 = Zero | |
| Local0 = (^^PCI0.LPC0.EC0.ATFH << 0x08) | |
| Local0 += ^^PCI0.LPC0.EC0.ATFL /* \_SB_.PCI0.LPC0.EC0_.ATFL */ | |
| If ((Local0 == 0xFFFF)) | |
| { | |
| Return (Ones) | |
| } | |
| Local1 = (Local0 * 0x3C) | |
| Return (Local1) | |
| } | |
| Return (Ones) | |
| } | |
| Method (_BTM, 1, NotSerialized) // _BTM: Battery Time | |
| { | |
| If (^^PCI0.LPC0.EC0.OKEC) | |
| { | |
| Local0 = Zero | |
| Local1 = Zero | |
| Local0 = (^^PCI0.LPC0.EC0.ATEH << 0x08) | |
| Local0 += ^^PCI0.LPC0.EC0.ATEL /* \_SB_.PCI0.LPC0.EC0_.ATEL */ | |
| If ((Local0 == 0xFFFF)) | |
| { | |
| Return (Ones) | |
| } | |
| Local1 = (Local0 * 0x3C) | |
| Return (Local1) | |
| } | |
| Return (Ones) | |
| } | |
| } | |
| } | |
| } | |
| Name (TSOS, 0x75) | |
| If (CondRefOf (\_OSI)) | |
| { | |
| If (_OSI ("Windows 2009")) | |
| { | |
| TSOS = 0x50 | |
| } | |
| If (_OSI ("Windows 2015")) | |
| { | |
| TSOS = 0x70 | |
| } | |
| } | |
| Scope (_SB) | |
| { | |
| OperationRegion (ECMC, SystemIO, 0x72, 0x02) | |
| Field (ECMC, AnyAcc, NoLock, Preserve) | |
| { | |
| ECMI, 8, | |
| ECMD, 8 | |
| } | |
| IndexField (ECMI, ECMD, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x08), | |
| FRTB, 32 | |
| } | |
| OperationRegion (FRTP, SystemMemory, FRTB, 0x0100) | |
| Field (FRTP, AnyAcc, NoLock, Preserve) | |
| { | |
| PEBA, 32, | |
| , 5, | |
| IC0E, 1, | |
| IC1E, 1, | |
| IC2E, 1, | |
| IC3E, 1, | |
| IC4E, 1, | |
| IC5E, 1, | |
| UT0E, 1, | |
| UT1E, 1, | |
| , 1, | |
| , 1, | |
| ST_E, 1, | |
| UT2E, 1, | |
| , 1, | |
| EMMD, 2, | |
| UT4E, 1, | |
| , 2, | |
| XHCE, 1, | |
| , 1, | |
| , 1, | |
| UT3E, 1, | |
| ESPI, 1, | |
| EMME, 1, | |
| Offset (0x08), | |
| PCEF, 1, | |
| , 4, | |
| IC0D, 1, | |
| IC1D, 1, | |
| IC2D, 1, | |
| IC3D, 1, | |
| IC4D, 1, | |
| IC5D, 1, | |
| UT0D, 1, | |
| UT1D, 1, | |
| , 1, | |
| , 1, | |
| ST_D, 1, | |
| UT2D, 1, | |
| , 1, | |
| EHCD, 1, | |
| , 1, | |
| UT4D, 1, | |
| , 2, | |
| XHCD, 1, | |
| SD_D, 1, | |
| , 1, | |
| UT3D, 1, | |
| , 1, | |
| EMD3, 1, | |
| , 2, | |
| S03D, 1, | |
| FW00, 16, | |
| FW01, 32, | |
| FW02, 16, | |
| FW03, 32, | |
| SDS0, 8, | |
| SDS1, 8, | |
| CZFG, 1, | |
| Offset (0x20), | |
| SD10, 32, | |
| EH10, 32, | |
| XH10, 32, | |
| STBA, 32 | |
| } | |
| OperationRegion (FCFG, SystemMemory, PEBA, 0x01000000) | |
| Field (FCFG, DWordAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA3044), | |
| IPDE, 32, | |
| IMPE, 32, | |
| Offset (0xA306C), | |
| RAR2, 32, | |
| Offset (0xA3078), | |
| , 2, | |
| LDQ0, 1, | |
| Offset (0xA30CB), | |
| , 7, | |
| AUSS, 1 | |
| } | |
| OperationRegion (IOMX, SystemMemory, 0xFED80D00, 0x0100) | |
| Field (IOMX, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x15), | |
| IM15, 8, | |
| IM16, 8, | |
| Offset (0x1F), | |
| IM1F, 8, | |
| IM20, 8, | |
| Offset (0x44), | |
| IM44, 8, | |
| Offset (0x46), | |
| IM46, 8, | |
| Offset (0x4A), | |
| IM4A, 8, | |
| IM4B, 8, | |
| Offset (0x57), | |
| IM57, 8, | |
| IM58, 8, | |
| Offset (0x68), | |
| IM68, 8, | |
| IM69, 8, | |
| IM6A, 8, | |
| IM6B, 8, | |
| Offset (0x6D), | |
| IM6D, 8 | |
| } | |
| OperationRegion (FACR, SystemMemory, 0xFED81E00, 0x0100) | |
| Field (FACR, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x80), | |
| , 28, | |
| RD28, 1, | |
| , 1, | |
| RQTY, 1, | |
| Offset (0x84), | |
| , 28, | |
| SD28, 1, | |
| , 1, | |
| Offset (0xA0), | |
| PG1A, 1 | |
| } | |
| OperationRegion (EMMX, SystemMemory, 0xFEDD5800, 0x0130) | |
| Field (EMMX, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0xD0), | |
| , 17, | |
| FC18, 1, | |
| FC33, 1, | |
| , 7, | |
| CD_T, 1, | |
| WP_T, 1 | |
| } | |
| OperationRegion (EMMB, SystemMemory, 0xFEDD5800, 0x0130) | |
| Field (EMMB, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0xA4), | |
| E0A4, 32, | |
| E0A8, 32, | |
| Offset (0xB0), | |
| E0B0, 32, | |
| Offset (0xD0), | |
| E0D0, 32, | |
| Offset (0x116), | |
| E116, 32 | |
| } | |
| OperationRegion (SPIM, SystemMemory, 0xFEC13000, 0x0100) | |
| Field (SPIM, AnyAcc, NoLock, Preserve) | |
| { | |
| Offset (0x1D), | |
| ASCE, 2, | |
| Offset (0x22), | |
| SSSC, 16, | |
| Offset (0xFC), | |
| STRN, 1, | |
| , 2, | |
| BOWS, 1, | |
| DOWS, 1 | |
| } | |
| Mutex (ASSM, 0x00) | |
| Name (SVBF, Buffer (0x0100) | |
| { | |
| 0x00 // . | |
| }) | |
| CreateDWordField (SVBF, Zero, S0A4) | |
| CreateDWordField (SVBF, 0x04, S0A8) | |
| CreateDWordField (SVBF, 0x08, S0B0) | |
| CreateDWordField (SVBF, 0x0C, S0D0) | |
| CreateDWordField (SVBF, 0x10, S116) | |
| CreateWordField (SVBF, 0x14, RG22) | |
| CreateDWordField (SVBF, 0x18, SAR2) | |
| Method (SECR, 0, Serialized) | |
| { | |
| S116 = E116 /* \_SB_.E116 */ | |
| RQTY = Zero | |
| RD28 = One | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| While (Local0) | |
| { | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| } | |
| } | |
| Method (RECR, 0, Serialized) | |
| { | |
| E116 = S116 /* \_SB_.S116 */ | |
| } | |
| OperationRegion (LUIE, SystemMemory, 0xFEDC0020, 0x04) | |
| Field (LUIE, AnyAcc, NoLock, Preserve) | |
| { | |
| IER0, 1, | |
| IER1, 1, | |
| IER2, 1, | |
| IER3, 1, | |
| UOL0, 1, | |
| UOL1, 1, | |
| UOL2, 1, | |
| UOL3, 1, | |
| WUR0, 2, | |
| WUR1, 2, | |
| WUR2, 2, | |
| WUR3, 2 | |
| } | |
| Method (FRUI, 2, Serialized) | |
| { | |
| If ((Arg0 == Zero)) | |
| { | |
| Arg1 = IUA0 /* \_SB_.IUA0 */ | |
| } | |
| If ((Arg0 == One)) | |
| { | |
| Arg1 = IUA1 /* \_SB_.IUA1 */ | |
| } | |
| If ((Arg0 == 0x02)) | |
| { | |
| Arg1 = IUA2 /* \_SB_.IUA2 */ | |
| } | |
| If ((Arg0 == 0x03)) | |
| { | |
| Arg1 = IUA3 /* \_SB_.IUA3 */ | |
| } | |
| } | |
| Method (SRAD, 2, Serialized) | |
| { | |
| Local0 = (Arg0 << One) | |
| Local0 += 0xFED81E40 | |
| OperationRegion (ADCR, SystemMemory, Local0, 0x02) | |
| Field (ADCR, ByteAcc, NoLock, Preserve) | |
| { | |
| ADTD, 2, | |
| ADPS, 1, | |
| ADPD, 1, | |
| ADSO, 1, | |
| ADSC, 1, | |
| ADSR, 1, | |
| ADIS, 1, | |
| ADDS, 3 | |
| } | |
| ADIS = One | |
| ADSR = Zero | |
| Stall (Arg1) | |
| ADSR = One | |
| ADIS = Zero | |
| Stall (Arg1) | |
| } | |
| Method (DSAD, 2, Serialized) | |
| { | |
| Local0 = (Arg0 << One) | |
| Local0 += 0xFED81E40 | |
| OperationRegion (ADCR, SystemMemory, Local0, 0x02) | |
| Field (ADCR, ByteAcc, NoLock, Preserve) | |
| { | |
| ADTD, 2, | |
| ADPS, 1, | |
| ADPD, 1, | |
| ADSO, 1, | |
| ADSC, 1, | |
| ADSR, 1, | |
| ADIS, 1, | |
| ADDS, 3 | |
| } | |
| If ((Arg0 != ADTD)) | |
| { | |
| If ((Arg1 == Zero)) | |
| { | |
| ADTD = Zero | |
| ADPD = One | |
| Local0 = ADDS /* \_SB_.DSAD.ADDS */ | |
| While ((Local0 != 0x07)) | |
| { | |
| Local0 = ADDS /* \_SB_.DSAD.ADDS */ | |
| } | |
| } | |
| If ((Arg1 == 0x03)) | |
| { | |
| ADPD = Zero | |
| Local0 = ADDS /* \_SB_.DSAD.ADDS */ | |
| While ((Local0 != Zero)) | |
| { | |
| Local0 = ADDS /* \_SB_.DSAD.ADDS */ | |
| } | |
| ADTD = 0x03 | |
| } | |
| } | |
| } | |
| Method (HSAD, 2, Serialized) | |
| { | |
| Local3 = (One << Arg0) | |
| Local0 = (Arg0 << One) | |
| Local0 += 0xFED81E40 | |
| OperationRegion (ADCR, SystemMemory, Local0, 0x02) | |
| Field (ADCR, ByteAcc, NoLock, Preserve) | |
| { | |
| ADTD, 2, | |
| ADPS, 1, | |
| ADPD, 1, | |
| ADSO, 1, | |
| ADSC, 1, | |
| ADSR, 1, | |
| ADIS, 1, | |
| ADDS, 3 | |
| } | |
| If ((Arg1 != ADTD)) | |
| { | |
| If ((Arg1 == Zero)) | |
| { | |
| PG1A = One | |
| ADTD = Zero | |
| ADPD = One | |
| Local0 = ADDS /* \_SB_.HSAD.ADDS */ | |
| While ((Local0 != 0x07)) | |
| { | |
| Local0 = ADDS /* \_SB_.HSAD.ADDS */ | |
| } | |
| RQTY = One | |
| RD28 = One | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| While (!Local0) | |
| { | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| } | |
| } | |
| If ((Arg1 == 0x03)) | |
| { | |
| RQTY = Zero | |
| RD28 = One | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| While (Local0) | |
| { | |
| Local0 = SD28 /* \_SB_.SD28 */ | |
| } | |
| ADPD = Zero | |
| Local0 = ADDS /* \_SB_.HSAD.ADDS */ | |
| While ((Local0 != Zero)) | |
| { | |
| Local0 = ADDS /* \_SB_.HSAD.ADDS */ | |
| } | |
| ADTD = 0x03 | |
| PG1A = Zero | |
| } | |
| } | |
| } | |
| OperationRegion (FPIC, SystemIO, 0x0C00, 0x02) | |
| Field (ECMC, AnyAcc, NoLock, Preserve) | |
| { | |
| FPII, 8, | |
| FPID, 8 | |
| } | |
| IndexField (FPII, FPID, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0xF4), | |
| IUA0, 8, | |
| IUA1, 8, | |
| Offset (0xF8), | |
| IUA2, 8, | |
| IUA3, 8 | |
| } | |
| Device (SPI1) | |
| { | |
| Name (_HID, "AMDI0062") // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| Memory32Fixed (ReadWrite, | |
| 0xFEC13000, // Address Base | |
| 0x00000100, // Address Length | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.SPI1._CRS.RBUF */ | |
| } | |
| Method (ASSC, 2, Serialized) | |
| { | |
| Acquire (ASSM, 0xFFFF) | |
| Local0 = Arg1 | |
| Switch (ToInteger (Arg0)) | |
| { | |
| Case (0x03) | |
| { | |
| DOWS = One | |
| STRN = One | |
| While ((BOWS && STRN)) | |
| { | |
| If (Arg1) | |
| { | |
| Stall (One) | |
| Local0 -= One | |
| If ((Local0 == Zero)) | |
| { | |
| Break | |
| } | |
| } | |
| } | |
| SAR2 = RAR2 /* \_SB_.RAR2 */ | |
| RAR2 = Zero | |
| ASCE = 0x02 | |
| RG22 = SSSC /* \_SB_.SSSC */ | |
| } | |
| Case (0x04) | |
| { | |
| SSSC = RG22 /* \_SB_.RG22 */ | |
| ASCE = Zero | |
| RAR2 = SAR2 /* \_SB_.SAR2 */ | |
| Local0 = One | |
| DOWS = Zero | |
| } | |
| } | |
| Release (ASSM) | |
| Return (Local0) | |
| } | |
| } | |
| Device (GPIO) | |
| { | |
| Name (_HID, "AMDI0030") // _HID: Hardware ID | |
| Name (_CID, "AMDI0030") // _CID: Compatible ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
| { | |
| 0x00000007, | |
| } | |
| Memory32Fixed (ReadWrite, | |
| 0xFED81500, // Address Base | |
| 0x00000400, // Address Length | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.GPIO._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (FUR0) | |
| { | |
| Name (_HID, "AMDI0020") // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {3} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC9000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC7000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((UT0E == One)) | |
| { | |
| If (IER0) | |
| { | |
| Return (Zero) | |
| } | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (FUR1) | |
| { | |
| Name (_HID, "AMDI0020") // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {4} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCA000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC8000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((UT1E == One)) | |
| { | |
| If (UOL1) | |
| { | |
| Return (Zero) | |
| } | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (FUR2) | |
| { | |
| Name (_HID, "AMDI0020") // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {3} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCE000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCC000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((UT2E == One)) | |
| { | |
| If (UOL2) | |
| { | |
| Return (Zero) | |
| } | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (FUR3) | |
| { | |
| Name (_HID, "AMDI0020") // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {4} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCF000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCD000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((UT3E == One)) | |
| { | |
| If (UOL3) | |
| { | |
| Return (Zero) | |
| } | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (FUR4) | |
| { | |
| Name (_HID, "AMDI0020") // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {15} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDD1000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDD0000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((UT4E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (I2CA) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {10} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC2000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC0E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x05, 0xC8) | |
| } | |
| } | |
| Device (I2CB) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {11} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC3000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC1E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x06, 0xC8) | |
| } | |
| } | |
| Device (I2CC) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {4} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC4000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC2E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x07, 0xC8) | |
| } | |
| } | |
| Device (I2CD) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {6} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC5000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC3E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x08, 0xC8) | |
| } | |
| } | |
| Device (I2CE) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {14} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDC6000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC4E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x09, 0xC8) | |
| } | |
| } | |
| Device (I2CF) | |
| { | |
| Name (_HID, "AMDI0010") // _HID: Hardware ID | |
| Name (_UID, 0x05) // _UID: Unique ID | |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings | |
| { | |
| IRQ (Edge, ActiveHigh, Exclusive, ) | |
| {15} | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDCB000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If ((IC5E == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (RSET, 0, NotSerialized) | |
| { | |
| SRAD (0x0A, 0xC8) | |
| } | |
| } | |
| Method (EPIN, 0, NotSerialized) | |
| { | |
| IPDE = Zero | |
| IMPE = Zero | |
| IM15 = One | |
| IM16 = One | |
| IM20 = One | |
| IM44 = One | |
| IM46 = One | |
| IM68 = One | |
| IM69 = One | |
| IM6A = One | |
| IM6B = One | |
| IM4A = One | |
| IM58 = One | |
| IM4B = One | |
| IM57 = One | |
| IM6D = One | |
| IM1F = One | |
| SECR () | |
| } | |
| Name (NCRS, ResourceTemplate () | |
| { | |
| Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
| { | |
| 0x00000005, | |
| } | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDD5000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| }) | |
| Name (DCRS, ResourceTemplate () | |
| { | |
| Interrupt (ResourceConsumer, Level, ActiveLow, Shared, ,, ) | |
| { | |
| 0x00000005, | |
| } | |
| Memory32Fixed (ReadWrite, | |
| 0xFEDD5000, // Address Base | |
| 0x00001000, // Address Length | |
| ) | |
| GpioInt (Edge, ActiveBoth, SharedAndWake, PullUp, 0x0BB8, | |
| "\\_SB.GPIO", 0x00, ResourceConsumer, , | |
| ) | |
| { // Pin list | |
| 0x0044 | |
| } | |
| GpioIo (Shared, PullUp, 0x0000, 0x0000, IoRestrictionNone, | |
| "\\_SB.GPIO", 0x00, ResourceConsumer, , | |
| ) | |
| { // Pin list | |
| 0x0044 | |
| } | |
| }) | |
| Name (AHID, "AMDI0040") | |
| Name (ACID, "AMDI0040") | |
| Name (SHID, 0x400DD041) | |
| Name (SCID, "PCI\\CC_080501") | |
| Device (EMM0) | |
| { | |
| Method (_HID, 0, Serialized) // _HID: Hardware ID | |
| { | |
| If (EMMD) | |
| { | |
| Return (SHID) /* \_SB_.SHID */ | |
| } | |
| Else | |
| { | |
| Return (AHID) /* \_SB_.AHID */ | |
| } | |
| } | |
| Method (_CID, 0, Serialized) // _CID: Compatible ID | |
| { | |
| If (EMMD) | |
| { | |
| Return (SCID) /* \_SB_.SCID */ | |
| } | |
| Else | |
| { | |
| Return (ACID) /* \_SB_.ACID */ | |
| } | |
| } | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| If (EMD3) | |
| { | |
| Return (DCRS) /* \_SB_.DCRS */ | |
| } | |
| Else | |
| { | |
| Return (NCRS) /* \_SB_.NCRS */ | |
| } | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TSOS >= 0x70)) | |
| { | |
| If (EMME) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (_INI, 0, NotSerialized) // _INI: Initialize | |
| { | |
| If (EMME) | |
| { | |
| EPIN () | |
| } | |
| } | |
| Method (_S0W, 0, NotSerialized) // _S0W: S0 Device Wake State | |
| { | |
| If ((EMD3 && EMME)) | |
| { | |
| Return (0x04) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
| { | |
| If ((EMD3 && EMME)) | |
| { | |
| HSAD (0x1C, Zero) | |
| RECR () | |
| } | |
| } | |
| Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
| { | |
| If ((EMD3 && EMME)) | |
| { | |
| HSAD (0x1C, 0x03) | |
| } | |
| } | |
| } | |
| Device (UAR1) | |
| { | |
| Name (_HID, EisaId ("PNP0500") /* Standard PC COM Serial Port */) // _HID: Hardware ID | |
| Name (_DDN, "COM1") // _DDN: DOS Device Name | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (IER0) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x02E8, // Range Minimum | |
| 0x02E8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| _Y09) | |
| IRQNoFlags (_Y0A) | |
| {3} | |
| }) | |
| CreateByteField (BUF0, \_SB.UAR1._CRS._Y09._MIN, IOLO) // _MIN: Minimum Base Address | |
| CreateByteField (BUF0, 0x03, IOHI) | |
| CreateByteField (BUF0, \_SB.UAR1._CRS._Y09._MAX, IORL) // _MAX: Maximum Base Address | |
| CreateByteField (BUF0, 0x05, IORH) | |
| CreateWordField (BUF0, \_SB.UAR1._CRS._Y0A._INT, IRQL) // _INT: Interrupts | |
| FRUI (WUR0, IRQL) | |
| Return (BUF0) /* \_SB_.UAR1._CRS.BUF0 */ | |
| } | |
| } | |
| Device (UAR2) | |
| { | |
| Name (_HID, EisaId ("PNP0500") /* Standard PC COM Serial Port */) // _HID: Hardware ID | |
| Name (_DDN, "COM2") // _DDN: DOS Device Name | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (IER1) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x02F8, // Range Minimum | |
| 0x02F8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| _Y0B) | |
| IRQNoFlags (_Y0C) | |
| {4} | |
| }) | |
| CreateByteField (BUF0, \_SB.UAR2._CRS._Y0B._MIN, IOLO) // _MIN: Minimum Base Address | |
| CreateByteField (BUF0, 0x03, IOHI) | |
| CreateByteField (BUF0, \_SB.UAR2._CRS._Y0B._MAX, IORL) // _MAX: Maximum Base Address | |
| CreateByteField (BUF0, 0x05, IORH) | |
| CreateWordField (BUF0, \_SB.UAR2._CRS._Y0C._INT, IRQL) // _INT: Interrupts | |
| FRUI (WUR1, IRQL) | |
| Return (BUF0) /* \_SB_.UAR2._CRS.BUF0 */ | |
| } | |
| } | |
| Device (UAR3) | |
| { | |
| Name (_HID, EisaId ("PNP0500") /* Standard PC COM Serial Port */) // _HID: Hardware ID | |
| Name (_DDN, "COM3") // _DDN: DOS Device Name | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (IER2) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x03E8, // Range Minimum | |
| 0x03E8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| _Y0D) | |
| IRQNoFlags (_Y0E) | |
| {3} | |
| }) | |
| CreateByteField (BUF0, \_SB.UAR3._CRS._Y0D._MIN, IOLO) // _MIN: Minimum Base Address | |
| CreateByteField (BUF0, 0x03, IOHI) | |
| CreateByteField (BUF0, \_SB.UAR3._CRS._Y0D._MAX, IORL) // _MAX: Maximum Base Address | |
| CreateByteField (BUF0, 0x05, IORH) | |
| CreateWordField (BUF0, \_SB.UAR3._CRS._Y0E._INT, IRQL) // _INT: Interrupts | |
| FRUI (WUR2, IRQL) | |
| Return (BUF0) /* \_SB_.UAR3._CRS.BUF0 */ | |
| } | |
| } | |
| Device (UAR4) | |
| { | |
| Name (_HID, EisaId ("PNP0500") /* Standard PC COM Serial Port */) // _HID: Hardware ID | |
| Name (_DDN, "COM4") // _DDN: DOS Device Name | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If (IER3) | |
| { | |
| Return (0x0F) | |
| } | |
| Return (Zero) | |
| } | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (BUF0, ResourceTemplate () | |
| { | |
| IO (Decode16, | |
| 0x03F8, // Range Minimum | |
| 0x03F8, // Range Maximum | |
| 0x01, // Alignment | |
| 0x08, // Length | |
| _Y0F) | |
| IRQNoFlags (_Y10) | |
| {4} | |
| }) | |
| CreateByteField (BUF0, \_SB.UAR4._CRS._Y0F._MIN, IOLO) // _MIN: Minimum Base Address | |
| CreateByteField (BUF0, 0x03, IOHI) | |
| CreateByteField (BUF0, \_SB.UAR4._CRS._Y0F._MAX, IORL) // _MAX: Maximum Base Address | |
| CreateByteField (BUF0, 0x05, IORH) | |
| CreateWordField (BUF0, \_SB.UAR4._CRS._Y10._INT, IRQL) // _INT: Interrupts | |
| FRUI (WUR3, IRQL) | |
| Return (BUF0) /* \_SB_.UAR4._CRS.BUF0 */ | |
| } | |
| } | |
| } | |
| Scope (_SB.FUR0) | |
| { | |
| Device (UART) | |
| { | |
| Name (_HID, "UTK0001") // _HID: Hardware ID | |
| Name (_CID, "UARTTest") // _CID: Compatible ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| UartSerialBusV2 (0x0001C200, DataBitsEight, StopBitsOne, | |
| 0xC0, LittleEndian, ParityTypeNone, FlowControlHardware, | |
| 0x0020, 0x0020, "\\_SB.FUR0", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.FUR0.UART._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.FUR1) | |
| { | |
| Device (UART) | |
| { | |
| Name (_HID, "UTK0001") // _HID: Hardware ID | |
| Name (_CID, "UARTTest") // _CID: Compatible ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| UartSerialBusV2 (0x0001C200, DataBitsEight, StopBitsOne, | |
| 0xC0, LittleEndian, ParityTypeNone, FlowControlHardware, | |
| 0x0020, 0x0020, "\\_SB.FUR1", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.FUR1.UART._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CA) | |
| { | |
| Device (WTP1) | |
| { | |
| Name (_HID, "STK0001") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x007F, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.WTP1._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MTP1) | |
| { | |
| Name (_HID, "STK0001") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB_.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.MTP1._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WTP2) | |
| { | |
| Name (_HID, "STK0002") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.WTP2._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MTP2) | |
| { | |
| Name (_HID, "STK0002") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB_.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.MTP2._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WTP3) | |
| { | |
| Name (_HID, "STK0003") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.WTP3._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MTP3) | |
| { | |
| Name (_HID, "STK0003") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB_.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.MTP3._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WTP4) | |
| { | |
| Name (_HID, "STK0004") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.WTP4._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MTP4) | |
| { | |
| Name (_HID, "STK0004") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0014, ControllerInitiated, 0x000222E0, | |
| AddressingMode7Bit, "\\_SB_.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.MTP4._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MTP5) | |
| { | |
| Name (_HID, "STK0005") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0015, ControllerInitiated, 0x00053020, | |
| AddressingMode7Bit, "\\_SB_.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CA.MTP5._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CB) | |
| { | |
| Device (WT21) | |
| { | |
| Name (_HID, "STK00012") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF2") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x007F, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.WT21._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT21) | |
| { | |
| Name (_HID, "STK00012") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB_.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.MT21._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT22) | |
| { | |
| Name (_HID, "STK00022") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF2") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.WT22._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT22) | |
| { | |
| Name (_HID, "STK00022") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB_.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.MT22._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT23) | |
| { | |
| Name (_HID, "STK00032") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF2") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.WT23._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT23) | |
| { | |
| Name (_HID, "STK00032") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB_.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.MT23._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT24) | |
| { | |
| Name (_HID, "STK00042") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF2") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.WT24._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT24) | |
| { | |
| Name (_HID, "STK00042") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0014, ControllerInitiated, 0x000222E0, | |
| AddressingMode7Bit, "\\_SB_.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.MT24._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT25) | |
| { | |
| Name (_HID, "STK00052") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0015, ControllerInitiated, 0x00053020, | |
| AddressingMode7Bit, "\\_SB_.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.MT25._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CC) | |
| { | |
| Device (WT31) | |
| { | |
| Name (_HID, "STK00013") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF3") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x007F, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.WT31._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT31) | |
| { | |
| Name (_HID, "STK00013") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB_.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.MT31._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT32) | |
| { | |
| Name (_HID, "STK00023") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF3") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.WT32._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT32) | |
| { | |
| Name (_HID, "STK00023") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB_.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.MT32._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT33) | |
| { | |
| Name (_HID, "STK00033") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF3") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.WT33._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT33) | |
| { | |
| Name (_HID, "STK00033") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB_.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.MT33._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT34) | |
| { | |
| Name (_HID, "STK00043") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF3") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.WT34._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT34) | |
| { | |
| Name (_HID, "STK00043") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0014, ControllerInitiated, 0x000222E0, | |
| AddressingMode7Bit, "\\_SB_.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.MT34._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT35) | |
| { | |
| Name (_HID, "STK00053") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0015, ControllerInitiated, 0x00053020, | |
| AddressingMode7Bit, "\\_SB_.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CC.MT35._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CD) | |
| { | |
| Device (WT41) | |
| { | |
| Name (_HID, "STK00014") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF4") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x007F, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.WT41._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT41) | |
| { | |
| Name (_HID, "STK00014") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB_.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.MT41._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT42) | |
| { | |
| Name (_HID, "STK00024") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF4") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0011, ControllerInitiated, 0x000186A0, | |
| AddressingMode7Bit, "\\_SB.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.WT42._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT42) | |
| { | |
| Name (_HID, "STK00024") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB_.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.MT42._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT43) | |
| { | |
| Name (_HID, "STK00034") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF4") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0012, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.WT43._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT43) | |
| { | |
| Name (_HID, "STK00034") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB_.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.MT43._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (WT44) | |
| { | |
| Name (_HID, "STK00044") // _HID: Hardware ID | |
| Name (_CID, "SPBTestKMDF4") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0013, ControllerInitiated, 0x000F4240, | |
| AddressingMode7Bit, "\\_SB.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.WT44._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT44) | |
| { | |
| Name (_HID, "STK00044") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0014, ControllerInitiated, 0x000222E0, | |
| AddressingMode7Bit, "\\_SB_.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.MT44._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (MT45) | |
| { | |
| Name (_HID, "STK00054") // _HID: Hardware ID | |
| Name (_CID, "WITTTest") // _CID: Compatible ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0015, ControllerInitiated, 0x00053020, | |
| AddressingMode7Bit, "\\_SB_.I2CD", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (RBUF) /* \_SB_.I2CD.MT45._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((MWTT == Zero)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CB) | |
| { | |
| Device (TPNL) | |
| { | |
| Name (_HID, "FTS3528") // _HID: Hardware ID | |
| Name (_CID, "PNP0C50" /* HID Protocol Device (I2C bus) */) // _CID: Compatible ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (RBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0038, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CB", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| GpioInt (Level, ActiveLow, Exclusive, PullUp, 0x0000, | |
| "\\_SB.GPIO", 0x00, ResourceConsumer, , | |
| ) | |
| { // Pin list | |
| 0x0044 | |
| } | |
| GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly, | |
| "\\_SB.GPIO", 0x00, ResourceConsumer, , | |
| ) | |
| { // Pin list | |
| 0x0045 | |
| } | |
| }) | |
| Return (RBUF) /* \_SB_.I2CB.TPNL._CRS.RBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((TPEN == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| Method (_DSW, 3, NotSerialized) // _DSW: Device Sleep Wake | |
| { | |
| If (Arg0){} | |
| Else | |
| { | |
| } | |
| } | |
| Method (_PS0, 0, NotSerialized) // _PS0: Power State 0 | |
| { | |
| } | |
| Method (_PS3, 0, NotSerialized) // _PS3: Power State 3 | |
| { | |
| } | |
| Method (_DSM, 4, Serialized) // _DSM: Device-Specific Method | |
| { | |
| If ((Arg0 == ToUUID ("3cdff6f7-4267-4555-ad05-b30a3d8938de") /* HID I2C Device */)) | |
| { | |
| Switch (ToInteger (Arg2)) | |
| { | |
| Case (Zero) | |
| { | |
| Switch (ToInteger (Arg1)) | |
| { | |
| Case (One) | |
| { | |
| Return (Buffer (One) | |
| { | |
| 0x03 // . | |
| }) | |
| } | |
| Default | |
| { | |
| Return (Buffer (One) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| } | |
| } | |
| Case (One) | |
| { | |
| Return (Zero) | |
| } | |
| Default | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Else | |
| { | |
| Return (Buffer (One) | |
| { | |
| 0x00 // . | |
| }) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CA) | |
| { | |
| Device (LGHT) | |
| { | |
| Name (_HID, "PRP0001") // _HID: Hardware ID | |
| Name (_UID, Zero) // _UID: Unique ID | |
| Name (_STR, Unicode ("OPT3001 Light Sensor")) // _STR: Description String | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "compatible", | |
| "ti,opt3001" | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0044, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (SBUF) /* \_SB_.I2CA.LGHT._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((ALSE == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (LTRF) | |
| { | |
| Name (_HID, "PRP0001") // _HID: Hardware ID | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_STR, Unicode ("LTRF216A Light Sensor")) // _STR: Description String | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "compatible", | |
| "ltr,ltrf216a" | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0053, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (SBUF) /* \_SB_.I2CA.LTRF._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((ALSE == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| Device (NAUO) | |
| { | |
| Name (_HID, "NVTN2020") // _HID: Hardware ID | |
| Name (_CID, "NVTN2020") // _CID: Compatible ID | |
| Name (_DDN, "NAU8821") // _DDN: DOS Device Name | |
| Name (_UID, One) // _UID: Unique ID | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x09) | |
| { | |
| Package (0x02) | |
| { | |
| "nuvoton,jkdet-enable", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,jkdet-pull-enable", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,jkdet-pull-up", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,jkdet-polarity", | |
| One | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,micbias-voltage", | |
| 0x06 | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,vref-impedance", | |
| 0x02 | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,jack-insert-debounce", | |
| 0x07 | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,jack-eject-debounce", | |
| Zero | |
| }, | |
| Package (0x02) | |
| { | |
| "nuvoton,dmic-clk-threshold", | |
| DCLK | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x001B, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CA", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| GpioInt (Level, ActiveLow, ExclusiveAndWake, PullUp, 0x0000, | |
| "\\_SB.GPIO", 0x00, ResourceConsumer, , | |
| ) | |
| { // Pin list | |
| 0x0056 | |
| } | |
| }) | |
| Return (SBUF) /* \_SB_.I2CA.NAUO._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| If ((AUCE == One)) | |
| { | |
| Return (0x0F) | |
| } | |
| Else | |
| { | |
| Return (Zero) | |
| } | |
| } | |
| } | |
| } | |
| Scope (_SB.I2CC) | |
| { | |
| Device (CUR0) | |
| { | |
| Name (_HID, "PRP0001") // _HID: Hardware ID | |
| Name (_UID, 0x02) // _UID: Unique ID | |
| Name (_STR, Unicode ("INA230 Current Sensor")) // _STR: Description String | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "compatible", | |
| "ti,ina230" | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0040, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (SBUF) /* \_SB_.I2CC.CUR0._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Device (CUR1) | |
| { | |
| Name (_HID, "PRP0001") // _HID: Hardware ID | |
| Name (_UID, 0x03) // _UID: Unique ID | |
| Name (_STR, Unicode ("INA230 Current Sensor")) // _STR: Description String | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "compatible", | |
| "ti,ina230" | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0041, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (SBUF) /* \_SB_.I2CC.CUR1._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| Device (CUR2) | |
| { | |
| Name (_HID, "PRP0001") // _HID: Hardware ID | |
| Name (_UID, 0x04) // _UID: Unique ID | |
| Name (_STR, Unicode ("INA230 Current Sensor")) // _STR: Description String | |
| Name (_DSD, Package (0x02) // _DSD: Device-Specific Data | |
| { | |
| ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */, | |
| Package (0x01) | |
| { | |
| Package (0x02) | |
| { | |
| "compatible", | |
| "ti,ina230" | |
| } | |
| } | |
| }) | |
| Method (_CRS, 0, Serialized) // _CRS: Current Resource Settings | |
| { | |
| Name (SBUF, ResourceTemplate () | |
| { | |
| I2cSerialBusV2 (0x0042, ControllerInitiated, 0x00061A80, | |
| AddressingMode7Bit, "\\_SB.I2CC", | |
| 0x00, ResourceConsumer, , Exclusive, | |
| ) | |
| }) | |
| Return (SBUF) /* \_SB_.I2CC.CUR2._CRS.SBUF */ | |
| } | |
| Method (_STA, 0, NotSerialized) // _STA: Status | |
| { | |
| Return (0x0F) | |
| } | |
| } | |
| } | |
| Scope (_TZ) | |
| { | |
| ThermalZone (TZ01) | |
| { | |
| Name (CRTT, 0x69) | |
| Name (PSVT, 0x64) | |
| Name (TSPS, 0x14) | |
| Method (_TMP, 0, Serialized) // _TMP: Temperature | |
| { | |
| If (\_SB.PCI0.LPC0.ECOK ()) | |
| { | |
| If (!Acquire (\_SB.PCI0.LPC0.EC0.Z009, 0x012C)) | |
| { | |
| Local0 = \_SB.PCI0.LPC0.EC0.CTMP | |
| Release (\_SB.PCI0.LPC0.EC0.Z009) | |
| Return ((0x0AAC + (Local0 * 0x0A))) | |
| } | |
| Return (0x0B74) | |
| } | |
| Else | |
| { | |
| Return (0x0B74) | |
| } | |
| } | |
| Method (_PSL, 0, Serialized) // _PSL: Passive List | |
| { | |
| Return (Package (0x03) | |
| { | |
| \_SB.PLTF.C000, | |
| \_SB.PLTF.C001, | |
| \_SB.PLTF.C002 | |
| }) | |
| } | |
| Method (_CRT, 0, Serialized) // _CRT: Critical Temperature | |
| { | |
| Return ((0x0AAC + (CRTT * 0x0A))) | |
| } | |
| Method (_PSV, 0, Serialized) // _PSV: Passive Temperature | |
| { | |
| Return ((0x0AAC + (PSVT * 0x0A))) | |
| } | |
| Method (_TC1, 0, Serialized) // _TC1: Thermal Constant 1 | |
| { | |
| Return (One) | |
| } | |
| Method (_TC2, 0, Serialized) // _TC2: Thermal Constant 2 | |
| { | |
| Return (0x02) | |
| } | |
| Method (_TSP, 0, Serialized) // _TSP: Thermal Sampling Period | |
| { | |
| Return (TSPS) /* \_TZ_.TZ01.TSPS */ | |
| } | |
| } | |
| } | |
| Scope (_SB) | |
| { | |
| OperationRegion (EXCO, SystemIO, 0x72, 0x02) | |
| Field (EXCO, ByteAcc, NoLock, Preserve) | |
| { | |
| INDT, 8, | |
| DATT, 8 | |
| } | |
| IndexField (INDT, DATT, ByteAcc, NoLock, Preserve) | |
| { | |
| Offset (0x88), | |
| , 2, | |
| RTCS, 1, | |
| , 3, | |
| PCIW, 1, | |
| Offset (0x89), | |
| Offset (0x90), | |
| , 4, | |
| FL07, 1, | |
| FL17, 1, | |
| FL06, 1, | |
| FL10, 1, | |
| Offset (0x93), | |
| BID0, 1, | |
| BID1, 1, | |
| BID2, 1, | |
| BID3, 1, | |
| BID4, 1, | |
| BID5, 1, | |
| BID6, 1, | |
| BID7, 1, | |
| Offset (0xA0), | |
| OSDS, 8, | |
| S4FG, 8, | |
| TPID, 8, | |
| Offset (0xA4), | |
| W714, 8, | |
| W715, 8, | |
| W716, 8, | |
| W717, 8, | |
| Offset (0xDA), | |
| FL0A, 1, | |
| Offset (0xDB), | |
| Offset (0xE0), | |
| CME0, 16, | |
| CME2, 16, | |
| CME4, 16, | |
| CME6, 16, | |
| CME8, 16, | |
| CMEA, 16, | |
| CMEC, 16, | |
| CMEE, 16, | |
| Offset (0xF4), | |
| CMF4, 8, | |
| CMF5, 8, | |
| CMF6, 8, | |
| CMF7, 8, | |
| CMF8, 8, | |
| CMF9, 8, | |
| CMFA, 8, | |
| CMFB, 8, | |
| CMFC, 8, | |
| CMFD, 8, | |
| CMFE, 8, | |
| ECTY, 8 | |
| } | |
| Method (CMSO, 2, NotSerialized) | |
| { | |
| INDT = Arg0 | |
| DATT = Arg1 | |
| } | |
| Method (CMRD, 1, NotSerialized) | |
| { | |
| INDT = Arg0 | |
| Return (DATT) /* \_SB_.DATT */ | |
| } | |
| } | |
| } | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment