| /* |
| * Intel ACPI Component Architecture |
| * AML/ASL+ Disassembler version 20160831-64 |
| * Copyright (c) 2000 - 2016 Intel Corporation |
| * |
| * Disassembling to symbolic ASL+ operators |
| * |
| * Disassembly of dsdt.dat, Mon Jan 2 15:19:14 2017 |
| * |
| * Original Table Header: |
| * Signature "DSDT" |
| * Length 0x00006909 (26889) |
| * Revision 0x01 **** 32-bit table (V1), no 64-bit math support |
| * Checksum 0xD7 |
| * OEM ID "A0798" |
| * OEM Table ID "A0798000" |
| * OEM Revision 0x00000000 (0) |
| * Compiler ID "INTL" |
| * Compiler Version 0x20051117 (537202967) |
| */ |
| DefinitionBlock ("", "DSDT", 1, "A0798", "A0798000", 0x00000000) |
| { |
| Scope (\_PR) |
| { |
| Processor (CPU1, 0x01, 0x00000810, 0x06) |
| { |
| OperationRegion (STBL, SystemMemory, 0x7F7AE0C0, 0x0214) |
| Name (NCPU, 0x02) |
| Name (TYPE, 0x80000000) |
| Name (HNDL, 0x80000000) |
| Name (CFGD, 0x01000009) |
| Name (TBLD, 0x80) |
| Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
| { |
| CreateDWordField (Arg0, 0x00, REVS) |
| CreateDWordField (Arg0, 0x04, SIZE) |
| Local0 = SizeOf (Arg0) |
| Local1 = (Local0 - 0x08) |
| CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP) |
| Name (STS0, Buffer (0x04) |
| { |
| 0x00, 0x00, 0x00, 0x00 /* .... */ |
| }) |
| Concatenate (STS0, TEMP, Local2) |
| _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2) |
| } |
| |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities |
| { |
| CreateDWordField (Arg3, 0x00, STS0) |
| CreateDWordField (Arg3, 0x04, CAP0) |
| CreateDWordField (Arg0, 0x00, IID0) |
| CreateDWordField (Arg0, 0x04, IID1) |
| CreateDWordField (Arg0, 0x08, IID2) |
| CreateDWordField (Arg0, 0x0C, IID3) |
| Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953")) |
| CreateDWordField (UID0, 0x00, EID0) |
| CreateDWordField (UID0, 0x04, EID1) |
| CreateDWordField (UID0, 0x08, EID2) |
| CreateDWordField (UID0, 0x0C, EID3) |
| If (!(((IID0 == EID0) && (IID1 == EID1)) && (( |
| IID2 == EID2) && (IID3 == EID3)))) |
| { |
| STS0 = 0x06 |
| Return (Arg3) |
| } |
| |
| If (Arg1 != 0x01) |
| { |
| STS0 = 0x0A |
| Return (Arg3) |
| } |
| |
| TYPE = ((TYPE & 0x7FFFFFFF) | CAP0) /* \_PR_.CPU1._OSC.CAP0 */ |
| If (CFGD & 0x01) |
| { |
| If (((CFGD & 0x01000000) && ((TYPE & 0x09) == |
| 0x09)) && !(TBLD & 0x01)) |
| { |
| TBLD |= 0x01 |
| Load (STBL, HNDL) /* \_PR_.CPU1.HNDL */ |
| } |
| } |
| |
| If (CFGD & 0xF0) |
| { |
| If (((CFGD & 0x01000000) && (TYPE & 0x18)) && ! |
| (TBLD & 0x02)) |
| { |
| TBLD |= 0x02 |
| } |
| } |
| |
| Return (Arg3) |
| } |
| } |
| } |
| |
| Scope (\_PR) |
| { |
| Processor (CPU2, 0x02, 0x00000810, 0x06) |
| { |
| OperationRegion (STBL, SystemMemory, 0x7F7AE2E0, 0x0143) |
| Name (NCPU, 0x02) |
| Name (TYPE, 0x80000000) |
| Name (HNDL, 0x80000000) |
| Name (CFGD, 0x01000009) |
| Name (TBLD, 0x80) |
| Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
| { |
| CreateDWordField (Arg0, 0x00, REVS) |
| CreateDWordField (Arg0, 0x04, SIZE) |
| Local0 = SizeOf (Arg0) |
| Local1 = (Local0 - 0x08) |
| CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP) |
| Name (STS1, Buffer (0x04) |
| { |
| 0x00, 0x00, 0x00, 0x00 /* .... */ |
| }) |
| Concatenate (STS1, TEMP, Local2) |
| _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2) |
| } |
| |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities |
| { |
| CreateDWordField (Arg3, 0x00, STS1) |
| CreateDWordField (Arg3, 0x04, CAP1) |
| CreateDWordField (Arg0, 0x00, IID0) |
| CreateDWordField (Arg0, 0x04, IID1) |
| CreateDWordField (Arg0, 0x08, IID2) |
| CreateDWordField (Arg0, 0x0C, IID3) |
| Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953")) |
| CreateDWordField (UID0, 0x00, EID0) |
| CreateDWordField (UID0, 0x04, EID1) |
| CreateDWordField (UID0, 0x08, EID2) |
| CreateDWordField (UID0, 0x0C, EID3) |
| If (!(((IID0 == EID0) && (IID1 == EID1)) && (( |
| IID2 == EID2) && (IID3 == EID3)))) |
| { |
| STS1 = 0x06 |
| Return (Arg3) |
| } |
| |
| If (Arg1 != 0x01) |
| { |
| STS1 = 0x0A |
| Return (Arg3) |
| } |
| |
| TYPE = ((TYPE & 0x7FFFFFFF) | CAP1) /* \_PR_.CPU2._OSC.CAP1 */ |
| If (CFGD & 0x01) |
| { |
| If (((CFGD & 0x01000000) && ((TYPE & 0x09) == |
| 0x09)) && !(TBLD & 0x01)) |
| { |
| TBLD |= 0x01 |
| Load (STBL, HNDL) /* \_PR_.CPU2.HNDL */ |
| } |
| } |
| |
| If (CFGD & 0xF0) |
| { |
| If (((CFGD & 0x01000000) && (TYPE & 0x18)) && ! |
| (TBLD & 0x02)) |
| { |
| TBLD |= 0x02 |
| } |
| } |
| |
| Return (Arg3) |
| } |
| } |
| } |
| |
| Scope (\_PR) |
| { |
| Processor (CPU3, 0x03, 0x00000810, 0x06) |
| { |
| OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF) |
| Name (NCPU, 0x80) |
| Name (TYPE, 0x80000000) |
| Name (HNDL, 0x80000000) |
| Name (CFGD, 0x80000000) |
| Name (TBLD, 0x80) |
| Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
| { |
| CreateDWordField (Arg0, 0x00, REVS) |
| CreateDWordField (Arg0, 0x04, SIZE) |
| Local0 = SizeOf (Arg0) |
| Local1 = (Local0 - 0x08) |
| CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP) |
| Name (STS2, Buffer (0x04) |
| { |
| 0x00, 0x00, 0x00, 0x00 /* .... */ |
| }) |
| Concatenate (STS2, TEMP, Local2) |
| _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2) |
| } |
| |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities |
| { |
| CreateDWordField (Arg3, 0x00, STS2) |
| CreateDWordField (Arg3, 0x04, CAP2) |
| CreateDWordField (Arg0, 0x00, IID0) |
| CreateDWordField (Arg0, 0x04, IID1) |
| CreateDWordField (Arg0, 0x08, IID2) |
| CreateDWordField (Arg0, 0x0C, IID3) |
| Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953")) |
| CreateDWordField (UID0, 0x00, EID0) |
| CreateDWordField (UID0, 0x04, EID1) |
| CreateDWordField (UID0, 0x08, EID2) |
| CreateDWordField (UID0, 0x0C, EID3) |
| If (!(((IID0 == EID0) && (IID1 == EID1)) && (( |
| IID2 == EID2) && (IID3 == EID3)))) |
| { |
| STS2 = 0x06 |
| Return (Arg3) |
| } |
| |
| If (Arg1 != 0x01) |
| { |
| STS2 = 0x0A |
| Return (Arg3) |
| } |
| |
| TYPE = ((TYPE & 0x7FFFFFFF) | CAP2) /* \_PR_.CPU3._OSC.CAP2 */ |
| If (CFGD & 0x01) |
| { |
| If (((CFGD & 0x01000000) && ((TYPE & 0x09) == |
| 0x09)) && !(TBLD & 0x01)) |
| { |
| TBLD |= 0x01 |
| Load (STBL, HNDL) /* \_PR_.CPU3.HNDL */ |
| } |
| } |
| |
| If (CFGD & 0xF0) |
| { |
| If (((CFGD & 0x01000000) && (TYPE & 0x18)) && ! |
| (TBLD & 0x02)) |
| { |
| TBLD |= 0x02 |
| } |
| } |
| |
| Return (Arg3) |
| } |
| } |
| } |
| |
| Scope (\_PR) |
| { |
| Processor (CPU4, 0x04, 0x00000810, 0x06) |
| { |
| OperationRegion (STBL, SystemMemory, 0xFFFF0000, 0xFFFF) |
| Name (NCPU, 0x80) |
| Name (TYPE, 0x80000000) |
| Name (HNDL, 0x80000000) |
| Name (CFGD, 0x80000000) |
| Name (TBLD, 0x80) |
| Method (_PDC, 1, NotSerialized) // _PDC: Processor Driver Capabilities |
| { |
| CreateDWordField (Arg0, 0x00, REVS) |
| CreateDWordField (Arg0, 0x04, SIZE) |
| Local0 = SizeOf (Arg0) |
| Local1 = (Local0 - 0x08) |
| CreateField (Arg0, 0x40, (Local1 * 0x08), TEMP) |
| Name (STS3, Buffer (0x04) |
| { |
| 0x00, 0x00, 0x00, 0x00 /* .... */ |
| }) |
| Concatenate (STS3, TEMP, Local2) |
| _OSC (ToUUID ("4077a616-290c-47be-9ebd-d87058713953"), REVS, SIZE, Local2) |
| } |
| |
| Method (_OSC, 4, NotSerialized) // _OSC: Operating System Capabilities |
| { |
| CreateDWordField (Arg3, 0x00, STS3) |
| CreateDWordField (Arg3, 0x04, CAP3) |
| CreateDWordField (Arg0, 0x00, IID0) |
| CreateDWordField (Arg0, 0x04, IID1) |
| CreateDWordField (Arg0, 0x08, IID2) |
| CreateDWordField (Arg0, 0x0C, IID3) |
| Name (UID0, ToUUID ("4077a616-290c-47be-9ebd-d87058713953")) |
| CreateDWordField (UID0, 0x00, EID0) |
| CreateDWordField (UID0, 0x04, EID1) |
| CreateDWordField (UID0, 0x08, EID2) |
| CreateDWordField (UID0, 0x0C, EID3) |
| If (!(((IID0 == EID0) && (IID1 == EID1)) && (( |
| IID2 == EID2) && (IID3 == EID3)))) |
| { |
| STS3 = 0x06 |
| Return (Arg3) |
| } |
| |
| If (Arg1 != 0x01) |
| { |
| STS3 = 0x0A |
| Return (Arg3) |
| } |
| |
| TYPE = ((TYPE & 0x7FFFFFFF) | CAP3) /* \_PR_.CPU4._OSC.CAP3 */ |
| If (CFGD & 0x01) |
| { |
| If (((CFGD & 0x01000000) && ((TYPE & 0x09) == |
| 0x09)) && !(TBLD & 0x01)) |
| { |
| TBLD |= 0x01 |
| Load (STBL, HNDL) /* \_PR_.CPU4.HNDL */ |
| } |
| } |
| |
| If (CFGD & 0xF0) |
| { |
| If (((CFGD & 0x01000000) && (TYPE & 0x18)) && ! |
| (TBLD & 0x02)) |
| { |
| TBLD |= 0x02 |
| } |
| } |
| |
| Return (Arg3) |
| } |
| } |
| } |
| |
| Name (DP80, 0x80) |
| Name (DP90, 0x90) |
| Name (SPIO, 0x2E) |
| Name (IOHW, 0x0290) |
| Name (ACPH, 0xDE) |
| Name (PMBS, 0x0800) |
| Name (FHDC, 0xD9) |
| Name (PMLN, 0x80) |
| Name (GPBS, 0x0480) |
| Name (GPLN, 0x40) |
| Name (SMBS, 0x0400) |
| Name (SMBL, 0x20) |
| Name (SMBH, 0x00) |
| Name (PM30, 0x0830) |
| Name (SUSW, 0xFF) |
| Name (HTBA, 0xFED1F404) |
| Name (APIC, 0x01) |
| Name (EAQF, 0x01) |
| Name (CQST, 0x3C) |
| Name (PCIB, 0xF0000000) |
| Name (PCIL, 0x04000000) |
| Name (CPUC, 0x04) |
| OperationRegion (BIOS, SystemMemory, 0x7F7AE064, 0xFF) |
| Field (BIOS, ByteAcc, NoLock, Preserve) |
| { |
| SS1, 1, |
| SS2, 1, |
| SS3, 1, |
| SS4, 1, |
| Offset (0x01), |
| IOST, 16, |
| TOPM, 32, |
| ROMS, 32, |
| MG1B, 32, |
| MG1L, 32, |
| MG2B, 32, |
| MG2L, 32, |
| Offset (0x1C), |
| DMAX, 8, |
| HPTA, 32, |
| CPB0, 32, |
| CPB1, 32, |
| CPB2, 32, |
| CPB3, 32, |
| ASSB, 8, |
| AOTB, 8, |
| AAXB, 32, |
| SMIF, 8, |
| DTSE, 8, |
| DTS1, 8, |
| DTS2, 8, |
| MPEN, 8, |
| MSC1, 32, |
| MSC2, 32, |
| MSC3, 32, |
| MSC4, 32, |
| MSC5, 32, |
| MSC6, 32, |
| MSC7, 32, |
| MSC8, 32 |
| } |
| |
| Method (RRIO, 4, NotSerialized) |
| { |
| Debug = "RRIO" |
| } |
| |
| Method (RDMA, 3, NotSerialized) |
| { |
| Debug = "rDMA" |
| } |
| |
| Name (PICM, 0x00) |
| Method (_PIC, 1, NotSerialized) // _PIC: Interrupt Model |
| { |
| If (Arg0) |
| { |
| DBG8 = 0xAA |
| } |
| Else |
| { |
| DBG8 = 0xAC |
| } |
| |
| PICM = Arg0 |
| } |
| |
| Name (OSVR, Ones) |
| Method (OSFL, 0, NotSerialized) |
| { |
| If (OSVR != Ones) |
| { |
| Return (OSVR) /* \OSVR */ |
| } |
| |
| If (PICM == 0x00) |
| { |
| DBG8 = 0xAC |
| } |
| |
| OSVR = 0x01 |
| If (CondRefOf (\_OSI, Local1)) |
| { |
| If (\_OSI ("Windows 2001")) |
| { |
| OSVR = 0x00 |
| } |
| } |
| ElseIf (MCTH (\_OS, "Microsoft Windows NT")) |
| { |
| OSVR = 0x04 |
| } |
| Else |
| { |
| If (MCTH (\_OS, "Microsoft WindowsME: Millennium Edition")) |
| { |
| OSVR = 0x02 |
| } |
| |
| If (MCTH (\_OS, "Linux")) |
| { |
| OSVR = 0x03 |
| } |
| } |
| |
| Return (OSVR) /* \OSVR */ |
| } |
| |
| Method (MCTH, 2, NotSerialized) |
| { |
| If (SizeOf (Arg0) < SizeOf (Arg1)) |
| { |
| Return (Zero) |
| } |
| |
| Local0 = (SizeOf (Arg0) + 0x01) |
| Name (BUF0, Buffer (Local0) {}) |
| Name (BUF1, Buffer (Local0) {}) |
| BUF0 = Arg0 |
| BUF1 = Arg1 |
| While (Local0) |
| { |
| Local0-- |
| If (DerefOf (BUF0 [Local0]) != DerefOf (BUF1 [Local0] |
| )) |
| { |
| Return (Zero) |
| } |
| } |
| |
| Return (One) |
| } |
| |
| Name (PRWP, Package (0x02) |
| { |
| Zero, |
| Zero |
| }) |
| Method (GPRW, 2, NotSerialized) |
| { |
| PRWP [0x00] = Arg0 |
| Local0 = (SS1 << 0x01) |
| Local0 |= (SS2 << 0x02) |
| Local0 |= (SS3 << 0x03) |
| Local0 |= (SS4 << 0x04) |
| If ((0x01 << Arg1) & Local0) |
| { |
| PRWP [0x01] = Arg1 |
| } |
| Else |
| { |
| Local0 >>= 0x01 |
| If ((OSFL () == 0x01) || (OSFL () == 0x02)) |
| { |
| FindSetLeftBit (Local0, PRWP [0x01]) |
| } |
| Else |
| { |
| FindSetRightBit (Local0, PRWP [0x01]) |
| } |
| } |
| |
| Return (PRWP) /* \PRWP */ |
| } |
| |
| Name (WAKP, Package (0x02) |
| { |
| Zero, |
| Zero |
| }) |
| OperationRegion (DEB0, SystemIO, DP80, 0x01) |
| Field (DEB0, ByteAcc, NoLock, Preserve) |
| { |
| DBG8, 8 |
| } |
| |
| OperationRegion (DEB1, SystemIO, DP90, 0x02) |
| Field (DEB1, WordAcc, NoLock, Preserve) |
| { |
| DBG9, 16 |
| } |
| |
| Scope (\_SB) |
| { |
| Name (PR00, Package (0x14) |
| { |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x02, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0002FFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0002FFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x02, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x02, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001EFFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001EFFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x00, |
| LNKE, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x00, |
| LNKG, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x01, |
| LNKH, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001BFFFF, |
| 0x00, |
| LNKD, |
| 0x00 |
| } |
| }) |
| Name (AR00, Package (0x14) |
| { |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x02, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0002FFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0002FFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x02, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001CFFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x02, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001EFFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001EFFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001DFFFF, |
| 0x00, |
| 0x00, |
| 0x14 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x00, |
| 0x00, |
| 0x16 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001FFFFF, |
| 0x01, |
| 0x00, |
| 0x17 |
| }, |
| |
| Package (0x04) |
| { |
| 0x001BFFFF, |
| 0x00, |
| 0x00, |
| 0x13 |
| } |
| }) |
| Name (PR01, Package (0x04) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| } |
| }) |
| Name (AR01, Package (0x04) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| } |
| }) |
| Name (PR03, Package (0x09) |
| { |
| Package (0x04) |
| { |
| 0x0008FFFF, |
| 0x00, |
| LNKE, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| LNKD, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x00, |
| LNKF, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x01, |
| LNKG, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x02, |
| LNKH, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x03, |
| LNKE, |
| 0x00 |
| } |
| }) |
| Name (AR03, Package (0x09) |
| { |
| Package (0x04) |
| { |
| 0x0008FFFF, |
| 0x00, |
| 0x00, |
| 0x14 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| 0x00, |
| 0x13 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x00, |
| 0x00, |
| 0x15 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x01, |
| 0x00, |
| 0x16 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x02, |
| 0x00, |
| 0x17 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0001FFFF, |
| 0x03, |
| 0x00, |
| 0x14 |
| } |
| }) |
| Name (PR09, Package (0x04) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| LNKA, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| LNKB, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| LNKC, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| LNKD, |
| 0x00 |
| } |
| }) |
| Name (AR09, Package (0x04) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| 0x00, |
| 0x10 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x01, |
| 0x00, |
| 0x11 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x02, |
| 0x00, |
| 0x12 |
| }, |
| |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x03, |
| 0x00, |
| 0x13 |
| } |
| }) |
| Name (PR08, Package (0x01) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| LNKB, |
| 0x00 |
| } |
| }) |
| Name (AR08, Package (0x01) |
| { |
| Package (0x04) |
| { |
| 0xFFFF, |
| 0x00, |
| 0x00, |
| 0x11 |
| } |
| }) |
| Name (PRSA, ResourceTemplate () |
| { |
| IRQ (Level, ActiveLow, Shared, ) |
| {3,4,5,6,7,10,11,12,14,15} |
| }) |
| Alias (PRSA, PRSB) |
| Alias (PRSA, PRSC) |
| Alias (PRSA, PRSD) |
| Alias (PRSA, PRSE) |
| Alias (PRSA, PRSF) |
| Alias (PRSA, PRSG) |
| Alias (PRSA, PRSH) |
| Device (PCI0) |
| { |
| Name (_HID, EisaId ("PNP0A08") /* PCI Express Bus */) // _HID: Hardware ID |
| Name (_CID, EisaId ("PNP0A03") /* PCI Bus */) // _CID: Compatible ID |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (^BN00, 0, NotSerialized) |
| { |
| Return (0x00) |
| } |
| |
| Method (_BBN, 0, NotSerialized) // _BBN: BIOS Bus Number |
| { |
| Return (BN00 ()) |
| } |
| |
| Name (_UID, 0x00) // _UID: Unique ID |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
| { |
| If (PICM) |
| { |
| Return (AR00) /* \_SB_.AR00 */ |
| } |
| |
| Return (PR00) /* \_SB_.PR00 */ |
| } |
| |
| Method (_S3D, 0, NotSerialized) // _S3D: S3 Device State |
| { |
| If ((OSFL () == 0x01) || (OSFL () == 0x02)) |
| { |
| Return (0x02) |
| } |
| Else |
| { |
| Return (0x03) |
| } |
| } |
| |
| Device (MCH) |
| { |
| Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID |
| Name (_UID, 0x0A) // _UID: Unique ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| Memory32Fixed (ReadWrite, |
| 0xFED13000, // Address Base |
| 0x00007000, // Address Length |
| ) |
| }) |
| } |
| |
| Method (NPTS, 1, NotSerialized) |
| { |
| } |
| |
| Method (NWAK, 1, NotSerialized) |
| { |
| } |
| |
| Device (P0P1) |
| { |
| Name (_ADR, 0x00010000) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
| { |
| If (PICM) |
| { |
| Return (AR01) /* \_SB_.AR01 */ |
| } |
| |
| Return (PR01) /* \_SB_.PR01 */ |
| } |
| } |
| |
| Device (P0P3) |
| { |
| Name (_ADR, 0x001E0000) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x0B, 0x04)) |
| } |
| |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
| { |
| If (PICM) |
| { |
| Return (AR03) /* \_SB_.AR03 */ |
| } |
| |
| Return (PR03) /* \_SB_.PR03 */ |
| } |
| } |
| |
| Device (P0P9) |
| { |
| Name (_ADR, 0x001C0000) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
| { |
| If (PICM) |
| { |
| Return (AR09) /* \_SB_.AR09 */ |
| } |
| |
| Return (PR09) /* \_SB_.PR09 */ |
| } |
| } |
| |
| Device (P0P8) |
| { |
| Name (_ADR, 0x001C0001) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| |
| Method (_PRT, 0, NotSerialized) // _PRT: PCI Routing Table |
| { |
| If (PICM) |
| { |
| Return (AR08) /* \_SB_.AR08 */ |
| } |
| |
| Return (PR08) /* \_SB_.PR08 */ |
| } |
| } |
| |
| Device (P0P7) |
| { |
| Name (_ADR, 0x001C0002) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| } |
| |
| Device (P0P6) |
| { |
| Name (_ADR, 0x001C0003) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| } |
| |
| Device (P0P5) |
| { |
| Name (_ADR, 0x001C0004) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| } |
| |
| Device (P0P4) |
| { |
| Name (_ADR, 0x001C0005) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x09, 0x04)) |
| } |
| } |
| |
| Device (SBRG) |
| { |
| Name (_ADR, 0x001F0000) // _ADR: Address |
| Method (SPTS, 1, NotSerialized) |
| { |
| PS1S = One |
| PS1E = One |
| \_SB.SLPS = One |
| } |
| |
| Method (SWAK, 1, NotSerialized) |
| { |
| \_SB.SLPS = Zero |
| PS1E = Zero |
| If (RTCS) {} |
| Else |
| { |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| If (AAXB & 0x02) |
| { |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| } |
| |
| OperationRegion (PMS0, SystemIO, PMBS, 0x04) |
| Field (PMS0, ByteAcc, NoLock, Preserve) |
| { |
| , 10, |
| RTCS, 1, |
| , 4, |
| WAKS, 1, |
| Offset (0x03), |
| PWBT, 1, |
| Offset (0x04) |
| } |
| |
| OperationRegion (SMIE, SystemIO, PM30, 0x08) |
| Field (SMIE, ByteAcc, NoLock, Preserve) |
| { |
| , 4, |
| PS1E, 1, |
| , 31, |
| PS1S, 1, |
| Offset (0x08) |
| } |
| |
| Scope (\_SB) |
| { |
| Name (SLPS, 0x00) |
| Device (SLPB) |
| { |
| Name (_HID, EisaId ("PNP0C0E") /* Sleep Button Device */) // _HID: Hardware ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| If (SUSW != 0xFF) |
| { |
| Return (0x0F) |
| } |
| |
| Return (0x00) |
| } |
| |
| Method (SBEV, 0, NotSerialized) |
| { |
| If (SLPS) |
| { |
| Notify (SLPB, 0x02) // Device Wake |
| } |
| Else |
| { |
| Notify (SLPB, 0x80) // Status Change |
| } |
| } |
| |
| Method (\_GPE._L1B, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| \_SB.SLPB.SBEV () |
| } |
| |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (Package (0x02) |
| { |
| 0x1B, |
| 0x04 |
| }) |
| } |
| } |
| } |
| |
| Device (PIC) |
| { |
| Name (_HID, EisaId ("PNP0000") /* 8259-compatible Programmable Interrupt Controller */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x0020, // Range Minimum |
| 0x0020, // Range Maximum |
| 0x00, // Alignment |
| 0x02, // Length |
| ) |
| IO (Decode16, |
| 0x00A0, // Range Minimum |
| 0x00A0, // Range Maximum |
| 0x00, // Alignment |
| 0x02, // Length |
| ) |
| IRQNoFlags () |
| {2} |
| }) |
| } |
| |
| Device (DMAD) |
| { |
| Name (_HID, EisaId ("PNP0200") /* PC-class DMA Controller */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| DMA (Compatibility, BusMaster, Transfer8, ) |
| {4} |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x10, // Length |
| ) |
| IO (Decode16, |
| 0x0081, // Range Minimum |
| 0x0081, // Range Maximum |
| 0x00, // Alignment |
| 0x03, // Length |
| ) |
| IO (Decode16, |
| 0x0087, // Range Minimum |
| 0x0087, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x0089, // Range Minimum |
| 0x0089, // Range Maximum |
| 0x00, // Alignment |
| 0x03, // Length |
| ) |
| IO (Decode16, |
| 0x008F, // Range Minimum |
| 0x008F, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x00C0, // Range Minimum |
| 0x00C0, // Range Maximum |
| 0x00, // Alignment |
| 0x20, // Length |
| ) |
| }) |
| } |
| |
| Device (TMR) |
| { |
| Name (_HID, EisaId ("PNP0100") /* PC-class System Timer */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x0040, // Range Minimum |
| 0x0040, // Range Maximum |
| 0x00, // Alignment |
| 0x04, // Length |
| ) |
| IRQNoFlags () |
| {0} |
| }) |
| } |
| |
| Device (RTC0) |
| { |
| Name (_HID, EisaId ("PNP0B00") /* AT Real-Time Clock */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x0070, // Range Minimum |
| 0x0070, // Range Maximum |
| 0x00, // Alignment |
| 0x02, // Length |
| ) |
| IRQNoFlags () |
| {8} |
| }) |
| } |
| |
| Device (SPKR) |
| { |
| Name (_HID, EisaId ("PNP0800") /* Microsoft Sound System Compatible Device */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x0061, // Range Minimum |
| 0x0061, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| }) |
| } |
| |
| Device (COPR) |
| { |
| Name (_HID, EisaId ("PNP0C04") /* x87-compatible Floating Point Processing Unit */) // _HID: Hardware ID |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x00F0, // Range Minimum |
| 0x00F0, // Range Maximum |
| 0x00, // Alignment |
| 0x10, // Length |
| ) |
| IRQNoFlags () |
| {13} |
| }) |
| } |
| |
| Device (FDC) |
| { |
| Name (_HID, EisaId ("PNP0700")) // _HID: Hardware ID |
| Method (_FDE, 0, NotSerialized) // _FDE: Floppy Disk Enumerate |
| { |
| Name (FDEP, Package (0x05) |
| { |
| 0x00, |
| 0x00, |
| 0x02, |
| 0x02, |
| 0x02 |
| }) |
| If (_STA ()) |
| { |
| FDEP [0x00] = 0x01 |
| } |
| |
| Return (FDEP) /* \_SB_.PCI0.SBRG.FDC_._FDE.FDEP */ |
| } |
| |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Return (DSTA (0x03)) |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| DCNT (0x03, 0x00) |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| DCRS (0x03, 0x01) |
| IRQE = IRQM /* \_SB_.PCI0.SBRG.IRQM */ |
| DMAE = DMAM /* \_SB_.PCI0.SBRG.DMAM */ |
| IO21 = IO11 /* \_SB_.PCI0.SBRG.IO11 */ |
| IO22 = IO12 /* \_SB_.PCI0.SBRG.IO12 */ |
| LEN2 = 0x06 |
| IO31 = (IO21 + 0x07) |
| IO32 = IO31 /* \_SB_.PCI0.SBRG.IO31 */ |
| LEN3 = 0x01 |
| Return (CRS2) /* \_SB_.PCI0.SBRG.CRS2 */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| DSRS (Arg0, 0x03) |
| CreateWordField (Arg0, 0x01, IRQE) |
| CreateByteField (Arg0, 0x04, DMAE) |
| ENFG (CGLD (0x03)) |
| If (IRQE) |
| { |
| FindSetRightBit (IRQE, Local0) |
| INTR = (Local0 - 0x01) |
| } |
| Else |
| { |
| INTR = 0x00 |
| } |
| |
| If (DMAE) |
| { |
| FindSetRightBit (DMAE, Local0) |
| DMCH = (Local0 - 0x01) |
| } |
| Else |
| { |
| DMCH = 0x04 |
| } |
| |
| EXFG () |
| } |
| |
| Name (_PRS, ResourceTemplate () // _PRS: Possible Resource Settings |
| { |
| StartDependentFn (0x00, 0x00) |
| { |
| IO (Decode16, |
| 0x03F0, // Range Minimum |
| 0x03F0, // Range Maximum |
| 0x01, // Alignment |
| 0x06, // Length |
| ) |
| IO (Decode16, |
| 0x03F7, // Range Minimum |
| 0x03F7, // Range Maximum |
| 0x01, // Alignment |
| 0x01, // Length |
| ) |
| IRQNoFlags () |
| {6} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {2} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x03F0, // Range Minimum |
| 0x03F0, // Range Maximum |
| 0x01, // Alignment |
| 0x06, // Length |
| ) |
| IO (Decode16, |
| 0x03F7, // Range Minimum |
| 0x03F7, // Range Maximum |
| 0x01, // Alignment |
| 0x01, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {0,1,2,3} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x0370, // Range Minimum |
| 0x0370, // Range Maximum |
| 0x01, // Alignment |
| 0x06, // Length |
| ) |
| IO (Decode16, |
| 0x0377, // Range Minimum |
| 0x0377, // Range Maximum |
| 0x01, // Alignment |
| 0x01, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {0,1,2,3} |
| } |
| EndDependentFn () |
| }) |
| } |
| |
| Device (LPTE) |
| { |
| Method (_HID, 0, NotSerialized) // _HID: Hardware ID |
| { |
| If (LPTM (0x02)) |
| { |
| Return (0x0104D041) |
| } |
| Else |
| { |
| Return (0x0004D041) |
| } |
| } |
| |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Return (DSTA (0x02)) |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| DCNT (0x02, 0x00) |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| DCRS (0x02, 0x01) |
| If (LPTM (0x02)) |
| { |
| IRQE = IRQM /* \_SB_.PCI0.SBRG.IRQM */ |
| DMAE = DMAM /* \_SB_.PCI0.SBRG.DMAM */ |
| IO21 = IO11 /* \_SB_.PCI0.SBRG.IO11 */ |
| IO22 = IO12 /* \_SB_.PCI0.SBRG.IO12 */ |
| LEN2 = LEN1 /* \_SB_.PCI0.SBRG.LEN1 */ |
| IO31 = (IO21 + 0x0400) |
| IO32 = IO31 /* \_SB_.PCI0.SBRG.IO31 */ |
| LEN3 = LEN2 /* \_SB_.PCI0.SBRG.LEN2 */ |
| Return (CRS2) /* \_SB_.PCI0.SBRG.CRS2 */ |
| } |
| Else |
| { |
| Return (CRS1) /* \_SB_.PCI0.SBRG.CRS1 */ |
| } |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| DSRS (Arg0, 0x02) |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| If (LPTM (0x02)) |
| { |
| Return (EPPR) /* \_SB_.PCI0.SBRG.LPTE.EPPR */ |
| } |
| Else |
| { |
| Return (LPPR) /* \_SB_.PCI0.SBRG.LPTE.LPPR */ |
| } |
| } |
| |
| Name (LPPR, ResourceTemplate () |
| { |
| StartDependentFn (0x00, 0x00) |
| { |
| IO (Decode16, |
| 0x0378, // Range Minimum |
| 0x0378, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {7} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x0378, // Range Minimum |
| 0x0378, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x0278, // Range Minimum |
| 0x0278, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x03BC, // Range Minimum |
| 0x03BC, // Range Maximum |
| 0x01, // Alignment |
| 0x04, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| } |
| EndDependentFn () |
| }) |
| Name (EPPR, ResourceTemplate () |
| { |
| StartDependentFn (0x00, 0x00) |
| { |
| IO (Decode16, |
| 0x0378, // Range Minimum |
| 0x0378, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IO (Decode16, |
| 0x0778, // Range Minimum |
| 0x0778, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {7} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {3} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x0378, // Range Minimum |
| 0x0378, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IO (Decode16, |
| 0x0778, // Range Minimum |
| 0x0778, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {0,1,2,3} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x0278, // Range Minimum |
| 0x0278, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IO (Decode16, |
| 0x0678, // Range Minimum |
| 0x0678, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {0,1,2,3} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x03BC, // Range Minimum |
| 0x03BC, // Range Maximum |
| 0x01, // Alignment |
| 0x04, // Length |
| ) |
| IO (Decode16, |
| 0x07BC, // Range Minimum |
| 0x07BC, // Range Maximum |
| 0x01, // Alignment |
| 0x04, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {0,1,2,3} |
| } |
| EndDependentFn () |
| }) |
| } |
| |
| Device (SIOR) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Method (_UID, 0, NotSerialized) // _UID: Unique ID |
| { |
| Return (SPIO) /* \SPIO */ |
| } |
| |
| Name (CRS, ResourceTemplate () |
| { |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| _Y00) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| ) |
| IO (Decode16, |
| 0x0290, // Range Minimum |
| 0x0290, // Range Maximum |
| 0x00, // Alignment |
| 0x08, // Length |
| ) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| If ((SPIO != 0x03F0) && (SPIO > 0xF0)) |
| { |
| CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MIN, GP10) // _MIN: Minimum Base Address |
| CreateWordField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._MAX, GP11) // _MAX: Maximum Base Address |
| CreateByteField (CRS, \_SB.PCI0.SBRG.SIOR._Y00._LEN, GPL1) // _LEN: Length |
| GP10 = SPIO /* \SPIO */ |
| GP11 = SPIO /* \SPIO */ |
| GPL1 = 0x02 |
| } |
| |
| Return (CRS) /* \_SB_.PCI0.SBRG.SIOR.CRS_ */ |
| } |
| } |
| |
| Name (DCAT, Package (0x15) |
| { |
| 0x02, |
| 0x03, |
| 0x01, |
| 0x00, |
| 0xFF, |
| 0x07, |
| 0xFF, |
| 0xFF, |
| 0x07, |
| 0xFF, |
| 0xFF, |
| 0xFF, |
| 0xFF, |
| 0xFF, |
| 0xFF, |
| 0xFF, |
| 0x07, |
| 0x08, |
| 0x09, |
| 0xFF, |
| 0xFF |
| }) |
| Mutex (IOCF, 0x00) |
| Method (ENFG, 1, NotSerialized) |
| { |
| Acquire (IOCF, 0xFFFF) |
| INDX = 0x87 |
| INDX = 0x87 |
| LDN = Arg0 |
| } |
| |
| Method (EXFG, 0, NotSerialized) |
| { |
| INDX = 0xAA |
| Release (IOCF) |
| } |
| |
| Method (LPTM, 1, NotSerialized) |
| { |
| ENFG (CGLD (Arg0)) |
| Local0 = (OPT0 & 0x02) |
| EXFG () |
| Return (Local0) |
| } |
| |
| Method (UHID, 1, NotSerialized) |
| { |
| If (Arg0 == 0x01) |
| { |
| ENFG (CGLD (Arg0)) |
| Local0 = (OPT1 & 0x38) |
| EXFG () |
| If (Local0) |
| { |
| Return (0x1005D041) |
| } |
| } |
| |
| Return (0x0105D041) |
| } |
| |
| Name (KBFG, 0x01) |
| Name (MSFG, 0x01) |
| Method (SIOK, 1, NotSerialized) |
| { |
| ENFG (0x0A) |
| If (Arg0 > 0x01) |
| { |
| CRE4 |= 0x10 |
| CRE0 = 0x00 |
| Local0 = CRE3 /* \_SB_.PCI0.SBRG.CRE3 */ |
| If (KBFG) |
| { |
| CRE0 |= 0x41 |
| } |
| |
| If (MSFG) |
| { |
| CRE0 |= 0x22 |
| CRE6 |= 0x80 |
| } |
| } |
| ElseIf (Arg0 == 0x01) |
| { |
| OPT6 = 0x00 |
| OPT3 |= 0xFF |
| OPT4 |= 0xFF |
| If (KBFG) |
| { |
| OPT6 |= 0x10 |
| } |
| |
| If (MSFG) |
| { |
| OPT6 |= 0x20 |
| } |
| } |
| |
| Local0 = CRE3 /* \_SB_.PCI0.SBRG.CRE3 */ |
| EXFG () |
| } |
| |
| Method (SIOS, 1, NotSerialized) |
| { |
| Debug = "SIOS" |
| SIOK (Arg0) |
| } |
| |
| Method (SIOW, 1, NotSerialized) |
| { |
| Debug = "SIOW" |
| SIOK (0x00) |
| } |
| |
| Method (SIOH, 0, NotSerialized) |
| { |
| Debug = "SIOH" |
| ENFG (0x0A) |
| If (OPT3 & 0x10) |
| { |
| Notify (PS2K, 0x02) // Device Wake |
| } |
| |
| If (OPT3 & 0x20) |
| { |
| Notify (PS2M, 0x02) // Device Wake |
| } |
| |
| EXFG () |
| SIOK (Zero) |
| } |
| |
| OperationRegion (IOID, SystemIO, SPIO, 0x02) |
| Field (IOID, ByteAcc, NoLock, Preserve) |
| { |
| INDX, 8, |
| DATA, 8 |
| } |
| |
| IndexField (INDX, DATA, ByteAcc, NoLock, Preserve) |
| { |
| Offset (0x07), |
| LDN, 8, |
| Offset (0x22), |
| FDCP, 1, |
| , 2, |
| LPTP, 1, |
| URAP, 1, |
| URBP, 1, |
| Offset (0x30), |
| ACTR, 8, |
| Offset (0x60), |
| IOAH, 8, |
| IOAL, 8, |
| IOH2, 8, |
| IOL2, 8, |
| Offset (0x70), |
| INTR, 4, |
| Offset (0x74), |
| DMCH, 3, |
| Offset (0xE0), |
| CRE0, 8, |
| CRE1, 8, |
| CRE2, 8, |
| CRE3, 8, |
| CRE4, 8, |
| CRE5, 8, |
| CRE6, 8, |
| Offset (0xF0), |
| OPT0, 8, |
| OPT1, 8, |
| OPT2, 8, |
| OPT3, 8, |
| OPT4, 8, |
| OPT5, 8, |
| OPT6, 8, |
| Offset (0xF9), |
| OPT9, 8 |
| } |
| |
| Method (CGLD, 1, NotSerialized) |
| { |
| Return (DerefOf (DCAT [Arg0])) |
| } |
| |
| Method (DSTA, 1, NotSerialized) |
| { |
| ENFG (CGLD (Arg0)) |
| Local0 = ACTR /* \_SB_.PCI0.SBRG.ACTR */ |
| EXFG () |
| If (Local0 == 0xFF) |
| { |
| Return (0x00) |
| } |
| |
| If (Arg0 == 0x05) |
| { |
| Local0 >>= 0x02 |
| } |
| |
| If (Arg0 == 0x08) |
| { |
| Local0 >>= 0x01 |
| } |
| |
| Local0 &= 0x01 |
| IOST |= (Local0 << Arg0) |
| If (Local0) |
| { |
| Return (0x0F) |
| } |
| ElseIf ((0x01 << Arg0) & IOST) |
| { |
| Return (0x0D) |
| } |
| Else |
| { |
| Return (0x00) |
| } |
| } |
| |
| Method (DCNT, 2, NotSerialized) |
| { |
| ENFG (CGLD (Arg0)) |
| If (Arg0 == 0x05) |
| { |
| Local1 = (IOH2 << 0x08) |
| Local1 |= IOL2 |
| } |
| Else |
| { |
| Local1 = (IOAH << 0x08) |
| Local1 |= IOAL |
| } |
| |
| RRIO (Arg0, Arg1, Local1, 0x08) |
| If ((DMCH < 0x04) && ((Local1 = (DMCH & 0x03)) != 0x00)) |
| { |
| RDMA (Arg0, Arg1, Local1++) |
| } |
| |
| Local1 = Arg1 |
| Local2 = 0x01 |
| If (Arg0 == 0x05) |
| { |
| Local1 = (Arg1 << 0x02) |
| Local2 <<= 0x02 |
| } |
| |
| If (Arg0 == 0x08) |
| { |
| Local1 = (Arg1 << 0x01) |
| Local2 <<= 0x01 |
| } |
| |
| Local0 = ACTR /* \_SB_.PCI0.SBRG.ACTR */ |
| Local3 = ~Local2 |
| Local0 &= Local3 |
| Local0 |= Local1 |
| ACTR = Local0 |
| EXFG () |
| } |
| |
| Name (CRS1, ResourceTemplate () |
| { |
| IRQNoFlags (_Y01) |
| {} |
| DMA (Compatibility, NotBusMaster, Transfer8, _Y02) |
| {} |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x01, // Alignment |
| 0x00, // Length |
| _Y03) |
| }) |
| CreateWordField (CRS1, \_SB.PCI0.SBRG._Y01._INT, IRQM) // _INT: Interrupts |
| CreateByteField (CRS1, \_SB.PCI0.SBRG._Y02._DMA, DMAM) // _DMA: Direct Memory Access |
| CreateWordField (CRS1, \_SB.PCI0.SBRG._Y03._MIN, IO11) // _MIN: Minimum Base Address |
| CreateWordField (CRS1, \_SB.PCI0.SBRG._Y03._MAX, IO12) // _MAX: Maximum Base Address |
| CreateByteField (CRS1, \_SB.PCI0.SBRG._Y03._LEN, LEN1) // _LEN: Length |
| Name (CRS2, ResourceTemplate () |
| { |
| IRQNoFlags (_Y04) |
| {6} |
| DMA (Compatibility, NotBusMaster, Transfer8, _Y05) |
| {2} |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x01, // Alignment |
| 0x00, // Length |
| _Y06) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x01, // Alignment |
| 0x00, // Length |
| _Y07) |
| }) |
| CreateWordField (CRS2, \_SB.PCI0.SBRG._Y04._INT, IRQE) // _INT: Interrupts |
| CreateByteField (CRS2, \_SB.PCI0.SBRG._Y05._DMA, DMAE) // _DMA: Direct Memory Access |
| CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MIN, IO21) // _MIN: Minimum Base Address |
| CreateWordField (CRS2, \_SB.PCI0.SBRG._Y06._MAX, IO22) // _MAX: Maximum Base Address |
| CreateByteField (CRS2, \_SB.PCI0.SBRG._Y06._LEN, LEN2) // _LEN: Length |
| CreateWordField (CRS2, \_SB.PCI0.SBRG._Y07._MIN, IO31) // _MIN: Minimum Base Address |
| CreateWordField (CRS2, \_SB.PCI0.SBRG._Y07._MAX, IO32) // _MAX: Maximum Base Address |
| CreateByteField (CRS2, \_SB.PCI0.SBRG._Y07._LEN, LEN3) // _LEN: Length |
| Method (DCRS, 2, NotSerialized) |
| { |
| ENFG (CGLD (Arg0)) |
| IO11 = (IOAH << 0x08) |
| IO11 |= IOAL /* \_SB_.PCI0.SBRG.IO11 */ |
| IO12 = IO11 /* \_SB_.PCI0.SBRG.IO11 */ |
| Local0 = (FindSetRightBit (IO11) - 0x01) |
| LEN1 = (0x01 << Local0) |
| If (INTR) |
| { |
| IRQM = (0x01 << INTR) /* \_SB_.PCI0.SBRG.INTR */ |
| } |
| Else |
| { |
| IRQM = 0x00 |
| } |
| |
| If ((DMCH > 0x03) || (Arg1 == 0x00)) |
| { |
| DMAM = 0x00 |
| } |
| Else |
| { |
| Local1 = (DMCH & 0x03) |
| DMAM = (0x01 << Local1) |
| } |
| |
| EXFG () |
| Return (CRS1) /* \_SB_.PCI0.SBRG.CRS1 */ |
| } |
| |
| Method (DSRS, 2, NotSerialized) |
| { |
| CreateWordField (Arg0, 0x01, IRQM) |
| CreateByteField (Arg0, 0x04, DMAM) |
| CreateWordField (Arg0, 0x08, IO11) |
| ENFG (CGLD (Arg1)) |
| IOAL = (IO11 & 0xFF) |
| IOAH = (IO11 >> 0x08) |
| If (IRQM) |
| { |
| FindSetRightBit (IRQM, Local0) |
| INTR = (Local0 - 0x01) |
| } |
| Else |
| { |
| INTR = 0x00 |
| } |
| |
| If (DMAM) |
| { |
| FindSetRightBit (DMAM, Local0) |
| DMCH = (Local0 - 0x01) |
| } |
| Else |
| { |
| DMCH = 0x07 |
| } |
| |
| EXFG () |
| DCNT (Arg1, 0x01) |
| } |
| |
| Device (RMSC) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Name (_UID, 0x10) // _UID: Unique ID |
| Name (CRS, ResourceTemplate () |
| { |
| IO (Decode16, |
| 0x0010, // Range Minimum |
| 0x0010, // Range Maximum |
| 0x00, // Alignment |
| 0x10, // Length |
| ) |
| IO (Decode16, |
| 0x0022, // Range Minimum |
| 0x0022, // Range Maximum |
| 0x00, // Alignment |
| 0x1E, // Length |
| ) |
| IO (Decode16, |
| 0x0044, // Range Minimum |
| 0x0044, // Range Maximum |
| 0x00, // Alignment |
| 0x1C, // Length |
| ) |
| IO (Decode16, |
| 0x0062, // Range Minimum |
| 0x0062, // Range Maximum |
| 0x00, // Alignment |
| 0x02, // Length |
| ) |
| IO (Decode16, |
| 0x0065, // Range Minimum |
| 0x0065, // Range Maximum |
| 0x00, // Alignment |
| 0x0B, // Length |
| ) |
| IO (Decode16, |
| 0x0072, // Range Minimum |
| 0x0072, // Range Maximum |
| 0x00, // Alignment |
| 0x0E, // Length |
| ) |
| IO (Decode16, |
| 0x0080, // Range Minimum |
| 0x0080, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x0084, // Range Minimum |
| 0x0084, // Range Maximum |
| 0x00, // Alignment |
| 0x03, // Length |
| ) |
| IO (Decode16, |
| 0x0088, // Range Minimum |
| 0x0088, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x008C, // Range Minimum |
| 0x008C, // Range Maximum |
| 0x00, // Alignment |
| 0x03, // Length |
| ) |
| IO (Decode16, |
| 0x0090, // Range Minimum |
| 0x0090, // Range Maximum |
| 0x00, // Alignment |
| 0x10, // Length |
| ) |
| IO (Decode16, |
| 0x00A2, // Range Minimum |
| 0x00A2, // Range Maximum |
| 0x00, // Alignment |
| 0x1E, // Length |
| ) |
| IO (Decode16, |
| 0x00E0, // Range Minimum |
| 0x00E0, // Range Maximum |
| 0x00, // Alignment |
| 0x10, // Length |
| ) |
| IO (Decode16, |
| 0x04D0, // Range Minimum |
| 0x04D0, // Range Maximum |
| 0x00, // Alignment |
| 0x02, // Length |
| ) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| _Y08) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| _Y09) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| _Y0A) |
| IO (Decode16, |
| 0x0000, // Range Minimum |
| 0x0000, // Range Maximum |
| 0x00, // Alignment |
| 0x00, // Length |
| _Y0B) |
| Memory32Fixed (ReadWrite, |
| 0xFED1C000, // Address Base |
| 0x00004000, // Address Length |
| ) |
| Memory32Fixed (ReadWrite, |
| 0xFED20000, // Address Base |
| 0x00070000, // Address Length |
| ) |
| Memory32Fixed (ReadWrite, |
| 0xFFB00000, // Address Base |
| 0x00100000, // Address Length |
| ) |
| Memory32Fixed (ReadWrite, |
| 0xFFF00000, // Address Base |
| 0x00100000, // Address Length |
| ) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._MIN, GP00) // _MIN: Minimum Base Address |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._MAX, GP01) // _MAX: Maximum Base Address |
| CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y08._LEN, GP0L) // _LEN: Length |
| GP00 = PMBS /* \PMBS */ |
| GP01 = PMBS /* \PMBS */ |
| GP0L = PMLN /* \PMLN */ |
| If (SMBH) |
| { |
| If (SMBS) |
| { |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MIN, GP10) // _MIN: Minimum Base Address |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._MAX, GP11) // _MAX: Maximum Base Address |
| CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y09._LEN, GP1L) // _LEN: Length |
| GP10 = SMBS /* \SMBS */ |
| GP11 = SMBS /* \SMBS */ |
| GP1L = SMBL /* \SMBL */ |
| } |
| } |
| |
| If (GPBS) |
| { |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MIN, GP20) // _MIN: Minimum Base Address |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._MAX, GP21) // _MAX: Maximum Base Address |
| CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0A._LEN, GP2L) // _LEN: Length |
| GP20 = GPBS /* \GPBS */ |
| GP21 = GPBS /* \GPBS */ |
| GP2L = GPLN /* \GPLN */ |
| } |
| |
| If (CPUC >= 0x02) |
| { |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MIN, GP30) // _MIN: Minimum Base Address |
| CreateWordField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._MAX, GP31) // _MAX: Maximum Base Address |
| CreateByteField (CRS, \_SB.PCI0.SBRG.RMSC._Y0B._LEN, GP3L) // _LEN: Length |
| GP30 = 0x0900 |
| GP31 = 0x0900 |
| If (CPUC >= 0x04) |
| { |
| GP3L = 0x20 |
| } |
| Else |
| { |
| GP3L = 0x10 |
| } |
| } |
| |
| Return (CRS) /* \_SB_.PCI0.SBRG.RMSC.CRS_ */ |
| } |
| } |
| |
| Device (P3F6) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Name (_UID, 0x03F6) // _UID: Unique ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Local1 = 0x0F |
| Local0 = \_SB.PCI0.IDE0.PAMD |
| Local0 &= 0xF5 |
| If (Local0 == 0x80) |
| { |
| Local1 = 0x00 |
| } |
| |
| Local0 = \_SB.PCI0.IDE1.SAMD |
| Local0 &= 0xF5 |
| If (Local0 == 0x80) |
| { |
| Local1 = 0x00 |
| } |
| |
| Return (Local1) |
| } |
| |
| Name (CRS, ResourceTemplate () |
| { |
| IO (Decode16, |
| 0x03F6, // Range Minimum |
| 0x03F6, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Return (CRS) /* \_SB_.PCI0.SBRG.P3F6.CRS_ */ |
| } |
| } |
| |
| OperationRegion (IODC, PCI_Config, 0x80, 0x0A) |
| Field (IODC, ByteAcc, NoLock, Preserve) |
| { |
| CADC, 3, |
| , 1, |
| CBDC, 3, |
| Offset (0x01), |
| LPDC, 2, |
| , 2, |
| FDDC, 1, |
| Offset (0x02), |
| CAEN, 1, |
| CBEN, 1, |
| LPEN, 1, |
| FDEN, 1, |
| Offset (0x03), |
| GLEN, 1, |
| GHEN, 1, |
| KBEN, 1, |
| MCEN, 1, |
| C1EN, 1, |
| C2EN, 1, |
| Offset (0x04), |
| G1EN, 1, |
| , 6, |
| G1D1, 1, |
| G1D2, 8, |
| Offset (0x08), |
| G2EN, 1, |
| , 3, |
| G2D1, 4, |
| G2D2, 8 |
| } |
| |
| Method (PDEC, 2, NotSerialized) |
| { |
| If (Arg0 == 0x00) |
| { |
| If (Arg1 == 0x03F8) |
| { |
| CADC = 0x00 |
| } |
| |
| If (Arg1 == 0x02F8) |
| { |
| CADC = 0x01 |
| } |
| |
| If (Arg1 == 0x02E8) |
| { |
| CADC = 0x05 |
| } |
| |
| If (Arg1 == 0x03E8) |
| { |
| CADC = 0x07 |
| } |
| |
| CAEN = One |
| } |
| |
| If (Arg0 == 0x01) |
| { |
| If (Arg1 == 0x03F8) |
| { |
| CBDC = 0x00 |
| } |
| |
| If (Arg1 == 0x02F8) |
| { |
| CBDC = 0x01 |
| } |
| |
| If (Arg1 == 0x02E8) |
| { |
| CBDC = 0x05 |
| } |
| |
| If (Arg1 == 0x03E8) |
| { |
| CBDC = 0x07 |
| } |
| |
| CBEN = One |
| } |
| |
| If (Arg0 == 0x02) |
| { |
| If (Arg1 == 0x0378) |
| { |
| LPDC = 0x00 |
| } |
| |
| If (Arg1 == 0x0278) |
| { |
| LPDC = 0x01 |
| } |
| |
| If (Arg1 == 0x03BC) |
| { |
| LPDC = 0x02 |
| } |
| |
| LPEN = One |
| } |
| |
| If (Arg0 == 0x08) |
| { |
| If (Arg1 == 0x0200) |
| { |
| GLEN = One |
| GHEN = Zero |
| } |
| |
| If (Arg1 == 0x0208) |
| { |
| GLEN = Zero |
| GHEN = One |
| } |
| } |
| } |
| |
| Device (HPET) |
| { |
| Name (_HID, EisaId ("PNP0103") /* HPET System Timer */) // _HID: Hardware ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadOnly, |
| 0xFED00000, // Address Base |
| 0x00000400, // Address Length |
| _Y0C) |
| }) |
| OperationRegion (HPTC, SystemMemory, HTBA, 0x04) |
| Field (HPTC, ByteAcc, NoLock, Preserve) |
| { |
| HPTS, 2, |
| , 5, |
| HPTE, 1, |
| Offset (0x04) |
| } |
| |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| If (OSFL () == 0x00) |
| { |
| If (HPTE) |
| { |
| Return (0x0F) |
| } |
| } |
| ElseIf (HPTE) |
| { |
| Return (0x0B) |
| } |
| |
| Return (0x00) |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.HPET._Y0C._BAS, HPT) // _BAS: Base Address |
| Local0 = (HPTS * 0x1000) |
| HPT = (Local0 + 0xFED00000) |
| Return (CRS) /* \_SB_.PCI0.SBRG.HPET.CRS_ */ |
| } |
| } |
| |
| Scope (\) |
| { |
| OperationRegion (\RAMW, SystemMemory, (TOPM - 0x00010000), 0x00010000) |
| Field (\RAMW, ByteAcc, NoLock, Preserve) |
| { |
| PAR0, 32, |
| PAR1, 32 |
| } |
| |
| OperationRegion (IOB2, SystemIO, 0xB2, 0x02) |
| Field (IOB2, ByteAcc, NoLock, Preserve) |
| { |
| SMIC, 8, |
| SMIS, 8 |
| } |
| |
| Method (ISMI, 1, Serialized) |
| { |
| SMIC = Arg0 |
| } |
| |
| Method (GNVS, 1, Serialized) |
| { |
| PAR0 = Arg0 |
| ISMI (0x70) |
| Return (PAR1) /* \PAR1 */ |
| } |
| |
| Method (SNVS, 2, Serialized) |
| { |
| PAR0 = Arg0 |
| PAR1 = Arg1 |
| ISMI (0x71) |
| } |
| } |
| |
| Scope (\_SB.PCI0.SBRG) |
| { |
| OperationRegion (DEB2, SystemIO, 0x80, 0x04) |
| Field (DEB2, WordAcc, NoLock, Preserve) |
| { |
| DBGE, 22 |
| } |
| |
| Scope (\) |
| { |
| Field (\RAMW, ByteAcc, NoLock, Preserve) |
| { |
| Offset (0x08), |
| ADSP, 32, |
| CFEQ, 16, |
| CFSB, 8, |
| AITU, 8, |
| CPMU, 8, |
| FSBF, 16, |
| MEMF, 8, |
| CHTP, 8, |
| CHTE, 8, |
| NOST, 4, |
| NOSS, 4, |
| NOS1, 4, |
| NOS2, 4, |
| OCPI, 4, |
| OVCP, 4, |
| CPUQ, 1, |
| CQFS, 3, |
| CQFT, 4, |
| OVID, 8, |
| UVID, 8, |
| AIDI, 8, |
| MMOV, 4, |
| CPOV, 4, |
| CHQ1, 1, |
| CQS1, 3, |
| CQF1, 4, |
| VRM1, 8 |
| } |
| } |
| |
| OperationRegion (SSMI, SystemIO, 0xB2, 0x02) |
| Field (SSMI, ByteAcc, NoLock, Preserve) |
| { |
| SMIC, 8, |
| SMID, 8 |
| } |
| |
| Device (ASOC) |
| { |
| Mutex (AMTX, 0x00) |
| Name (_HID, "ATK0110") // _HID: Hardware ID |
| Name (_UID, 0x01010110) // _UID: Unique ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| If (AIDI) |
| { |
| Return (0x00) |
| } |
| Else |
| { |
| Return (0x0F) |
| } |
| } |
| |
| Name (MBIF, Package (0x08) |
| { |
| 0x01, |
| "P5GC-MX", |
| 0x01, |
| 0x00, |
| 0x02, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| Method (ASIF, 0, NotSerialized) |
| { |
| Return (MBIF) /* \_SB_.PCI0.SBRG.ASOC.MBIF */ |
| } |
| |
| Name (QCFN, Package (0x05) |
| { |
| 0x04060003, |
| "CPU Q-Fan Control", |
| 0x00, |
| 0x01, |
| 0x00030001 |
| }) |
| Name (QFLO, Package (0x06) |
| { |
| 0x04050004, |
| "CPU Q-Fan Ratio", |
| 0x3C, |
| 0x5A, |
| 0x05, |
| 0x01 |
| }) |
| Name (QFTP, Package (0x06) |
| { |
| 0x04030005, |
| "CPU Target Temperature", |
| 0x26, |
| 0x3E, |
| 0x09, |
| 0x00030001 |
| }) |
| Name (CFE1, Package (0x05) |
| { |
| 0x04060006, |
| "Chassis1 Q-Fan Control", |
| 0x00, |
| 0x01, |
| 0x00 |
| }) |
| Name (CFR1, Package (0x06) |
| { |
| 0x04050007, |
| "Chassis1 Q-Fan Ratio", |
| 0x3C, |
| 0x5A, |
| 0x05, |
| 0x00 |
| }) |
| Name (CFT1, Package (0x06) |
| { |
| 0x04030008, |
| "Chassis1 Target Temperature", |
| 0x26, |
| 0x3E, |
| 0x09, |
| 0x00 |
| }) |
| Name (EACF, Package (0x06) |
| { |
| 0x04050009, |
| "CPU Smart Fan Profile", |
| 0x00, |
| 0x02, |
| 0x03, |
| 0x00 |
| }) |
| Name (EAFC, Package (0x06) |
| { |
| 0x0405000A, |
| "Chassis Smart Fan Profile", |
| 0x00, |
| 0x02, |
| 0x03, |
| 0x00 |
| }) |
| Name (OBUF, Package (0x08) |
| { |
| QCFN, |
| QFLO, |
| QFTP, |
| CFE1, |
| CFR1, |
| CFT1, |
| EACF, |
| EAFC |
| }) |
| Method (OCIF, 0, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| QFLO [0x05] = 0x00 |
| QFTP [0x05] = 0x00 |
| CFR1 [0x05] = 0x00 |
| CFT1 [0x05] = 0x00 |
| EACF [0x05] = 0x00010003 |
| EAFC [0x05] = 0x00010003 |
| Release (AMTX) |
| Return (OBUF) /* \_SB_.PCI0.SBRG.ASOC.OBUF */ |
| } |
| |
| Method (OCOP, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local1 = DerefOf (QCFN [0x00]) |
| If (Arg0 == Local1) |
| { |
| CQFN [0x02] = CPUQ /* \CPUQ */ |
| Release (AMTX) |
| Return (CQFN) /* \_SB_.PCI0.SBRG.ASOC.CQFN */ |
| } |
| |
| Local1 = DerefOf (EACF [0x00]) |
| If (Arg0 == Local1) |
| { |
| EACC [0x02] = CQFS /* \CQFS */ |
| Release (AMTX) |
| Return (EACC) /* \_SB_.PCI0.SBRG.ASOC.EACC */ |
| } |
| |
| Local1 = DerefOf (CFE1 [0x00]) |
| If (Arg0 == Local1) |
| { |
| CQE1 [0x02] = CHQ1 /* \CHQ1 */ |
| Release (AMTX) |
| Return (CQE1) /* \_SB_.PCI0.SBRG.ASOC.CQE1 */ |
| } |
| |
| Local1 = DerefOf (EAFC [0x00]) |
| If (Arg0 == Local1) |
| { |
| EAFF [0x02] = CQS1 /* \CQS1 */ |
| Release (AMTX) |
| Return (EAFF) /* \_SB_.PCI0.SBRG.ASOC.EAFF */ |
| } |
| |
| Release (AMTX) |
| } |
| |
| Name (CQFN, Package (0x06) |
| { |
| 0x04060003, |
| 0x00, |
| 0x00, |
| 0x01, |
| "Disabled", |
| "Enabled" |
| }) |
| Name (QFNR, Package (0x09) |
| { |
| 0x04050004, |
| 0x5A, |
| 0x00, |
| 0x01, |
| "Auto", |
| "90%", |
| "80%", |
| "70%", |
| "60%" |
| }) |
| Name (EACC, Package (0x07) |
| { |
| 0x04050009, |
| 0x00, |
| 0x00, |
| 0x01, |
| "Optimal", |
| "Silent", |
| "Performance" |
| }) |
| Name (EAFF, Package (0x07) |
| { |
| 0x0405000A, |
| 0x00, |
| 0x00, |
| 0x00, |
| "Optimal", |
| "Silent", |
| "Performance" |
| }) |
| Name (QFNT, Package (0x0F) |
| { |
| 0x04030005, |
| 0x42, |
| 0x05, |
| 0x01, |
| "51", |
| "54", |
| "57", |
| "60", |
| "63", |
| "66", |
| "69", |
| "72", |
| "75", |
| "78", |
| "81" |
| }) |
| Name (CQE1, Package (0x06) |
| { |
| 0x04060006, |
| 0x00, |
| 0x00, |
| 0x00, |
| "Disabled", |
| "Enabled" |
| }) |
| Name (CQR1, Package (0x09) |
| { |
| 0x04050007, |
| 0x5A, |
| 0x00, |
| 0x01, |
| "Auto", |
| "90%", |
| "80%", |
| "70%", |
| "60%" |
| }) |
| Name (CQT1, Package (0x0F) |
| { |
| 0x04030008, |
| 0x42, |
| 0x05, |
| 0x01, |
| "51", |
| "54", |
| "57", |
| "60", |
| "63", |
| "66", |
| "69", |
| "72", |
| "75", |
| "78", |
| "81" |
| }) |
| Name (OCST, Package (0x17) |
| { |
| Package (0x02) |
| { |
| 0x01010000, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x01060001, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x02010002, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x07010003, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x05050004, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x08050005, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x08050006, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04040007, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x01020008, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x02020009, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0702000A, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0106000B, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0906000C, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0806000D, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04060003, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04050004, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04030005, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04060006, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04050007, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04030008, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x04050009, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0405000A, |
| 0x01 |
| }, |
| |
| Package (0x02) |
| { |
| 0x0806000E, |
| 0x01 |
| } |
| }) |
| Method (PROC, 3, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local1 = DerefOf (QCFN [0x00]) |
| If (Arg0 == Local1) |
| { |
| If (Arg1 != CPUQ) |
| { |
| If (Arg2 == 0x00) |
| { |
| DerefOf (OCST [0x0E]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| ElseIf (Arg1 == 0x01) |
| { |
| Local4 = 0x03 |
| } |
| Else |
| { |
| Local4 = 0x00 |
| } |
| } |
| Else |
| { |
| DerefOf (OCST [0x0E]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| |
| Local1 = DerefOf (EACF [0x00]) |
| If (Arg0 == Local1) |
| { |
| If (Arg1 != CQFS) |
| { |
| If (Arg2 == 0x00) |
| { |
| DerefOf (OCST [0x14]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| Else |
| { |
| Local0 = Arg1 |
| CQFS = Local0 |
| Local0 *= 0x0A |
| Local0 += 0x41 |
| If (Local0 == 0x55) |
| { |
| Local0 -= 0x1E |
| } |
| |
| ^^SIOR.BSEL = 0x00 |
| ^^SIOR.TRGT = Local0 |
| ^^SIOR.CFNS = 0x00 |
| Sleep (0x64) |
| ^^SIOR.CFNS = 0x03 |
| DerefOf (OCST [0x14]) [0x01] = 0x01 |
| SMID = 0x0A |
| SMIC = 0xAB |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| Else |
| { |
| DerefOf (OCST [0x14]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| |
| Local1 = DerefOf (CFE1 [0x00]) |
| If (Arg0 == Local1) |
| { |
| If (Arg1 != CHQ1) |
| { |
| If (Arg2 == 0x00) |
| { |
| DerefOf (OCST [0x11]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| Else |
| { |
| CHQ1 = Arg1 |
| DerefOf (OCST [0x11]) [0x01] = 0x01 |
| ^^SIOR.BSEL = 0x00 |
| ^^SIOR.CHNS = Arg1 |
| SMID = 0x0E |
| SMIC = 0xAB |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| Else |
| { |
| DerefOf (OCST [0x11]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| |
| Local1 = DerefOf (EAFC [0x00]) |
| If (Arg0 == Local1) |
| { |
| If (Arg1 != CQS1) |
| { |
| If (Arg2 == 0x00) |
| { |
| DerefOf (OCST [0x15]) [0x01] = 0x01 |
| Release (AMTX) |
| Return (0x01) |
| } |
| Else |
| { |
| Local0 = Arg1 |
| CQS1 = Local0 |
| Local2 = (Local0 * 0x0A) |
| Local2 += 0x28 |
| Local4 = (Local0 * 0x19) |
| Local4 += 0xB2 |
| If (Local2 == 0x3C) |
| { |
| (Local2 - 0x1E) |
| (Local4 - 0x4B) |
| } |
| |
| ^^SIOR.BSEL = 0x00 |
| ^^SIOR.SYST = Local2 |
| ^^SIOR.SSUP = Local4 |
| ^^SIOR.SSDN = Local4 |
| DerefOf (OCST [0x15]) [0x01] = 0x01 |
| SMID = 0x0F |
| SMIC = 0xAB |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| Else |
| { |
| DerefOf (OCST [0x15]) [0x01] = 0x02 |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| |
| Release (AMTX) |
| } |
| |
| Name (PREB, Package (0x2E) |
| { |
| 0x01010000, |
| 0x00, |
| 0x01060001, |
| 0x00, |
| 0x02010002, |
| 0x00, |
| 0x07010003, |
| 0x00, |
| 0x05050004, |
| 0x00, |
| 0x08050005, |
| 0x00, |
| 0x08050006, |
| 0x00, |
| 0x04040007, |
| 0x00, |
| 0x01020008, |
| 0x00, |
| 0x02020009, |
| 0x00, |
| 0x0702000A, |
| 0x00, |
| 0x0106000B, |
| 0x00, |
| 0x0906000C, |
| 0x00, |
| 0x0806000D, |
| 0x00, |
| 0x04060003, |
| 0x00, |
| 0x04050004, |
| 0x00, |
| 0x04030005, |
| 0x00, |
| 0x04060006, |
| 0x00, |
| 0x04050007, |
| 0x00, |
| 0x04030008, |
| 0x00, |
| 0x04050009, |
| 0x00, |
| 0x0405000A, |
| 0x00, |
| 0x0806000E, |
| 0x00 |
| }) |
| Method (GPRE, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| If (Arg0 == 0x00) |
| { |
| Release (AMTX) |
| Return (PREB) /* \_SB_.PCI0.SBRG.ASOC.PREB */ |
| } |
| Else |
| { |
| PREB [0x1D] = CPUQ /* \CPUQ */ |
| PREB [0x1F] = CQFS /* \CQFS */ |
| PREB [0x21] = CQFT /* \CQFT */ |
| Release (AMTX) |
| Return (PREB) /* \_SB_.PCI0.SBRG.ASOC.PREB */ |
| } |
| } |
| |
| Method (SPRE, 2, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = DerefOf (DerefOf (PREB [0x00]) [0x00]) |
| Local1 = DerefOf (DerefOf (PREB [0x00]) [0x01]) |
| Local2 = PROC (Local0, Local1, 0x00) |
| PROC (Local0, Local1, 0x01) |
| Release (AMTX) |
| } |
| } |
| } |
| |
| Device (\_SB.PCI0.PCIE) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Name (_UID, 0x11) // _UID: Unique ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadOnly, |
| 0xE0000000, // Address Base |
| 0x10000000, // Address Length |
| _Y0D) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._BAS, BAS1) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.PCI0.PCIE._Y0D._LEN, LEN1) // _LEN: Length |
| BAS1 = \PCIB |
| LEN1 = \PCIL |
| Return (CRS) /* \_SB_.PCI0.PCIE.CRS_ */ |
| } |
| } |
| |
| Device (PS2K) |
| { |
| Name (_HID, EisaId ("PNP0303") /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */) // _HID: Hardware ID |
| Name (_CID, EisaId ("PNP030B")) // _CID: Compatible ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Local0 = (0x01 << 0x0A) |
| If (IOST & Local0) |
| { |
| Return (0x0F) |
| } |
| |
| Return (0x00) |
| } |
| |
| Name (_CRS, ResourceTemplate () // _CRS: Current Resource Settings |
| { |
| IO (Decode16, |
| 0x0060, // Range Minimum |
| 0x0060, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x0064, // Range Minimum |
| 0x0064, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IRQNoFlags () |
| {1} |
| }) |
| } |
| |
| Method (PS2K._PSW, 1, NotSerialized) // _PSW: Power State Wake |
| { |
| If (!((OSFL () == 0x01) || (OSFL () == 0x02))) |
| { |
| KBFG = Arg0 |
| } |
| } |
| |
| Method (PS2K._PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x1D, 0x04)) |
| } |
| |
| Device (PS2M) |
| { |
| Name (_HID, EisaId ("PNP0F03") /* Microsoft PS/2-style Mouse */) // _HID: Hardware ID |
| Name (_CID, EisaId ("PNP0F13") /* PS/2 Mouse */) // _CID: Compatible ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Local0 = (0x01 << 0x0C) |
| If (IOST & Local0) |
| { |
| Return (0x0F) |
| } |
| |
| Return (0x00) |
| } |
| |
| Name (CRS1, ResourceTemplate () |
| { |
| IRQNoFlags () |
| {12} |
| }) |
| Name (CRS2, ResourceTemplate () |
| { |
| IO (Decode16, |
| 0x0060, // Range Minimum |
| 0x0060, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IO (Decode16, |
| 0x0064, // Range Minimum |
| 0x0064, // Range Maximum |
| 0x00, // Alignment |
| 0x01, // Length |
| ) |
| IRQNoFlags () |
| {12} |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (0x01 << 0x0A) |
| If (IOST & Local0) |
| { |
| Return (CRS1) /* \_SB_.PCI0.SBRG.PS2M.CRS1 */ |
| } |
| Else |
| { |
| Return (CRS2) /* \_SB_.PCI0.SBRG.PS2M.CRS2 */ |
| } |
| } |
| } |
| |
| Method (PS2M._PSW, 1, NotSerialized) // _PSW: Power State Wake |
| { |
| If (!((OSFL () == 0x01) || (OSFL () == 0x02))) |
| { |
| MSFG = Arg0 |
| } |
| } |
| |
| Method (PS2M._PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x1D, 0x04)) |
| } |
| |
| Device (OMSC) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Name (_UID, 0x00) // _UID: Unique ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y0E) |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y0F) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| If (APIC) |
| { |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._LEN, ML01) // _LEN: Length |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0E._BAS, MB01) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._LEN, ML02) // _LEN: Length |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.OMSC._Y0F._BAS, MB02) // _BAS: Base Address |
| MB01 = 0xFEC00000 |
| ML01 = 0x1000 |
| MB02 = 0xFEE00000 |
| ML02 = 0x1000 |
| } |
| |
| Return (CRS) /* \_SB_.PCI0.SBRG.OMSC.CRS_ */ |
| } |
| } |
| |
| Device (\_SB.RMEM) |
| { |
| Name (_HID, EisaId ("PNP0C01") /* System Board */) // _HID: Hardware ID |
| Name (_UID, 0x01) // _UID: Unique ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadWrite, |
| 0x00000000, // Address Base |
| 0x000A0000, // Address Length |
| ) |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y10) |
| Memory32Fixed (ReadOnly, |
| 0x000E0000, // Address Base |
| 0x00020000, // Address Length |
| _Y11) |
| Memory32Fixed (ReadWrite, |
| 0x00100000, // Address Base |
| 0x00000000, // Address Length |
| _Y12) |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y13) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| CreateDWordField (CRS, \_SB.RMEM._Y10._BAS, BAS1) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.RMEM._Y10._LEN, LEN1) // _LEN: Length |
| CreateDWordField (CRS, \_SB.RMEM._Y11._BAS, BAS2) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.RMEM._Y11._LEN, LEN2) // _LEN: Length |
| CreateDWordField (CRS, \_SB.RMEM._Y12._LEN, LEN3) // _LEN: Length |
| CreateDWordField (CRS, \_SB.RMEM._Y13._BAS, BAS4) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.RMEM._Y13._LEN, LEN4) // _LEN: Length |
| If (!OSFL ()) |
| { |
| If (MG1B) |
| { |
| If (MG1B > 0x000C0000) |
| { |
| BAS1 = 0x000C0000 |
| LEN1 = (MG1B - BAS1) /* \_SB_.RMEM._CRS.BAS1 */ |
| } |
| Else |
| { |
| BAS1 = MG1B /* \MG1B */ |
| LEN1 = MG1L /* \MG1L */ |
| } |
| |
| BAS2 = (MG1B + MG1L) /* \MG1L */ |
| LEN2 = (0x00100000 - BAS2) /* \_SB_.RMEM._CRS.BAS2 */ |
| } |
| } |
| |
| LEN3 = (MG2B - 0x00100000) |
| BAS4 = (MG2B + MG2L) /* \MG2L */ |
| LEN4 = (0x00 - BAS4) /* \_SB_.RMEM._CRS.BAS4 */ |
| Return (CRS) /* \_SB_.RMEM.CRS_ */ |
| } |
| } |
| |
| Device (UAR1) |
| { |
| Name (_UID, 0x01) // _UID: Unique ID |
| Name (_HID, EisaId ("PNP0501") /* 16550A-compatible COM Serial Port */) // _HID: Hardware ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Return (DSTA (0x00)) |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| DCNT (0x00, 0x00) |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Return (DCRS (0x00, 0x00)) |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| DSRS (Arg0, 0x00) |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (CMPR) /* \_SB_.PCI0.SBRG.UAR1.CMPR */ |
| } |
| |
| Name (CMPR, ResourceTemplate () |
| { |
| StartDependentFn (0x00, 0x00) |
| { |
| IO (Decode16, |
| 0x03F8, // Range Minimum |
| 0x03F8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {4} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x03F8, // Range Minimum |
| 0x03F8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x02F8, // Range Minimum |
| 0x02F8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x03E8, // Range Minimum |
| 0x03E8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {} |
| } |
| StartDependentFnNoPri () |
| { |
| IO (Decode16, |
| 0x02E8, // Range Minimum |
| 0x02E8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| IRQNoFlags () |
| {3,4,5,6,7,10,11,12} |
| DMA (Compatibility, NotBusMaster, Transfer8, ) |
| {} |
| } |
| EndDependentFn () |
| }) |
| } |
| |
| Method (UAR1._PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x08, 0x04)) |
| } |
| |
| Device (FWH) |
| { |
| Name (_HID, EisaId ("INT0800") /* Intel 82802 Firmware Hub Device */) // _HID: Hardware ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y14) |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y15) |
| }) |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._BAS, BS00) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y14._LEN, BL00) // _LEN: Length |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y15._BAS, BS10) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWH._Y15._LEN, BL10) // _LEN: Length |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = 0xFF800000 |
| FindSetRightBit (FHD0, Local1) |
| Local1-- |
| If (Local1) |
| { |
| Local1 *= 0x00080000 |
| } |
| |
| Local2 = (Local0 + Local1) |
| BS00 = Local2 |
| BS10 = (BS00 + 0x00400000) |
| BL00 = (0x00 - BS10) /* \_SB_.PCI0.SBRG.FWH_.BS10 */ |
| BL10 = BL00 /* \_SB_.PCI0.SBRG.FWH_.BL00 */ |
| Return (CRS) /* \_SB_.PCI0.SBRG.FWH_.CRS_ */ |
| } |
| } |
| |
| Device (FWHE) |
| { |
| Name (_HID, EisaId ("PNP0C02") /* PNP Motherboard Resources */) // _HID: Hardware ID |
| Name (_UID, 0x03) // _UID: Unique ID |
| Name (CRS, ResourceTemplate () |
| { |
| Memory32Fixed (ReadOnly, |
| 0x00000000, // Address Base |
| 0x00000000, // Address Length |
| _Y16) |
| }) |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y16._BAS, BS00) // _BAS: Base Address |
| CreateDWordField (CRS, \_SB.PCI0.SBRG.FWHE._Y16._LEN, BL00) // _LEN: Length |
| If (^^FWH.BS00 == 0x00) |
| { |
| ^^FWH._CRS () |
| } |
| |
| BS00 = (^^FWH.BS00 + ^^FWH.BL00) /* \_SB_.PCI0.SBRG.FWH_.BL00 */ |
| BL00 = (^^FWH.BS10 - BS00) /* \_SB_.PCI0.SBRG.FWHE._CRS.BS00 */ |
| Return (CRS) /* \_SB_.PCI0.SBRG.FWHE.CRS_ */ |
| } |
| } |
| |
| OperationRegion (FHR0, PCI_Config, FHDC, 0x01) |
| Field (FHR0, ByteAcc, NoLock, Preserve) |
| { |
| FHD0, 8 |
| } |
| } |
| |
| Device (USB2) |
| { |
| Name (_ADR, 0x001D0001) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x04, 0x04)) |
| } |
| } |
| |
| Device (USB3) |
| { |
| Name (_ADR, 0x001D0002) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x0C, 0x04)) |
| } |
| } |
| |
| Device (USB4) |
| { |
| Name (_ADR, 0x001D0003) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x0E, 0x04)) |
| } |
| } |
| |
| Device (MC97) |
| { |
| Name (_ADR, 0x001E0003) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x05, 0x04)) |
| } |
| } |
| |
| Device (USB1) |
| { |
| Name (_ADR, 0x001D0000) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x03, 0x04)) |
| } |
| } |
| |
| Device (EUSB) |
| { |
| Name (_ADR, 0x001D0007) // _ADR: Address |
| Method (_PRW, 0, NotSerialized) // _PRW: Power Resources for Wake |
| { |
| Return (GPRW (0x0D, 0x04)) |
| } |
| } |
| |
| Device (IDE0) |
| { |
| Name (_ADR, 0x001F0001) // _ADR: Address |
| Name (\_SB.PCI0.NATA, Package (0x01) |
| { |
| 0x001F0001 |
| }) |
| Name (REGF, 0x01) |
| Method (_REG, 2, NotSerialized) // _REG: Region Availability |
| { |
| If (Arg0 == 0x02) |
| { |
| REGF = Arg1 |
| } |
| } |
| |
| Name (TIM0, Package (0x08) |
| { |
| Package (0x04) |
| { |
| 0x78, |
| 0xB4, |
| 0xF0, |
| 0x0384 |
| }, |
| |
| Package (0x04) |
| { |
| 0x23, |
| 0x21, |
| 0x10, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0B, |
| 0x09, |
| 0x04, |
| 0x00 |
| }, |
| |
| Package (0x06) |
| { |
| 0x70, |
| 0x49, |
| 0x36, |
| 0x27, |
| 0x19, |
| 0x14 |
| }, |
| |
| Package (0x06) |
| { |
| 0x00, |
| 0x01, |
| 0x02, |
| 0x01, |
| 0x02, |
| 0x01 |
| }, |
| |
| Package (0x06) |
| { |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x01, |
| 0x01, |
| 0x01 |
| }, |
| |
| Package (0x04) |
| { |
| 0x04, |
| 0x03, |
| 0x02, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x02, |
| 0x01, |
| 0x00, |
| 0x00 |
| } |
| }) |
| Name (TMD0, Buffer (0x14) {}) |
| CreateDWordField (TMD0, 0x00, PIO0) |
| CreateDWordField (TMD0, 0x04, DMA0) |
| CreateDWordField (TMD0, 0x08, PIO1) |
| CreateDWordField (TMD0, 0x0C, DMA1) |
| CreateDWordField (TMD0, 0x10, CHNF) |
| OperationRegion (CFG2, PCI_Config, 0x40, 0x20) |
| Field (CFG2, DWordAcc, NoLock, Preserve) |
| { |
| PMPT, 4, |
| PSPT, 4, |
| PMRI, 6, |
| Offset (0x02), |
| SMPT, 4, |
| SSPT, 4, |
| SMRI, 6, |
| Offset (0x04), |
| PSRI, 4, |
| SSRI, 4, |
| Offset (0x08), |
| PM3E, 1, |
| PS3E, 1, |
| SM3E, 1, |
| SS3E, 1, |
| Offset (0x0A), |
| PMUT, 2, |
| , 2, |
| PSUT, 2, |
| Offset (0x0B), |
| SMUT, 2, |
| , 2, |
| SSUT, 2, |
| Offset (0x0C), |
| Offset (0x14), |
| PM6E, 1, |
| PS6E, 1, |
| SM6E, 1, |
| SS6E, 1, |
| PMCR, 1, |
| PSCR, 1, |
| SMCR, 1, |
| SSCR, 1, |
| , 4, |
| PMAE, 1, |
| PSAE, 1, |
| SMAE, 1, |
| SSAE, 1 |
| } |
| |
| Name (GMPT, 0x00) |
| Name (GMUE, 0x00) |
| Name (GMUT, 0x00) |
| Name (GMCR, 0x00) |
| Name (GSPT, 0x00) |
| Name (GSUE, 0x00) |
| Name (GSUT, 0x00) |
| Name (GSCR, 0x00) |
| Device (CHN0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
| { |
| Local1 = (PSCR << 0x01) |
| Local0 = (PMCR | Local1) |
| Local3 = (PMAE << 0x02) |
| Local4 = (PM6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (PM3E | Local3) |
| Local3 = (PMPT << 0x04) |
| Local1 |= Local3 |
| Local3 = (PSAE << 0x02) |
| Local4 = (PS6E << 0x01) |
| Local3 |= Local4 |
| Local2 = (PS3E | Local3) |
| Local3 = (PSPT << 0x04) |
| Local2 |= Local3 |
| Return (GTM (PMRI, Local1, PMUT, PSRI, Local2, PSUT, Local0)) |
| } |
| |
| Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
| { |
| Debug = Arg0 |
| TMD0 = Arg0 |
| Local3 = (PMAE << 0x02) |
| Local4 = (PM6E << 0x01) |
| Local3 |= Local4 |
| Local0 = (PM3E | Local3) |
| Local3 = (PMPT << 0x04) |
| Local0 |= Local3 |
| Local3 = (PSAE << 0x02) |
| Local4 = (PS6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (PS3E | Local3) |
| Local3 = (PSPT << 0x04) |
| Local1 |= Local3 |
| GMPT = PMRI /* \_SB_.PCI0.IDE0.PMRI */ |
| GMUE = Local0 |
| GMUT = PMUT /* \_SB_.PCI0.IDE0.PMUT */ |
| GMCR = PMCR /* \_SB_.PCI0.IDE0.PMCR */ |
| GSPT = PSRI /* \_SB_.PCI0.IDE0.PSRI */ |
| GSUE = Local1 |
| GSUT = PSUT /* \_SB_.PCI0.IDE0.PSUT */ |
| GSCR = PSCR /* \_SB_.PCI0.IDE0.PSCR */ |
| STM () |
| PMRI = GMPT /* \_SB_.PCI0.IDE0.GMPT */ |
| Local0 = GMUE /* \_SB_.PCI0.IDE0.GMUE */ |
| PMUT = GMUT /* \_SB_.PCI0.IDE0.GMUT */ |
| PMCR = GMCR /* \_SB_.PCI0.IDE0.GMCR */ |
| Local1 = GSUE /* \_SB_.PCI0.IDE0.GSUE */ |
| PSUT = GSUT /* \_SB_.PCI0.IDE0.GSUT */ |
| PSCR = GSCR /* \_SB_.PCI0.IDE0.GSCR */ |
| If (Local0 & 0x01) |
| { |
| PM3E = 0x01 |
| } |
| Else |
| { |
| PM3E = 0x00 |
| } |
| |
| If (Local0 & 0x02) |
| { |
| PM6E = 0x01 |
| } |
| Else |
| { |
| PM6E = 0x00 |
| } |
| |
| If (Local0 & 0x04) |
| { |
| PMAE = 0x01 |
| } |
| Else |
| { |
| PMAE = 0x00 |
| } |
| |
| If (Local1 & 0x01) |
| { |
| PS3E = 0x01 |
| } |
| Else |
| { |
| PS3E = 0x00 |
| } |
| |
| If (Local1 & 0x02) |
| { |
| PS6E = 0x01 |
| } |
| Else |
| { |
| PS6E = 0x00 |
| } |
| |
| If (Local1 & 0x04) |
| { |
| PSAE = 0x01 |
| } |
| Else |
| { |
| PSAE = 0x00 |
| } |
| |
| ATA0 = GTF (0x00, Arg1) |
| ATA1 = GTF (0x01, Arg2) |
| } |
| |
| Device (DRV0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA0), FZTF)) |
| } |
| } |
| |
| Device (DRV1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA1), FZTF)) |
| } |
| } |
| } |
| |
| Device (CHN1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
| { |
| Local1 = (SSCR << 0x01) |
| Local0 = (SMCR | Local1) |
| Local3 = (SMAE << 0x02) |
| Local4 = (SM6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (SM3E | Local3) |
| Local3 = (SMPT << 0x04) |
| Local1 |= Local3 |
| Local3 = (SSAE << 0x02) |
| Local4 = (SS6E << 0x01) |
| Local3 |= Local4 |
| Local2 = (SS3E | Local3) |
| Local3 = (SSPT << 0x04) |
| Local2 |= Local3 |
| Return (GTM (SMRI, Local1, SMUT, SSRI, Local2, SSUT, Local0)) |
| } |
| |
| Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
| { |
| Debug = Arg0 |
| TMD0 = Arg0 |
| Local3 = (SMAE << 0x02) |
| Local4 = (SM6E << 0x01) |
| Local3 |= Local4 |
| Local0 = (SM3E | Local3) |
| Local3 = (SMPT << 0x04) |
| Local0 |= Local3 |
| Local3 = (SSAE << 0x02) |
| Local4 = (SS6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (SS3E | Local3) |
| Local3 = (SSPT << 0x04) |
| Local1 |= Local3 |
| GMPT = SMRI /* \_SB_.PCI0.IDE0.SMRI */ |
| GMUE = Local0 |
| GMUT = SMUT /* \_SB_.PCI0.IDE0.SMUT */ |
| GMCR = SMCR /* \_SB_.PCI0.IDE0.SMCR */ |
| GSPT = SSRI /* \_SB_.PCI0.IDE0.SSRI */ |
| GSUE = Local1 |
| GSUT = SSUT /* \_SB_.PCI0.IDE0.SSUT */ |
| GSCR = SSCR /* \_SB_.PCI0.IDE0.SSCR */ |
| STM () |
| SMRI = GMPT /* \_SB_.PCI0.IDE0.GMPT */ |
| Local0 = GMUE /* \_SB_.PCI0.IDE0.GMUE */ |
| SMUT = GMUT /* \_SB_.PCI0.IDE0.GMUT */ |
| SMCR = GMCR /* \_SB_.PCI0.IDE0.GMCR */ |
| Local1 = GSUE /* \_SB_.PCI0.IDE0.GSUE */ |
| SSUT = GSUT /* \_SB_.PCI0.IDE0.GSUT */ |
| SSCR = GSCR /* \_SB_.PCI0.IDE0.GSCR */ |
| If (Local0 & 0x01) |
| { |
| SM3E = 0x01 |
| } |
| Else |
| { |
| SM3E = 0x00 |
| } |
| |
| If (Local0 & 0x02) |
| { |
| SM6E = 0x01 |
| } |
| Else |
| { |
| SM6E = 0x00 |
| } |
| |
| If (Local0 & 0x04) |
| { |
| SMAE = 0x01 |
| } |
| Else |
| { |
| SMAE = 0x00 |
| } |
| |
| If (Local1 & 0x01) |
| { |
| SS3E = 0x01 |
| } |
| Else |
| { |
| SS3E = 0x00 |
| } |
| |
| If (Local1 & 0x02) |
| { |
| SS6E = 0x01 |
| } |
| Else |
| { |
| SS6E = 0x00 |
| } |
| |
| If (Local1 & 0x04) |
| { |
| SSAE = 0x01 |
| } |
| Else |
| { |
| SSAE = 0x00 |
| } |
| |
| ATA2 = GTF (0x00, Arg1) |
| ATA3 = GTF (0x01, Arg2) |
| } |
| |
| Device (DRV0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA2), FZTF)) |
| } |
| } |
| |
| Device (DRV1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA3), FZTF)) |
| } |
| } |
| } |
| |
| Method (GTM, 7, Serialized) |
| { |
| PIO0 = Ones |
| PIO1 = Ones |
| DMA0 = Ones |
| DMA1 = Ones |
| CHNF = 0x10 |
| If (REGF) {} |
| Else |
| { |
| Return (TMD0) /* \_SB_.PCI0.IDE0.TMD0 */ |
| } |
| |
| If (Arg1 & 0x20) |
| { |
| CHNF |= 0x02 |
| } |
| |
| Local6 = Match (DerefOf (TIM0 [0x01]), MEQ, Arg0, MTR, 0x00, |
| 0x00) |
| Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6]) |
| DMA0 = Local7 |
| PIO0 = Local7 |
| If (Arg4 & 0x20) |
| { |
| CHNF |= 0x08 |
| } |
| |
| Local6 = Match (DerefOf (TIM0 [0x02]), MEQ, Arg3, MTR, 0x00, |
| 0x00) |
| Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6]) |
| DMA1 = Local7 |
| PIO1 = Local7 |
| If (Arg1 & 0x07) |
| { |
| Local5 = Arg2 |
| If (Arg1 & 0x02) |
| { |
| Local5 += 0x02 |
| } |
| |
| If (Arg1 & 0x04) |
| { |
| Local5 += 0x04 |
| } |
| |
| DMA0 = DerefOf (DerefOf (TIM0 [0x03]) [Local5]) |
| CHNF |= 0x01 |
| } |
| |
| If (Arg4 & 0x07) |
| { |
| Local5 = Arg5 |
| If (Arg4 & 0x02) |
| { |
| Local5 += 0x02 |
| } |
| |
| If (Arg4 & 0x04) |
| { |
| Local5 += 0x04 |
| } |
| |
| DMA1 = DerefOf (DerefOf (TIM0 [0x03]) [Local5]) |
| CHNF |= 0x04 |
| } |
| |
| Debug = TMD0 /* \_SB_.PCI0.IDE0.TMD0 */ |
| Return (TMD0) /* \_SB_.PCI0.IDE0.TMD0 */ |
| } |
| |
| Method (STM, 0, Serialized) |
| { |
| If (REGF) {} |
| Else |
| { |
| GMUE = 0x00 |
| GMUT = 0x00 |
| GSUE = 0x00 |
| GSUT = 0x00 |
| If (CHNF & 0x01) |
| { |
| Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA0, MTR, 0x00, |
| 0x00) |
| If (Local0 > 0x05) |
| { |
| Local0 = 0x05 |
| } |
| |
| GMUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0]) |
| GMUE |= 0x01 |
| If (Local0 > 0x02) |
| { |
| GMUE |= 0x02 |
| } |
| |
| If (Local0 > 0x04) |
| { |
| GMUE &= 0xFD |
| GMUE |= 0x04 |
| } |
| } |
| ElseIf ((PIO0 == Ones) | (PIO0 == 0x00)) |
| { |
| If ((DMA0 < Ones) & (DMA0 > 0x00)) |
| { |
| PIO0 = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */ |
| GMUE |= 0x80 |
| } |
| } |
| |
| If (CHNF & 0x04) |
| { |
| Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA1, MTR, 0x00, |
| 0x00) |
| If (Local0 > 0x05) |
| { |
| Local0 = 0x05 |
| } |
| |
| GSUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0]) |
| GSUE |= 0x01 |
| If (Local0 > 0x02) |
| { |
| GSUE |= 0x02 |
| } |
| |
| If (Local0 > 0x04) |
| { |
| GSUE &= 0xFD |
| GSUE |= 0x04 |
| } |
| } |
| ElseIf ((PIO1 == Ones) | (PIO1 == 0x00)) |
| { |
| If ((DMA1 < Ones) & (DMA1 > 0x00)) |
| { |
| PIO1 = DMA1 /* \_SB_.PCI0.IDE0.DMA1 */ |
| GSUE |= 0x80 |
| } |
| } |
| |
| If (CHNF & 0x02) |
| { |
| GMUE |= 0x20 |
| } |
| |
| If (CHNF & 0x08) |
| { |
| GSUE |= 0x20 |
| } |
| |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0]) |
| GMPT = Local1 |
| If (Local0 < 0x03) |
| { |
| GMUE |= 0x50 |
| } |
| |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO1, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = DerefOf (DerefOf (TIM0 [0x02]) [Local0]) |
| GSPT = Local1 |
| If (Local0 < 0x03) |
| { |
| GSUE |= 0x50 |
| } |
| } |
| } |
| |
| Name (AT01, Buffer (0x07) |
| { |
| 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF /* ....... */ |
| }) |
| Name (AT02, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90 /* ....... */ |
| }) |
| Name (AT03, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6 /* ....... */ |
| }) |
| Name (AT04, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91 /* ....... */ |
| }) |
| Name (ATA0, Buffer (0x1D) {}) |
| Name (ATA1, Buffer (0x1D) {}) |
| Name (ATA2, Buffer (0x1D) {}) |
| Name (ATA3, Buffer (0x1D) {}) |
| Name (ATAB, Buffer (0x1D) {}) |
| CreateByteField (ATAB, 0x00, CMDC) |
| Method (GTFB, 3, Serialized) |
| { |
| Local0 = (CMDC * 0x38) |
| Local1 = (Local0 + 0x08) |
| CreateField (ATAB, Local1, 0x38, CMDX) |
| Local0 = (CMDC * 0x07) |
| CreateByteField (ATAB, (Local0 + 0x02), A001) |
| CreateByteField (ATAB, (Local0 + 0x06), A005) |
| CMDX = Arg0 |
| A001 = Arg1 |
| A005 = Arg2 |
| CMDC++ |
| } |
| |
| Method (GTF, 2, Serialized) |
| { |
| Debug = Arg1 |
| CMDC = 0x00 |
| Name (ID49, 0x0C00) |
| Name (ID59, 0x00) |
| Name (ID53, 0x04) |
| Name (ID63, 0x0F00) |
| Name (ID88, 0x0F00) |
| Name (IRDY, 0x01) |
| Name (PIOT, 0x00) |
| Name (DMAT, 0x00) |
| If (SizeOf (Arg1) == 0x0200) |
| { |
| CreateWordField (Arg1, 0x62, IW49) |
| ID49 = IW49 /* \_SB_.PCI0.IDE0.GTF_.IW49 */ |
| CreateWordField (Arg1, 0x6A, IW53) |
| ID53 = IW53 /* \_SB_.PCI0.IDE0.GTF_.IW53 */ |
| CreateWordField (Arg1, 0x7E, IW63) |
| ID63 = IW63 /* \_SB_.PCI0.IDE0.GTF_.IW63 */ |
| CreateWordField (Arg1, 0x76, IW59) |
| ID59 = IW59 /* \_SB_.PCI0.IDE0.GTF_.IW59 */ |
| CreateWordField (Arg1, 0xB0, IW88) |
| ID88 = IW88 /* \_SB_.PCI0.IDE0.GTF_.IW88 */ |
| } |
| |
| Local7 = 0xA0 |
| If (Arg0) |
| { |
| Local7 = 0xB0 |
| IRDY = (CHNF & 0x08) |
| If (CHNF & 0x10) |
| { |
| PIOT = PIO1 /* \_SB_.PCI0.IDE0.PIO1 */ |
| } |
| Else |
| { |
| PIOT = PIO0 /* \_SB_.PCI0.IDE0.PIO0 */ |
| } |
| |
| If (CHNF & 0x04) |
| { |
| If (CHNF & 0x10) |
| { |
| DMAT = DMA1 /* \_SB_.PCI0.IDE0.DMA1 */ |
| } |
| Else |
| { |
| DMAT = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */ |
| } |
| } |
| } |
| Else |
| { |
| IRDY = (CHNF & 0x02) |
| PIOT = PIO0 /* \_SB_.PCI0.IDE0.PIO0 */ |
| If (CHNF & 0x01) |
| { |
| DMAT = DMA0 /* \_SB_.PCI0.IDE0.DMA0 */ |
| } |
| } |
| |
| If (((ID53 & 0x04) && (ID88 & 0xFF00)) && DMAT) |
| { |
| Local1 = Match (DerefOf (TIM0 [0x03]), MLE, DMAT, MTR, 0x00, |
| 0x00) |
| If (Local1 > 0x05) |
| { |
| Local1 = 0x05 |
| } |
| |
| GTFB (AT01, (0x40 | Local1), Local7) |
| } |
| ElseIf ((ID63 & 0xFF00) && PIOT) |
| { |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, |
| 0x00) & 0x03) |
| Local1 = (0x20 | DerefOf (DerefOf (TIM0 [0x07]) [Local0])) |
| GTFB (AT01, Local1, Local7) |
| } |
| |
| If (IRDY) |
| { |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = (0x08 | DerefOf (DerefOf (TIM0 [0x06]) [Local0])) |
| GTFB (AT01, Local1, Local7) |
| } |
| ElseIf (ID49 & 0x0400) |
| { |
| GTFB (AT01, 0x01, Local7) |
| } |
| |
| If ((ID59 & 0x0100) && (ID59 & 0xFF)) |
| { |
| GTFB (AT03, (ID59 & 0xFF), Local7) |
| } |
| |
| Debug = ATAB /* \_SB_.PCI0.IDE0.ATAB */ |
| Return (ATAB) /* \_SB_.PCI0.IDE0.ATAB */ |
| } |
| |
| Method (RATA, 1, NotSerialized) |
| { |
| CreateByteField (Arg0, 0x00, CMDN) |
| Local0 = (CMDN * 0x38) |
| CreateField (Arg0, 0x08, Local0, RETB) |
| Debug = RETB /* \_SB_.PCI0.IDE0.RATA.RETB */ |
| Return (RETB) /* \_SB_.PCI0.IDE0.RATA.RETB */ |
| } |
| } |
| |
| Device (IDE1) |
| { |
| Name (_ADR, 0x001F0002) // _ADR: Address |
| Name (\FZTF, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF5 /* ....... */ |
| }) |
| Name (REGF, 0x01) |
| Method (_REG, 2, NotSerialized) // _REG: Region Availability |
| { |
| If (Arg0 == 0x02) |
| { |
| REGF = Arg1 |
| } |
| } |
| |
| Name (TIM0, Package (0x08) |
| { |
| Package (0x04) |
| { |
| 0x78, |
| 0xB4, |
| 0xF0, |
| 0x0384 |
| }, |
| |
| Package (0x04) |
| { |
| 0x23, |
| 0x21, |
| 0x10, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x0B, |
| 0x09, |
| 0x04, |
| 0x00 |
| }, |
| |
| Package (0x06) |
| { |
| 0x78, |
| 0x5A, |
| 0x3C, |
| 0x28, |
| 0x1E, |
| 0x14 |
| }, |
| |
| Package (0x06) |
| { |
| 0x00, |
| 0x01, |
| 0x02, |
| 0x01, |
| 0x02, |
| 0x01 |
| }, |
| |
| Package (0x06) |
| { |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x01, |
| 0x01, |
| 0x01 |
| }, |
| |
| Package (0x04) |
| { |
| 0x04, |
| 0x03, |
| 0x02, |
| 0x00 |
| }, |
| |
| Package (0x04) |
| { |
| 0x02, |
| 0x01, |
| 0x00, |
| 0x00 |
| } |
| }) |
| Name (TMD0, Buffer (0x14) {}) |
| CreateDWordField (TMD0, 0x00, PIO0) |
| CreateDWordField (TMD0, 0x04, DMA0) |
| CreateDWordField (TMD0, 0x08, PIO1) |
| CreateDWordField (TMD0, 0x0C, DMA1) |
| CreateDWordField (TMD0, 0x10, CHNF) |
| OperationRegion (CFG2, PCI_Config, 0x40, 0x20) |
| Field (CFG2, DWordAcc, NoLock, Preserve) |
| { |
| PMPT, 4, |
| PSPT, 4, |
| PMRI, 6, |
| Offset (0x02), |
| SMPT, 4, |
| SSPT, 4, |
| SMRI, 6, |
| Offset (0x04), |
| PSRI, 4, |
| SSRI, 4, |
| Offset (0x08), |
| PM3E, 1, |
| PS3E, 1, |
| SM3E, 1, |
| SS3E, 1, |
| Offset (0x0A), |
| PMUT, 2, |
| , 2, |
| PSUT, 2, |
| Offset (0x0B), |
| SMUT, 2, |
| , 2, |
| SSUT, 2, |
| Offset (0x0C), |
| Offset (0x14), |
| PM6E, 1, |
| PS6E, 1, |
| SM6E, 1, |
| SS6E, 1, |
| PMCR, 1, |
| PSCR, 1, |
| SMCR, 1, |
| SSCR, 1, |
| , 4, |
| PMAE, 1, |
| PSAE, 1, |
| SMAE, 1, |
| SSAE, 1 |
| } |
| |
| Name (GMPT, 0x00) |
| Name (GMUE, 0x00) |
| Name (GMUT, 0x00) |
| Name (GMCR, 0x00) |
| Name (GSPT, 0x00) |
| Name (GSUE, 0x00) |
| Name (GSUT, 0x00) |
| Name (GSCR, 0x00) |
| Device (CHN0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
| { |
| Local1 = (PSCR << 0x01) |
| Local0 = (PMCR | Local1) |
| Local3 = (PMAE << 0x02) |
| Local4 = (PM6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (PM3E | Local3) |
| Local3 = (PMPT << 0x04) |
| Local1 |= Local3 |
| Local3 = (PSAE << 0x02) |
| Local4 = (PS6E << 0x01) |
| Local3 |= Local4 |
| Local2 = (PS3E | Local3) |
| Local3 = (PSPT << 0x04) |
| Local2 |= Local3 |
| Return (GTM (PMRI, Local1, PMUT, PSRI, Local2, PSUT, Local0)) |
| } |
| |
| Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
| { |
| Debug = Arg0 |
| TMD0 = Arg0 |
| Local3 = (PMAE << 0x02) |
| Local4 = (PM6E << 0x01) |
| Local3 |= Local4 |
| Local0 = (PM3E | Local3) |
| Local3 = (PMPT << 0x04) |
| Local0 |= Local3 |
| Local3 = (PSAE << 0x02) |
| Local4 = (PS6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (PS3E | Local3) |
| Local3 = (PSPT << 0x04) |
| Local1 |= Local3 |
| GMPT = PMRI /* \_SB_.PCI0.IDE1.PMRI */ |
| GMUE = Local0 |
| GMUT = PMUT /* \_SB_.PCI0.IDE1.PMUT */ |
| GMCR = PMCR /* \_SB_.PCI0.IDE1.PMCR */ |
| GSPT = PSRI /* \_SB_.PCI0.IDE1.PSRI */ |
| GSUE = Local1 |
| GSUT = PSUT /* \_SB_.PCI0.IDE1.PSUT */ |
| GSCR = PSCR /* \_SB_.PCI0.IDE1.PSCR */ |
| STM () |
| PMRI = GMPT /* \_SB_.PCI0.IDE1.GMPT */ |
| Local0 = GMUE /* \_SB_.PCI0.IDE1.GMUE */ |
| PMUT = GMUT /* \_SB_.PCI0.IDE1.GMUT */ |
| PMCR = GMCR /* \_SB_.PCI0.IDE1.GMCR */ |
| Local1 = GSUE /* \_SB_.PCI0.IDE1.GSUE */ |
| PSUT = GSUT /* \_SB_.PCI0.IDE1.GSUT */ |
| PSCR = GSCR /* \_SB_.PCI0.IDE1.GSCR */ |
| If (Local0 & 0x01) |
| { |
| PM3E = 0x01 |
| } |
| Else |
| { |
| PM3E = 0x00 |
| } |
| |
| If (Local0 & 0x02) |
| { |
| PM6E = 0x01 |
| } |
| Else |
| { |
| PM6E = 0x00 |
| } |
| |
| If (Local0 & 0x04) |
| { |
| PMAE = 0x01 |
| } |
| Else |
| { |
| PMAE = 0x00 |
| } |
| |
| If (Local1 & 0x01) |
| { |
| PS3E = 0x01 |
| } |
| Else |
| { |
| PS3E = 0x00 |
| } |
| |
| If (Local1 & 0x02) |
| { |
| PS6E = 0x01 |
| } |
| Else |
| { |
| PS6E = 0x00 |
| } |
| |
| If (Local1 & 0x04) |
| { |
| PSAE = 0x01 |
| } |
| Else |
| { |
| PSAE = 0x00 |
| } |
| |
| ATA0 = GTF (0x00, Arg1) |
| ATA1 = GTF (0x01, Arg2) |
| } |
| |
| Device (DRV0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA0), FZTF)) |
| } |
| } |
| |
| Device (DRV1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA1), FZTF)) |
| } |
| } |
| } |
| |
| Device (CHN1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTM, 0, NotSerialized) // _GTM: Get Timing Mode |
| { |
| Local1 = (SSCR << 0x01) |
| Local0 = (SMCR | Local1) |
| Local3 = (SMAE << 0x02) |
| Local4 = (SM6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (SM3E | Local3) |
| Local3 = (SMPT << 0x04) |
| Local1 |= Local3 |
| Local3 = (SSAE << 0x02) |
| Local4 = (SS6E << 0x01) |
| Local3 |= Local4 |
| Local2 = (SS3E | Local3) |
| Local3 = (SSPT << 0x04) |
| Local2 |= Local3 |
| Return (GTM (SMRI, Local1, SMUT, SSRI, Local2, SSUT, Local0)) |
| } |
| |
| Method (_STM, 3, NotSerialized) // _STM: Set Timing Mode |
| { |
| Debug = Arg0 |
| TMD0 = Arg0 |
| Local3 = (SMAE << 0x02) |
| Local4 = (SM6E << 0x01) |
| Local3 |= Local4 |
| Local0 = (SM3E | Local3) |
| Local3 = (SMPT << 0x04) |
| Local0 |= Local3 |
| Local3 = (SSAE << 0x02) |
| Local4 = (SS6E << 0x01) |
| Local3 |= Local4 |
| Local1 = (SS3E | Local3) |
| Local3 = (SSPT << 0x04) |
| Local1 |= Local3 |
| GMPT = SMRI /* \_SB_.PCI0.IDE1.SMRI */ |
| GMUE = Local0 |
| GMUT = SMUT /* \_SB_.PCI0.IDE1.SMUT */ |
| GMCR = SMCR /* \_SB_.PCI0.IDE1.SMCR */ |
| GSPT = SSRI /* \_SB_.PCI0.IDE1.SSRI */ |
| GSUE = Local1 |
| GSUT = SSUT /* \_SB_.PCI0.IDE1.SSUT */ |
| GSCR = SSCR /* \_SB_.PCI0.IDE1.SSCR */ |
| STM () |
| SMRI = GMPT /* \_SB_.PCI0.IDE1.GMPT */ |
| Local0 = GMUE /* \_SB_.PCI0.IDE1.GMUE */ |
| SMUT = GMUT /* \_SB_.PCI0.IDE1.GMUT */ |
| SMCR = GMCR /* \_SB_.PCI0.IDE1.GMCR */ |
| Local1 = GSUE /* \_SB_.PCI0.IDE1.GSUE */ |
| SSUT = GSUT /* \_SB_.PCI0.IDE1.GSUT */ |
| SSCR = GSCR /* \_SB_.PCI0.IDE1.GSCR */ |
| If (Local0 & 0x01) |
| { |
| SM3E = 0x01 |
| } |
| Else |
| { |
| SM3E = 0x00 |
| } |
| |
| If (Local0 & 0x02) |
| { |
| SM6E = 0x01 |
| } |
| Else |
| { |
| SM6E = 0x00 |
| } |
| |
| If (Local0 & 0x04) |
| { |
| SMAE = 0x01 |
| } |
| Else |
| { |
| SMAE = 0x00 |
| } |
| |
| If (Local1 & 0x01) |
| { |
| SS3E = 0x01 |
| } |
| Else |
| { |
| SS3E = 0x00 |
| } |
| |
| If (Local1 & 0x02) |
| { |
| SS6E = 0x01 |
| } |
| Else |
| { |
| SS6E = 0x00 |
| } |
| |
| If (Local1 & 0x04) |
| { |
| SSAE = 0x01 |
| } |
| Else |
| { |
| SSAE = 0x00 |
| } |
| |
| ATA2 = GTF (0x00, Arg1) |
| ATA3 = GTF (0x01, Arg2) |
| } |
| |
| Device (DRV0) |
| { |
| Name (_ADR, 0x00) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA2), FZTF)) |
| } |
| } |
| |
| Device (DRV1) |
| { |
| Name (_ADR, 0x01) // _ADR: Address |
| Method (_GTF, 0, NotSerialized) // _GTF: Get Task File |
| { |
| Return (Concatenate (RATA (ATA3), FZTF)) |
| } |
| } |
| } |
| |
| Method (GTM, 7, Serialized) |
| { |
| PIO0 = Ones |
| PIO1 = Ones |
| DMA0 = Ones |
| DMA1 = Ones |
| CHNF = 0x10 |
| If (REGF) {} |
| Else |
| { |
| Return (TMD0) /* \_SB_.PCI0.IDE1.TMD0 */ |
| } |
| |
| If (Arg1 & 0x20) |
| { |
| CHNF |= 0x02 |
| } |
| |
| Local6 = Match (DerefOf (TIM0 [0x01]), MEQ, Arg0, MTR, 0x00, |
| 0x00) |
| Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6]) |
| DMA0 = Local7 |
| PIO0 = Local7 |
| If (Arg4 & 0x20) |
| { |
| CHNF |= 0x08 |
| } |
| |
| Local6 = Match (DerefOf (TIM0 [0x02]), MEQ, Arg3, MTR, 0x00, |
| 0x00) |
| Local7 = DerefOf (DerefOf (TIM0 [0x00]) [Local6]) |
| DMA1 = Local7 |
| PIO1 = Local7 |
| If (Arg1 & 0x07) |
| { |
| Local5 = Arg2 |
| If (Arg1 & 0x02) |
| { |
| Local5 += 0x02 |
| } |
| |
| If (Arg1 & 0x04) |
| { |
| Local5 += 0x04 |
| } |
| |
| DMA0 = DerefOf (DerefOf (TIM0 [0x03]) [Local5]) |
| CHNF |= 0x01 |
| } |
| |
| If (Arg4 & 0x07) |
| { |
| Local5 = Arg5 |
| If (Arg4 & 0x02) |
| { |
| Local5 += 0x02 |
| } |
| |
| If (Arg4 & 0x04) |
| { |
| Local5 += 0x04 |
| } |
| |
| DMA1 = DerefOf (DerefOf (TIM0 [0x03]) [Local5]) |
| CHNF |= 0x04 |
| } |
| |
| Debug = TMD0 /* \_SB_.PCI0.IDE1.TMD0 */ |
| Return (TMD0) /* \_SB_.PCI0.IDE1.TMD0 */ |
| } |
| |
| Method (STM, 0, Serialized) |
| { |
| If (REGF) |
| { |
| GMUE = 0x00 |
| GMUT = 0x00 |
| GSUE = 0x00 |
| GSUT = 0x00 |
| If (CHNF & 0x01) |
| { |
| Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA0, MTR, 0x00, |
| 0x00) |
| If (Local0 > 0x05) |
| { |
| Local0 = 0x05 |
| } |
| |
| GMUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0]) |
| GMUE |= 0x01 |
| If (Local0 > 0x02) |
| { |
| GMUE |= 0x02 |
| } |
| |
| If (Local0 > 0x04) |
| { |
| GMUE &= 0xFD |
| GMUE |= 0x04 |
| } |
| } |
| ElseIf ((PIO0 == Ones) | (PIO0 == 0x00)) |
| { |
| If ((DMA0 < Ones) & (DMA0 > 0x00)) |
| { |
| PIO0 = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */ |
| GMUE |= 0x80 |
| } |
| } |
| |
| If (CHNF & 0x04) |
| { |
| Local0 = Match (DerefOf (TIM0 [0x03]), MLE, DMA1, MTR, 0x00, |
| 0x00) |
| If (Local0 > 0x05) |
| { |
| Local0 = 0x05 |
| } |
| |
| GSUT = DerefOf (DerefOf (TIM0 [0x04]) [Local0]) |
| GSUE |= 0x01 |
| If (Local0 > 0x02) |
| { |
| GSUE |= 0x02 |
| } |
| |
| If (Local0 > 0x04) |
| { |
| GSUE &= 0xFD |
| GSUE |= 0x04 |
| } |
| } |
| ElseIf ((PIO1 == Ones) | (PIO1 == 0x00)) |
| { |
| If ((DMA1 < Ones) & (DMA1 > 0x00)) |
| { |
| PIO1 = DMA1 /* \_SB_.PCI0.IDE1.DMA1 */ |
| GSUE |= 0x80 |
| } |
| } |
| |
| If (CHNF & 0x02) |
| { |
| GMUE |= 0x20 |
| } |
| |
| If (CHNF & 0x08) |
| { |
| GSUE |= 0x20 |
| } |
| |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO0, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = DerefOf (DerefOf (TIM0 [0x01]) [Local0]) |
| GMPT = Local1 |
| If (Local0 < 0x03) |
| { |
| GMUE |= 0x50 |
| } |
| |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIO1, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = DerefOf (DerefOf (TIM0 [0x02]) [Local0]) |
| GSPT = Local1 |
| If (Local0 < 0x03) |
| { |
| GSUE |= 0x50 |
| } |
| } |
| } |
| |
| Name (AT01, Buffer (0x07) |
| { |
| 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF /* ....... */ |
| }) |
| Name (AT02, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90 /* ....... */ |
| }) |
| Name (AT03, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6 /* ....... */ |
| }) |
| Name (AT04, Buffer (0x07) |
| { |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91 /* ....... */ |
| }) |
| Name (ATA0, Buffer (0x1D) {}) |
| Name (ATA1, Buffer (0x1D) {}) |
| Name (ATA2, Buffer (0x1D) {}) |
| Name (ATA3, Buffer (0x1D) {}) |
| Name (ATAB, Buffer (0x1D) {}) |
| CreateByteField (ATAB, 0x00, CMDC) |
| Method (GTFB, 3, Serialized) |
| { |
| Local0 = (CMDC * 0x38) |
| Local1 = (Local0 + 0x08) |
| CreateField (ATAB, Local1, 0x38, CMDX) |
| Local0 = (CMDC * 0x07) |
| CreateByteField (ATAB, (Local0 + 0x02), A001) |
| CreateByteField (ATAB, (Local0 + 0x06), A005) |
| CMDX = Arg0 |
| A001 = Arg1 |
| A005 = Arg2 |
| CMDC++ |
| } |
| |
| Method (GTF, 2, Serialized) |
| { |
| Debug = Arg1 |
| CMDC = 0x00 |
| Name (ID49, 0x0C00) |
| Name (ID59, 0x00) |
| Name (ID53, 0x04) |
| Name (ID63, 0x0F00) |
| Name (ID88, 0x0F00) |
| Name (IRDY, 0x01) |
| Name (PIOT, 0x00) |
| Name (DMAT, 0x00) |
| If (SizeOf (Arg1) == 0x0200) |
| { |
| CreateWordField (Arg1, 0x62, IW49) |
| ID49 = IW49 /* \_SB_.PCI0.IDE1.GTF_.IW49 */ |
| CreateWordField (Arg1, 0x6A, IW53) |
| ID53 = IW53 /* \_SB_.PCI0.IDE1.GTF_.IW53 */ |
| CreateWordField (Arg1, 0x7E, IW63) |
| ID63 = IW63 /* \_SB_.PCI0.IDE1.GTF_.IW63 */ |
| CreateWordField (Arg1, 0x76, IW59) |
| ID59 = IW59 /* \_SB_.PCI0.IDE1.GTF_.IW59 */ |
| CreateWordField (Arg1, 0xB0, IW88) |
| ID88 = IW88 /* \_SB_.PCI0.IDE1.GTF_.IW88 */ |
| } |
| |
| Local7 = 0xA0 |
| If (Arg0) |
| { |
| Local7 = 0xB0 |
| IRDY = (CHNF & 0x08) |
| If (CHNF & 0x10) |
| { |
| PIOT = PIO1 /* \_SB_.PCI0.IDE1.PIO1 */ |
| } |
| Else |
| { |
| PIOT = PIO0 /* \_SB_.PCI0.IDE1.PIO0 */ |
| } |
| |
| If (CHNF & 0x04) |
| { |
| If (CHNF & 0x10) |
| { |
| DMAT = DMA1 /* \_SB_.PCI0.IDE1.DMA1 */ |
| } |
| Else |
| { |
| DMAT = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */ |
| } |
| } |
| } |
| Else |
| { |
| IRDY = (CHNF & 0x02) |
| PIOT = PIO0 /* \_SB_.PCI0.IDE1.PIO0 */ |
| If (CHNF & 0x01) |
| { |
| DMAT = DMA0 /* \_SB_.PCI0.IDE1.DMA0 */ |
| } |
| } |
| |
| If (((ID53 & 0x04) && (ID88 & 0xFF00)) && DMAT) |
| { |
| Local1 = Match (DerefOf (TIM0 [0x03]), MLE, DMAT, MTR, 0x00, |
| 0x00) |
| If (Local1 > 0x05) |
| { |
| Local1 = 0x05 |
| } |
| |
| GTFB (AT01, (0x40 | Local1), Local7) |
| } |
| ElseIf ((ID63 & 0xFF00) && PIOT) |
| { |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, |
| 0x00) & 0x03) |
| Local1 = (0x20 | DerefOf (DerefOf (TIM0 [0x07]) [Local0])) |
| GTFB (AT01, Local1, Local7) |
| } |
| |
| If (IRDY) |
| { |
| Local0 = (Match (DerefOf (TIM0 [0x00]), MGE, PIOT, MTR, 0x00, |
| 0x00) & 0x07) |
| Local1 = (0x08 | DerefOf (DerefOf (TIM0 [0x06]) [Local0])) |
| GTFB (AT01, Local1, Local7) |
| } |
| ElseIf (ID49 & 0x0400) |
| { |
| GTFB (AT01, 0x01, Local7) |
| } |
| |
| If ((ID59 & 0x0100) && (ID59 & 0xFF)) |
| { |
| GTFB (AT03, (ID59 & 0xFF), Local7) |
| } |
| |
| Debug = ATAB /* \_SB_.PCI0.IDE1.ATAB */ |
| Return (ATAB) /* \_SB_.PCI0.IDE1.ATAB */ |
| } |
| |
| Method (RATA, 1, NotSerialized) |
| { |
| CreateByteField (Arg0, 0x00, CMDN) |
| Local0 = (CMDN * 0x38) |
| CreateField (Arg0, 0x08, Local0, RETB) |
| Debug = RETB /* \_SB_.PCI0.IDE1.RATA.RETB */ |
| Return (RETB) /* \_SB_.PCI0.IDE1.RATA.RETB */ |
| } |
| } |
| } |
| |
| Scope (\_GPE) |
| { |
| Method (_L09, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.P0P1, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P9, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P8, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P7, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P6, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P5, 0x02) // Device Wake |
| Notify (\_SB.PCI0.P0P4, 0x02) // Device Wake |
| } |
| |
| Method (_L0B, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.P0P3, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L1D, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| \_SB.PCI0.SBRG.SIOH () |
| } |
| |
| Method (_L08, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| \_SB.PCI0.SBRG.SIOH () |
| } |
| |
| Method (_L04, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.USB2, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L0C, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.USB3, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L0E, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.USB4, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L05, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.MC97, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L03, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.USB1, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| Method (_L0D, 0, NotSerialized) // _Lxx: Level-Triggered GPE |
| { |
| Notify (\_SB.PCI0.EUSB, 0x02) // Device Wake |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| } |
| |
| Device (PWRB) |
| { |
| Name (_HID, EisaId ("PNP0C0C") /* Power Button Device */) // _HID: Hardware ID |
| Name (_UID, 0xAA) // _UID: Unique ID |
| Name (_STA, 0x0B) // _STA: Status |
| } |
| } |
| |
| OperationRegion (\_SB.PCI0.SBRG.PIX0, PCI_Config, 0x60, 0x0C) |
| Field (\_SB.PCI0.SBRG.PIX0, ByteAcc, NoLock, Preserve) |
| { |
| PIRA, 8, |
| PIRB, 8, |
| PIRC, 8, |
| PIRD, 8, |
| Offset (0x08), |
| PIRE, 8, |
| PIRF, 8, |
| PIRG, 8, |
| PIRH, 8 |
| } |
| |
| Scope (\_SB) |
| { |
| Name (BUFA, ResourceTemplate () |
| { |
| IRQ (Level, ActiveLow, Shared, _Y17) |
| {15} |
| }) |
| CreateWordField (BUFA, \_SB._Y17._INT, IRA0) // _INT: Interrupts |
| Device (LNKA) |
| { |
| Name (_HID, EisaId ("PNP0C0F") /* PCI Interrupt Link Device */) // _HID: Hardware ID |
| Name (_UID, 0x01) // _UID: Unique ID |
| Method (_STA, 0, NotSerialized) // _STA: Status |
| { |
| Local0 = (PIRA & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSA) /* \_SB_.PRSA */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRA |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRA & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRB & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSB) /* \_SB_.PRSB */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRB |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRB & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRC & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSC) /* \_SB_.PRSC */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRC |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRC & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRD & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSD) /* \_SB_.PRSD */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRD |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRD & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRE & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSE) /* \_SB_.PRSE */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRE |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRE & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRF & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSF) /* \_SB_.PRSF */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRF |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRF & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRG & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSG) /* \_SB_.PRSG */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRG |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRG & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, 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 |
| { |
| Local0 = (PIRH & 0x80) |
| If (Local0) |
| { |
| Return (0x09) |
| } |
| Else |
| { |
| Return (0x0B) |
| } |
| } |
| |
| Method (_PRS, 0, NotSerialized) // _PRS: Possible Resource Settings |
| { |
| Return (PRSH) /* \_SB_.PRSH */ |
| } |
| |
| Method (_DIS, 0, NotSerialized) // _DIS: Disable Device |
| { |
| PIRH |= 0x80 |
| } |
| |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| Local0 = (PIRH & 0x0F) |
| IRA0 = (0x01 << Local0) |
| Return (BUFA) /* \_SB_.BUFA */ |
| } |
| |
| Method (_SRS, 1, NotSerialized) // _SRS: Set Resource Settings |
| { |
| CreateWordField (Arg0, 0x01, IRA) |
| FindSetRightBit (IRA, Local0) |
| Local0-- |
| PIRH = Local0 |
| } |
| } |
| } |
| |
| Scope (\_SB) |
| { |
| Name (XCPD, 0x00) |
| Name (XNPT, 0x01) |
| Name (XCAP, 0x02) |
| Name (XDCP, 0x04) |
| Name (XDCT, 0x08) |
| Name (XDST, 0x0A) |
| Name (XLCP, 0x0C) |
| Name (XLCT, 0x10) |
| Name (XLST, 0x12) |
| Name (XSCP, 0x14) |
| Name (XSCT, 0x18) |
| Name (XSST, 0x1A) |
| Name (XRCT, 0x1C) |
| Mutex (MUTE, 0x00) |
| Method (RBPE, 1, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x01) |
| Field (PCFG, ByteAcc, NoLock, Preserve) |
| { |
| XCFG, 8 |
| } |
| |
| Release (MUTE) |
| Return (XCFG) /* \_SB_.RBPE.XCFG */ |
| } |
| |
| Method (RWPE, 1, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Arg0 &= 0xFFFFFFFE |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x02) |
| Field (PCFG, WordAcc, NoLock, Preserve) |
| { |
| XCFG, 16 |
| } |
| |
| Release (MUTE) |
| Return (XCFG) /* \_SB_.RWPE.XCFG */ |
| } |
| |
| Method (RDPE, 1, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Arg0 &= 0xFFFFFFFC |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
| Field (PCFG, DWordAcc, NoLock, Preserve) |
| { |
| XCFG, 32 |
| } |
| |
| Release (MUTE) |
| Return (XCFG) /* \_SB_.RDPE.XCFG */ |
| } |
| |
| Method (WBPE, 2, NotSerialized) |
| { |
| Acquire (MUTE, 0x0FFF) |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x01) |
| Field (PCFG, ByteAcc, NoLock, Preserve) |
| { |
| XCFG, 8 |
| } |
| |
| XCFG = Arg1 |
| Release (MUTE) |
| } |
| |
| Method (WWPE, 2, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Arg0 &= 0xFFFFFFFE |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x02) |
| Field (PCFG, WordAcc, NoLock, Preserve) |
| { |
| XCFG, 16 |
| } |
| |
| XCFG = Arg1 |
| Release (MUTE) |
| } |
| |
| Method (WDPE, 2, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Arg0 &= 0xFFFFFFFC |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
| Field (PCFG, DWordAcc, NoLock, Preserve) |
| { |
| XCFG, 32 |
| } |
| |
| XCFG = Arg1 |
| Release (MUTE) |
| } |
| |
| Method (RWDP, 3, NotSerialized) |
| { |
| Acquire (MUTE, 0x03E8) |
| Arg0 &= 0xFFFFFFFC |
| Local0 = (Arg0 + \PCIB) |
| OperationRegion (PCFG, SystemMemory, Local0, 0x04) |
| Field (PCFG, DWordAcc, NoLock, Preserve) |
| { |
| XCFG, 32 |
| } |
| |
| Local1 = (XCFG & Arg2) |
| XCFG = (Local1 | Arg1) |
| Release (MUTE) |
| } |
| |
| Method (RPME, 1, NotSerialized) |
| { |
| Local0 = (Arg0 + 0x84) |
| Local1 = \_SB.RDPE (Local0) |
| If (Local1 == 0xFFFFFFFF) |
| { |
| Return (0x00) |
| } |
| Else |
| { |
| If (Local1 && 0x00010000) |
| { |
| \_SB.WDPE (Local0, (Local1 & 0x00010000)) |
| Return (0x01) |
| } |
| |
| Return (0x00) |
| } |
| } |
| } |
| |
| Name (HBAS, 0x00) |
| Name (HLBA, 0x00) |
| Name (HDEV, 0x00) |
| OperationRegion (REFP, SystemIO, 0x61, 0x01) |
| Field (REFP, ByteAcc, NoLock, Preserve) |
| { |
| P061, 8 |
| } |
| |
| Method (FZHD, 0, NotSerialized) |
| { |
| Local0 = 0x80 |
| Local1 = DMAX /* \DMAX */ |
| While (Local0 <= Local1) |
| { |
| Local3 = (Local0 & 0x7F) |
| Local2 = 0x01 |
| Local2 <<= Local3 |
| If (!(\_SB.PCI0.HFZF & Local2)) |
| { |
| If (FZOD (Local0)) |
| { |
| \_SB.PCI0.HFZF |= Local2 |
| } |
| } |
| |
| Local0++ |
| } |
| } |
| |
| Method (FZOD, 1, NotSerialized) |
| { |
| GHET (Arg0) |
| If (HBAS == 0x00) |
| { |
| Return (0x01) |
| } |
| |
| If (HDEV == 0x00) |
| { |
| Return (0x01) |
| } |
| |
| Local1 = HDEV /* \HDEV */ |
| Local1 &= 0x10 |
| If (Local1 == 0x00) |
| { |
| Return (0x01) |
| } |
| |
| SDRV () |
| Local1 = (HBAS + 0x07) |
| OperationRegion (HRGS, SystemIO, Local1, 0x01) |
| Field (HRGS, ByteAcc, NoLock, Preserve) |
| { |
| SREG, 8 |
| } |
| |
| Local1 = SREG /* \FZOD.SREG */ |
| Local1 &= 0x80 |
| If (Local1) |
| { |
| Return (0x00) |
| } |
| |
| Local1 = (HBAS + 0x07) |
| OperationRegion (HRGC, SystemIO, Local1, 0x01) |
| Field (HRGC, ByteAcc, NoLock, Preserve) |
| { |
| CREG, 8 |
| } |
| |
| CREG = 0xF5 |
| If (WFCF ()) |
| { |
| Local0 = (HBAS + 0x07) |
| Local1 = SREG /* \FZOD.SREG */ |
| Return (!(Local1 & 0x01)) |
| } |
| Else |
| { |
| Return (0x00) |
| } |
| } |
| |
| OperationRegion (DBGA, SystemIO, 0x80, 0x04) |
| Field (DBGA, DWordAcc, NoLock, Preserve) |
| { |
| DB32, 32 |
| } |
| |
| Method (GHET, 1, NotSerialized) |
| { |
| Local0 = (Arg0 & 0x7F) |
| Local0 <<= 0x05 |
| Local0 += HPTA /* \HPTA */ |
| OperationRegion (HDPT, SystemMemory, Local0, 0x20) |
| Field (HDPT, ByteAcc, NoLock, Preserve) |
| { |
| HP00, 16, |
| Offset (0x04), |
| HP04, 8, |
| Offset (0x12), |
| HP0C, 8 |
| } |
| |
| HBAS = HP00 /* \GHET.HP00 */ |
| HLBA = HP04 /* \GHET.HP04 */ |
| HDEV = HP0C /* \GHET.HP0C */ |
| } |
| |
| Method (SDRV, 0, NotSerialized) |
| { |
| Local0 = (HBAS + 0x06) |
| OperationRegion (HRGH, SystemIO, Local0, 0x01) |
| Field (HRGH, ByteAcc, NoLock, Preserve) |
| { |
| HREG, 8 |
| } |
| |
| HREG = HLBA /* \HLBA */ |
| } |
| |
| Method (WFCF, 0, NotSerialized) |
| { |
| SDRV () |
| Local0 = (HBAS + 0x01) |
| OperationRegion (HRGE, SystemIO, Local0, 0x01) |
| Field (HRGE, ByteAcc, NoLock, Preserve) |
| { |
| EREG, 8 |
| } |
| |
| EREG = 0x00 |
| Local1 = (HBAS + 0x07) |
| OperationRegion (HRGC, SystemIO, Local1, 0x01) |
| Field (HRGC, ByteAcc, NoLock, Preserve) |
| { |
| CREG, 8 |
| } |
| |
| Local0 = 0x28 |
| While (Local0) |
| { |
| Local2 = (CREG & 0x01) |
| If (Local2) |
| { |
| Return (0x00) |
| } |
| |
| WFZF (Local1) |
| Local2 = (CREG & 0x80) |
| If (Local2 == 0x00) |
| { |
| Return (0x01) |
| } |
| |
| Local0-- |
| } |
| |
| Return (0x00) |
| } |
| |
| Method (WFZF, 1, NotSerialized) |
| { |
| OperationRegion (HRGC, SystemIO, Arg0, 0x01) |
| Field (HRGC, ByteAcc, NoLock, Preserve) |
| { |
| CREG, 8 |
| } |
| |
| Local1 = 0xFFFF |
| While (Local1) |
| { |
| Local2 = CREG /* \WFZF.CREG */ |
| Local2 &= 0x80 |
| If (Local2 == 0x00) |
| { |
| Return (0x01) |
| } |
| |
| Stall (0x0F) |
| Local1-- |
| } |
| |
| Return (0x00) |
| } |
| |
| Scope (\_SB.PCI0) |
| { |
| Name (HFZF, 0x00) |
| Method (HWAK, 1, NotSerialized) |
| { |
| If (Arg0 == 0x03) |
| { |
| HFZF = 0x00 |
| } |
| } |
| } |
| |
| Scope (\_SB.PCI0.SBRG.SIOR) |
| { |
| Method (HWV0, 0, NotSerialized) |
| { |
| Return ((VCOR * 0x08)) |
| } |
| |
| Method (HWV1, 0, NotSerialized) |
| { |
| Local0 = (V12V * 0x08) |
| Return (Local0) |
| } |
| |
| Method (HWV3, 0, NotSerialized) |
| { |
| Local0 = (V33V * 0x08) |
| Return (Local0) |
| } |
| |
| Method (HWV5, 0, NotSerialized) |
| { |
| Local0 = (V50V * 0x08) |
| Return (Local0) |
| } |
| |
| Method (HWT0, 0, NotSerialized) |
| { |
| Local1 = MBTE /* \_SB_.PCI0.SBRG.SIOR.MBTE */ |
| Local1 *= 0x0A |
| Return (Local1) |
| } |
| |
| Method (HWT1, 0, NotSerialized) |
| { |
| BSEL = 0x01 |
| Local1 = TSR1 /* \_SB_.PCI0.SBRG.SIOR.TSR1 */ |
| Local1 *= 0x0A |
| Local2 = TSR2 /* \_SB_.PCI0.SBRG.SIOR.TSR2 */ |
| Local2 *= 0x05 |
| Local1 += Local2 |
| Return (Local1) |
| } |
| |
| Method (HWT2, 0, NotSerialized) |
| { |
| BSEL = 0x02 |
| Local1 = TSR1 /* \_SB_.PCI0.SBRG.SIOR.TSR1 */ |
| Local1 *= 0x0A |
| Local2 = TSR2 /* \_SB_.PCI0.SBRG.SIOR.TSR2 */ |
| Local2 *= 0x05 |
| Local1 += Local2 |
| Return (Local1) |
| } |
| |
| Method (HWF0, 0, NotSerialized) |
| { |
| Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */ |
| BSEL = 0x00 |
| Local1 = (FD21 & 0x20) |
| Local1 >>= 0x05 |
| Local1 *= 0x04 |
| Local1 += FD11 /* \_SB_.PCI0.SBRG.SIOR.FD11 */ |
| While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < |
| 0x64) && (Local1 > 0x00))) |
| { |
| If ((Local0 > 0xE6) && (Local1 < 0x07)) |
| { |
| Local1 += 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x05 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0xDF |
| FD21 = (Local3 | Local4) |
| FD11 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */ |
| } |
| Else |
| { |
| Local1 -= 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x05 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0xDF |
| FD21 = (Local3 | Local4) |
| FD11 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN1 /* \_SB_.PCI0.SBRG.SIOR.FAN1 */ |
| } |
| } |
| |
| If ((Local0 == 0xFF) && (Local1 == 0x07)) |
| { |
| Return (0x00) |
| } |
| |
| If ((Local0 == 0x00) && (Local1 == 0x00)) |
| { |
| Return (0xFFFF) |
| } |
| |
| Local2 = 0x01 |
| While (Local1) |
| { |
| Local2 *= 0x02 |
| Local1-- |
| } |
| |
| Local0 *= Local2 |
| Divide (0x00149970, Local0, Local1, Local0) |
| Return (Local0) |
| } |
| |
| Method (HWF1, 0, NotSerialized) |
| { |
| Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */ |
| BSEL = 0x00 |
| Local1 = (FD21 & 0x40) |
| Local1 >>= 0x06 |
| Local1 *= 0x04 |
| Local1 += FD12 /* \_SB_.PCI0.SBRG.SIOR.FD12 */ |
| While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < |
| 0x64) && (Local1 > 0x00))) |
| { |
| If ((Local0 > 0xE6) && (Local1 < 0x07)) |
| { |
| Local1 += 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x06 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0xBF |
| FD21 = (Local3 | Local4) |
| FD12 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */ |
| } |
| Else |
| { |
| Local1 -= 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x06 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0xBF |
| FD21 = (Local3 | Local4) |
| FD12 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN2 /* \_SB_.PCI0.SBRG.SIOR.FAN2 */ |
| } |
| } |
| |
| If ((Local0 == 0xFF) && (Local1 == 0x07)) |
| { |
| Return (0x00) |
| } |
| |
| If ((Local0 == 0x00) && (Local1 == 0x00)) |
| { |
| Return (0xFFFF) |
| } |
| |
| Local2 = 0x01 |
| While (Local1) |
| { |
| Local2 *= 0x02 |
| Local1-- |
| } |
| |
| Local0 *= Local2 |
| Divide (0x00149970, Local0, Local1, Local0) |
| Return (Local0) |
| } |
| |
| Method (HWF2, 0, NotSerialized) |
| { |
| Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */ |
| BSEL = 0x00 |
| Local1 = (FD21 & 0x80) |
| Local1 >>= 0x07 |
| Local1 *= 0x04 |
| Divide (FD13, 0x40, Local2, Local3) |
| Local1 += Local3 |
| While (((Local0 > 0xE6) && (Local1 < 0x07)) || ((Local0 < |
| 0x64) && (Local1 > 0x00))) |
| { |
| If ((Local0 > 0xE6) && (Local1 < 0x07)) |
| { |
| Local1 += 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x07 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0x7F |
| FD21 = (Local3 | Local4) |
| Local3 = FD13 /* \_SB_.PCI0.SBRG.SIOR.FD13 */ |
| Local3 &= 0x3F |
| Local2 *= 0x40 |
| Local2 += Local3 |
| FD13 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */ |
| } |
| Else |
| { |
| Local1 -= 0x01 |
| Divide (Local1, 0x04, Local2, Local3) |
| BSEL = 0x00 |
| Local3 <<= 0x07 |
| Local4 = FD21 /* \_SB_.PCI0.SBRG.SIOR.FD21 */ |
| Local4 &= 0x7F |
| FD21 = (Local3 | Local4) |
| Local3 = FD13 /* \_SB_.PCI0.SBRG.SIOR.FD13 */ |
| Local3 &= 0x3F |
| Local2 *= 0x40 |
| Local2 += Local3 |
| FD13 = Local2 |
| Sleep (0x012C) |
| Local0 = FAN3 /* \_SB_.PCI0.SBRG.SIOR.FAN3 */ |
| } |
| } |
| |
| If ((Local0 == 0xFF) && (Local1 == 0x07)) |
| { |
| Return (0x00) |
| } |
| |
| If ((Local0 == 0x00) && (Local1 == 0x00)) |
| { |
| Return (0xFFFF) |
| } |
| |
| Local2 = 0x01 |
| While (Local1) |
| { |
| Local2 *= 0x02 |
| Local1-- |
| } |
| |
| Local0 *= Local2 |
| Divide (0x00149970, Local0, Local1, Local0) |
| Return (Local0) |
| } |
| |
| OperationRegion (HWRE, SystemIO, IOHW, 0x0A) |
| Field (HWRE, ByteAcc, NoLock, Preserve) |
| { |
| Offset (0x05), |
| HIDX, 8, |
| HDAT, 8 |
| } |
| |
| IndexField (HIDX, HDAT, ByteAcc, NoLock, Preserve) |
| { |
| Offset (0x04), |
| CHNM, 1, |
| CFNM, 1, |
| CHNS, 2, |
| CFNS, 2, |
| Offset (0x05), |
| SYST, 8, |
| TRGT, 8, |
| Offset (0x08), |
| SSDN, 8, |
| CSDN, 8, |
| SSUP, 8, |
| CSUP, 8, |
| Offset (0x20), |
| VCOR, 8, |
| V12V, 8, |
| Offset (0x23), |
| V33V, 8, |
| Offset (0x25), |
| V50V, 8, |
| Offset (0x27), |
| MBTE, 8, |
| FAN1, 8, |
| FAN2, 8, |
| FAN3, 8, |
| Offset (0x40), |
| HWST, 1, |
| Offset (0x41), |
| Offset (0x47), |
| , 4, |
| FD11, 2, |
| FD12, 2, |
| Offset (0x4B), |
| FD13, 8, |
| Offset (0x4E), |
| BSEL, 3, |
| Offset (0x4F), |
| Offset (0x50), |
| TSR1, 8, |
| TSR2, 1, |
| Offset (0x52), |
| Offset (0x5D), |
| FD21, 8 |
| } |
| } |
| |
| Scope (\_SB.PCI0.SBRG.ASOC) |
| { |
| Name (CORV, Package (0x05) |
| { |
| 0x06020000, |
| "Vcore Voltage", |
| 0x0352, |
| 0x0640, |
| 0x01 |
| }) |
| Name (V3VV, Package (0x05) |
| { |
| 0x06020001, |
| " +3.3 Voltage", |
| 0x0B9A, |
| 0x0E2E, |
| 0x01 |
| }) |
| Name (V5VV, Package (0x05) |
| { |
| 0x06020002, |
| " +5 Voltage", |
| 0x1194, |
| 0x157C, |
| 0x01 |
| }) |
| Name (VV12, Package (0x05) |
| { |
| 0x06020003, |
| " +12 Voltage", |
| 0x27D8, |
| 0x35E8, |
| 0x01 |
| }) |
| Name (VPAR, Package (0x04) |
| { |
| Package (0x03) |
| { |
| 0x00, |
| 0x01, |
| 0x00 |
| }, |
| |
| Package (0x03) |
| { |
| 0x22, |
| 0x22, |
| 0x00 |
| }, |
| |
| Package (0x03) |
| { |
| 0x16, |
| 0x0A, |
| 0x00 |
| }, |
| |
| Package (0x03) |
| { |
| 0x38, |
| 0x0A, |
| 0x00 |
| } |
| }) |
| Name (VBUF, Package (0x05) |
| { |
| 0x04, |
| CORV, |
| V3VV, |
| V5VV, |
| VV12 |
| }) |
| Method (VGET, 1, NotSerialized) |
| { |
| Local0 = 0x00 |
| If (Arg0 == 0x00) |
| { |
| Local0 = ^^SIOR.HWV0 () |
| } |
| |
| If (Arg0 == 0x01) |
| { |
| Local0 = ^^SIOR.HWV3 () |
| } |
| |
| If (Arg0 == 0x02) |
| { |
| Local0 = ^^SIOR.HWV5 () |
| } |
| |
| If (Arg0 == 0x03) |
| { |
| Local0 = ^^SIOR.HWV1 () |
| } |
| |
| Return (Local0) |
| } |
| |
| Name (CPUT, Package (0x05) |
| { |
| 0x06030000, |
| "CPU Temperature", |
| 0x0258, |
| 0x03B6, |
| 0x00010001 |
| }) |
| Name (TBUF, Package (0x02) |
| { |
| 0x01, |
| CPUT |
| }) |
| Method (TGET, 1, NotSerialized) |
| { |
| Local0 = 0x00 |
| If (Arg0 == 0x00) |
| { |
| Local0 = ^^SIOR.HWT1 () |
| } |
| |
| Return (Local0) |
| } |
| |
| Name (CPUF, Package (0x05) |
| { |
| 0x06040000, |
| "CPU FAN Speed", |
| 0x0258, |
| 0x1C20, |
| 0x00010001 |
| }) |
| Name (CHAF, Package (0x05) |
| { |
| 0x06040001, |
| "CHASSIS FAN Speed", |
| 0x0320, |
| 0x1C20, |
| 0x00010001 |
| }) |
| Name (FBUF, Package (0x03) |
| { |
| 0x02, |
| CPUF, |
| CHAF |
| }) |
| Method (FGET, 1, NotSerialized) |
| { |
| Local0 = 0x00 |
| If (Arg0 == 0x00) |
| { |
| Local0 = ^^SIOR.HWF1 () |
| } |
| |
| If (Arg0 == 0x01) |
| { |
| Local0 = ^^SIOR.HWF0 () |
| } |
| |
| Return (Local0) |
| } |
| |
| Method (VSIF, 0, Serialized) |
| { |
| Return (VBUF) /* \_SB_.PCI0.SBRG.ASOC.VBUF */ |
| } |
| |
| Method (RVLT, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (Arg0 & 0xFFFF) |
| Local1 = VGET (Local0) |
| Local2 = DerefOf (DerefOf (VPAR [Local0]) [0x00]) |
| Local3 = DerefOf (DerefOf (VPAR [Local0]) [0x01]) |
| Local4 = DerefOf (DerefOf (VPAR [Local0]) [0x02]) |
| Local5 = (Local1 * (Local2 + Local3)) |
| Local5 /= Local3 |
| Local5 += Local4 |
| Release (AMTX) |
| Return (Local5) |
| } |
| |
| Method (SVLT, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF) |
| Local1 = DerefOf (VBUF [0x00]) |
| If (Local0 >= Local1) |
| { |
| Release (AMTX) |
| Return (0x00) |
| } |
| |
| Local0++ |
| DerefOf (VBUF [Local0]) [0x01] = DerefOf (Arg0 [ |
| 0x01]) |
| DerefOf (VBUF [Local0]) [0x02] = DerefOf (Arg0 [ |
| 0x02]) |
| DerefOf (VBUF [Local0]) [0x03] = DerefOf (Arg0 [ |
| 0x03]) |
| DerefOf (VBUF [Local0]) [0x04] = DerefOf (Arg0 [ |
| 0x04]) |
| Release (AMTX) |
| Return (0x01) |
| } |
| |
| Method (TSIF, 0, Serialized) |
| { |
| Return (TBUF) /* \_SB_.PCI0.SBRG.ASOC.TBUF */ |
| } |
| |
| Method (RTMP, 1, NotSerialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (Arg0 & 0xFFFF) |
| Local1 = TGET (Local0) |
| Release (AMTX) |
| Return (Local1) |
| } |
| |
| Method (STMP, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF) |
| Local1 = DerefOf (TBUF [0x00]) |
| If (Local0 >= Local1) |
| { |
| Release (AMTX) |
| Return (0x00) |
| } |
| |
| Local0++ |
| DerefOf (TBUF [Local0]) [0x01] = DerefOf (Arg0 [ |
| 0x01]) |
| DerefOf (TBUF [Local0]) [0x02] = DerefOf (Arg0 [ |
| 0x02]) |
| DerefOf (TBUF [Local0]) [0x03] = DerefOf (Arg0 [ |
| 0x03]) |
| DerefOf (TBUF [Local0]) [0x04] = DerefOf (Arg0 [ |
| 0x04]) |
| Release (AMTX) |
| Return (0x01) |
| } |
| |
| Method (FSIF, 0, Serialized) |
| { |
| Return (FBUF) /* \_SB_.PCI0.SBRG.ASOC.FBUF */ |
| } |
| |
| Method (RFAN, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (Arg0 & 0xFFFF) |
| Local1 = FGET (Local0) |
| Release (AMTX) |
| Return (Local1) |
| } |
| |
| Method (SFAN, 1, Serialized) |
| { |
| Acquire (AMTX, 0xFFFF) |
| Local0 = (DerefOf (Arg0 [0x00]) & 0xFFFF) |
| Local1 = DerefOf (FBUF [0x00]) |
| If (Local0 >= Local1) |
| { |
| Release (AMTX) |
| Return (0x00) |
| } |
| |
| Local0++ |
| DerefOf (FBUF [Local0]) [0x01] = DerefOf (Arg0 [ |
| 0x01]) |
| DerefOf (FBUF [Local0]) [0x02] = DerefOf (Arg0 [ |
| 0x02]) |
| DerefOf (FBUF [Local0]) [0x03] = DerefOf (Arg0 [ |
| 0x03]) |
| DerefOf (FBUF [Local0]) [0x04] = DerefOf (Arg0 [ |
| 0x04]) |
| Release (AMTX) |
| Return (0x01) |
| } |
| } |
| |
| Scope (\_SB) |
| { |
| Scope (PCI0) |
| { |
| Name (CRS, ResourceTemplate () |
| { |
| WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, |
| 0x0000, // Granularity |
| 0x0000, // Range Minimum |
| 0x00FF, // Range Maximum |
| 0x0000, // Translation Offset |
| 0x0100, // Length |
| ,, ) |
| IO (Decode16, |
| 0x0CF8, // Range Minimum |
| 0x0CF8, // Range Maximum |
| 0x01, // Alignment |
| 0x08, // Length |
| ) |
| WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
| 0x0000, // Granularity |
| 0x0000, // Range Minimum |
| 0x0CF7, // Range Maximum |
| 0x0000, // Translation Offset |
| 0x0CF8, // Length |
| ,, , TypeStatic) |
| WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, |
| 0x0000, // Granularity |
| 0x0D00, // Range Minimum |
| 0xFFFF, // Range Maximum |
| 0x0000, // Translation Offset |
| 0xF300, // Length |
| ,, , TypeStatic) |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
| 0x00000000, // Granularity |
| 0x000A0000, // Range Minimum |
| 0x000BFFFF, // Range Maximum |
| 0x00000000, // Translation Offset |
| 0x00020000, // Length |
| ,, , AddressRangeMemory, TypeStatic) |
| DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, |
| 0x00000000, // Granularity |
| 0x00000000, // Range Minimum |
| 0x00000000, // Range Maximum |
| 0x00000000, // Translation Offset |
| 0x00000000, // Length |
| ,, _Y18, AddressRangeMemory, TypeStatic) |
| }) |
| CreateDWordField (CRS, \_SB.PCI0._Y18._MIN, MIN6) // _MIN: Minimum Base Address |
| CreateDWordField (CRS, \_SB.PCI0._Y18._MAX, MAX6) // _MAX: Maximum Base Address |
| CreateDWordField (CRS, \_SB.PCI0._Y18._LEN, LEN6) // _LEN: Length |
| Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings |
| { |
| MIN6 = MG2B /* \MG2B */ |
| MIN6 += 0x00010000 |
| LEN6 = MG2L /* \MG2L */ |
| LEN6 -= 0x00010000 |
| Local0 = LEN6 /* \_SB_.PCI0.LEN6 */ |
| MAX6 = (MIN6 + Local0--) |
| Return (CRS) /* \_SB_.PCI0.CRS_ */ |
| } |
| } |
| } |
| |
| Name (WOTB, 0x00) |
| Name (WSSB, 0x00) |
| Name (WAXB, 0x00) |
| Method (_PTS, 1, NotSerialized) // _PTS: Prepare To Sleep |
| { |
| DBG8 = Arg0 |
| PTS (Arg0) |
| WAKP [0x00] = 0x00 |
| WAKP [0x01] = 0x00 |
| If ((Arg0 == 0x04) && (OSFL () == 0x02)) |
| { |
| Sleep (0x0BB8) |
| } |
| |
| WSSB = ASSB /* \ASSB */ |
| WOTB = AOTB /* \AOTB */ |
| WAXB = AAXB /* \AAXB */ |
| ASSB = Arg0 |
| AOTB = OSFL () |
| AAXB = Zero |
| } |
| |
| Method (_WAK, 1, NotSerialized) // _WAK: Wake |
| { |
| DBG8 = (Arg0 << 0x04) |
| WAK (Arg0) |
| If (IOWK) {} |
| Else |
| { |
| Notify (\_SB.PWRB, 0x02) // Device Wake |
| } |
| |
| If (ASSB) |
| { |
| ASSB = WSSB /* \WSSB */ |
| AOTB = WOTB /* \WOTB */ |
| AAXB = WAXB /* \WAXB */ |
| } |
| |
| If (DerefOf (WAKP [0x00])) |
| { |
| WAKP [0x01] = 0x00 |
| } |
| Else |
| { |
| WAKP [0x01] = Arg0 |
| } |
| |
| Return (WAKP) /* \WAKP */ |
| } |
| |
| OperationRegion (PMS0, SystemIO, PMBS, 0x04) |
| Field (PMS0, ByteAcc, NoLock, Preserve) |
| { |
| , 10, |
| RTCS, 1, |
| , 4, |
| WAKS, 1, |
| Offset (0x03), |
| PWBT, 1, |
| , 1, |
| RTCE, 1, |
| Offset (0x04) |
| } |
| |
| OperationRegion (SMIE, SystemIO, PM30, 0x08) |
| Field (SMIE, ByteAcc, NoLock, Preserve) |
| { |
| , 4, |
| PS1E, 1, |
| , 31, |
| PS1S, 1, |
| Offset (0x08) |
| } |
| |
| OperationRegion (\_SB.PCI0.SKPD, PCI_Config, ACPH, 0x02) |
| Field (\_SB.PCI0.SKPD, ByteAcc, NoLock, Preserve) |
| { |
| APWR, 8, |
| SPLV, 3, |
| OSFG, 2, |
| Offset (0x02) |
| } |
| |
| OperationRegion (IORK, SystemIO, 0xB3, 0x01) |
| Field (IORK, ByteAcc, NoLock, Preserve) |
| { |
| IOWK, 8 |
| } |
| |
| Scope (\_SB.PCI0.IDE0) |
| { |
| OperationRegion (PAR9, PCI_Config, 0x09, 0x01) |
| Field (PAR9, ByteAcc, NoLock, Preserve) |
| { |
| PAMD, 8 |
| } |
| } |
| |
| Scope (\_SB.PCI0.IDE1) |
| { |
| OperationRegion (SAR9, PCI_Config, 0x09, 0x01) |
| Field (SAR9, ByteAcc, NoLock, Preserve) |
| { |
| SAMD, 8 |
| } |
| } |
| |
| Name (\_S0, Package (0x04) // _S0_: S0 System State |
| { |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| If (SS1) |
| { |
| Name (\_S1, Package (0x04) // _S1_: S1 System State |
| { |
| 0x01, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| } |
| |
| If (SS3) |
| { |
| Name (\_S3, Package (0x04) // _S3_: S3 System State |
| { |
| 0x05, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| } |
| |
| If (SS4) |
| { |
| Name (\_S4, Package (0x04) // _S4_: S4 System State |
| { |
| 0x06, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| } |
| |
| Name (\_S5, Package (0x04) // _S5_: S5 System State |
| { |
| 0x07, |
| 0x00, |
| 0x00, |
| 0x00 |
| }) |
| Scope (\_SB.PCI0) |
| { |
| Method (_INI, 0, NotSerialized) // _INI: Initialize |
| { |
| } |
| } |
| |
| Method (PTS, 1, NotSerialized) |
| { |
| If (Arg0) |
| { |
| \_SB.PCI0.SBRG.SIOS (Arg0) |
| \_SB.PCI0.NPTS (Arg0) |
| \_SB.PCI0.SBRG.SPTS (Arg0) |
| } |
| } |
| |
| Method (WAK, 1, NotSerialized) |
| { |
| \_SB.PCI0.SBRG.SIOW (Arg0) |
| \_SB.PCI0.NWAK (Arg0) |
| \_SB.PCI0.SBRG.SWAK (Arg0) |
| \_SB.PCI0.HWAK (Arg0) |
| } |
| } |
| |