From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- src/VBox/Devices/PC/vbox.dsl | 1991 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1991 insertions(+) create mode 100644 src/VBox/Devices/PC/vbox.dsl (limited to 'src/VBox/Devices/PC/vbox.dsl') diff --git a/src/VBox/Devices/PC/vbox.dsl b/src/VBox/Devices/PC/vbox.dsl new file mode 100644 index 00000000..8af9f3ae --- /dev/null +++ b/src/VBox/Devices/PC/vbox.dsl @@ -0,0 +1,1991 @@ +/* $Id: vbox.dsl $ */ +/** @file + * VirtualBox ACPI + */ + +/* + * Copyright (C) 2006-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +DefinitionBlock ("DSDT.aml", "DSDT", 2, "VBOX ", "VBOXBIOS", 2) +{ + // Declare debugging ports withing SystemIO + OperationRegion(DBG0, SystemIO, 0x3000, 4) + + // Writes to this field Will dump hex char + Field (DBG0, ByteAcc, NoLock, Preserve) + { + DHE1, 8, + } + + // Writes to this field Will dump hex word + Field (DBG0, WordAcc, NoLock, Preserve) + { + DHE2, 16, + } + + // Writes to this field Will dump hex double word + Field (DBG0, DWordAcc, NoLock, Preserve) + { + DHE4, 32, + } + + // Writes to this field will dump ascii char + Field (DBG0, ByteAcc, NoLock, Preserve) + { + Offset (1), + DCHR, 8 + } + + // Shortcuts + Method(HEX, 1) + { + Store (Arg0, DHE1) + } + + Method(HEX2, 1) + { + Store (Arg0, DHE2) + } + + Method(HEX4, 1) + { + Store (Arg0, DHE4) + } + + // Code from Microsoft sample + // http://www.microsoft.com/whdc/system/pnppwr/powermgmt/_OSI-method.mspx + + // + // SLEN(Str) - Returns the length of Str (excluding NULL). + // + Method(SLEN, 1) + { + // + // Note: The caller must make sure that the argument is a string object. + // + Store(Arg0, Local0) + Return(Sizeof(Local0)) + } + + + // + // S2BF(Str) - Convert a string object into a buffer object. + // + Method(S2BF, 1, Serialized) + { + // + // Note: The caller must make sure that the argument is a string object. + // + // Local0 contains length of string + NULL. + // + Store(Arg0, Local0) + Add(SLEN(Local0), One, Local0) + // + // Convert the string object into a buffer object. + // + Name(BUFF, Buffer(Local0) {}) + Store(Arg0, BUFF) + Return(BUFF) + } + + // + // MIN(Int1, Int2) - Returns the minimum of Int1 or Int2. + // + // + Method(MIN, 2) + { + // + // Note: The caller must make sure that both arguments are integer objects. + // + If (LLess(Arg0, Arg1)) + { + Return(Arg0) + } + Else + { + Return(Arg1) + } + } + + // + // SCMP(Str1, Str2) - Compare Str1 and Str2. + // Returns One if Str1 > Str2 + // Returns Zero if Str1 == Str2 + // Returns Ones if Str1 < Str2 + // + Method(SCMP, 2) + { + // + // Note: The caller must make sure that both arguments are string objects. + // + // Local0 is a buffer of Str1. + // Local1 is a buffer of Str2. + // Local2 is the indexed byte of Str1. + // Local3 is the indexed byte of Str2. + // Local4 is the index to both Str1 and Str2. + // Local5 is the length of Str1. + // Local6 is the length of Str2. + // Local7 is the minimum of Str1 or Str2 length. + // + + Store(Arg0, Local0) + Store(S2BF(Local0), Local0) + + Store(S2BF(Arg1), Local1) + Store(Zero, Local4) + + Store(SLEN(Arg0), Local5) + Store(SLEN(Arg1), Local6) + Store(MIN(Local5, Local6), Local7) + + While (LLess(Local4, Local7)) + { + Store(Derefof(Index(Local0, Local4)), Local2) + Store(Derefof(Index(Local1, Local4)), Local3) + If (LGreater(Local2, Local3)) + { + Return(One) + } + Else + { + If (LLess(Local2, Local3)) + { + Return(Ones) + } + } + + Increment(Local4) + } + + If (LLess(Local4, Local5)) + { + Return(One) + } + Else + { + If (LLess(Local4, Local6)) + { + Return(Ones) + } + Else + { + Return(Zero) + } + } + } + + // Return one if strings match, zero otherwise. Wrapper around SCMP + Method (MTCH, 2) + { + Store(Arg0, Local0) + Store(Arg1, Local1) + Store(SCMP(Local0, Local1), Local2) + Return(LNot(Local2)) + } + + // Convert ASCII string to buffer and store it's contents (char by + // char) into DCHR (thus possibly writing the string to console) + Method (\DBG, 1, NotSerialized) + { + Store(Arg0, Local0) + Store(S2BF (Local0), Local1) + Store(SizeOf (Local1), Local0) + Decrement (Local0) + Store(Zero, Local2) + While (Local0) + { + Decrement (Local0) + Store (DerefOf (Index (Local1, Local2)), DCHR) + Increment (Local2) + } + } + + // Microsoft Windows version indicator + Name(MSWV, Ones) + + // + // Return Windows version. Detect non-Microsoft OSes. + // + // 0 : Not Windows OS + // 2 : Windows Me + // 3 : Windows 2000 (NT pre-XP) + // 4 : Windows XP + // 5 : Windows Server 2003 + // 6 : Windows Vista + // 7 : Windows 7 + // 8 : Windows 8 + // 9 : Windows 8.1 + // 10 : Windows 10 + Method(MSWN, 0, NotSerialized) + { + If (LNotEqual(MSWV, Ones)) + { + Return(MSWV) + } + + Store(0x00, MSWV) + DBG("_OS: ") + DBG(_OS) + DBG("\n") + + // Does OS provide the _OSI method? + If (CondRefOf(_OSI)) + { + DBG("_OSI exists\n") + // OS returns non-zero value in response to _OSI query if it + // supports the interface. Newer Windows releases support older + // versions of the ACPI interface. + If (_OSI("Windows 2001")) + { + Store(4, MSWV) // XP + } + If (_OSI("Windows 2001.1")) + { + Store(5, MSWV) // Server 2003 + } + If (_OSI("Windows 2006")) + { + Store(6, MSWV) // Vista + } + If (_OSI("Windows 2009")) + { + Store(7, MSWV) // Windows 7 + } + If (_OSI("Windows 2012")) + { + Store(8, MSWV) // Windows 8 + } + If (_OSI("Windows 2013")) + { + Store(9, MSWV) // Windows 8.1 + } + If (_OSI("Windows 2015")) + { + Store(10, MSWV) // Windows 10 + } + + // This must come last and is a trap. No version of Windows + // reports this! + If (_OSI("Windows 2006 SP2")) + { + DBG("Windows 2006 SP2 supported\n") + // Not a Microsoft OS + Store(0, MSWV) + } + } + Else + { + // No _OSI, could be older NT or Windows 9x + If (MTCH(_OS, "Microsoft Windows NT")) + { + Store(3, MSWV) + } + If (MTCH(_OS, "Microsoft WindowsME: Millennium Edition")) + { + Store(2, MSWV) + } + } + + // Does OS provide the _REV method? + If (CondRefOf(_REV)) + { + DBG("_REV: ") + HEX4(_REV) + + // Defeat most Linuxes and other non-Microsoft OSes. Microsoft Windows + // up to Server 2003 reports ACPI 1.0 support, Vista up to Windows 10 + // reports ACPI 2.0 support. Anything pretending to be a Windows OS + // with higher ACPI revision support is a fake. + If (LAnd(LGreater(MSWV, 0),LGreater(_REV, 2))) + { + If (LLess(MSWV,8)) + { + DBG("ACPI rev mismatch, not a Microsoft OS\n") + Store(0, MSWV) + } + } + } + + DBG("Determined MSWV: ") + HEX4(MSWV) + + Return(MSWV) + } + + Name(PICM, 0) + Method(_PIC, 1) + { + DBG ("Pic mode: ") + HEX4 (Arg0) + Store (Arg0, PICM) + } + + // Declare indexed registers used for reading configuration information + OperationRegion (SYSI, SystemIO, 0x4048, 0x08) + Field (SYSI, DwordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32, + } + + IndexField (IDX0, DAT0, DwordAcc, NoLock, Preserve) + { + MEML, 32, // low-memory length (64KB units) + UIOA, 32, // if IO APIC enabled + UHPT, 32, // if HPET enabled + USMC, 32, // if SMC enabled + UFDC, 32, // if floppy controller enabled + SL2B, 32, // Serial2 base IO address + SL2I, 32, // Serial2 IRQ + SL3B, 32, // Serial3 base IO address + SL3I, 32, // Serial3 IRQ + PMNN, 32, // start of 64-bit prefetch window (64KB units) + URTC, 32, // if RTC shown in tables + CPUL, 32, // flag of CPU lock state + CPUC, 32, // CPU to check lock status + CPET, 32, // type of CPU hotplug event + CPEV, 32, // id of CPU event targets + NICA, 32, // Primary NIC PCI address + HDAA, 32, // HDA PCI address + PWRS, 32, // power states + IOCA, 32, // southbridge IO controller PCI address + HBCA, 32, // host bus controller address + PCIB, 32, // PCI MCFG base start + PCIL, 32, // PCI MCFG length + SL0B, 32, // Serial0 base IO address + SL0I, 32, // Serial0 IRQ + SL1B, 32, // Serial1 base IO address + SL1I, 32, // Serial1 IRQ + PP0B, 32, // Parallel0 base IO address + PP0I, 32, // Parallel0 IRQ + PP1B, 32, // Parallel1 base IO address + PP1I, 32, // Parallel1 IRQ + PMNX, 32, // limit of 64-bit prefetch window (64KB units) + NVMA, 32, // Primary NVMe controller PCI address + IOMA, 32, // AMD IOMMU + SIOA, 32, // Southbridge IO APIC (when AMD IOMMU is present) + Offset (0x200), + VAIN, 32, + } + + Scope (\_SB) + { + Method (_INI, 0, NotSerialized) + { + Store (0xbadc0de, VAIN) + DBG ("MEML: ") + HEX4 (MEML) + DBG ("UIOA: ") + HEX4 (UIOA) + DBG ("UHPT: ") + HEX4 (UHPT) + DBG ("USMC: ") + HEX4 (USMC) + DBG ("UFDC: ") + HEX4 (UFDC) + DBG ("PMNN: ") + HEX4 (PMNN) + } + + // PCI PIC IRQ Routing table + // Must match pci.c:pci_slot_get_pirq + Name (PR00, Package () + { +/** @todo add devices 0/1 to be complete */ + Package (0x04) {0x0002FFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x0002FFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x0002FFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x0002FFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x0003FFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x0003FFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x0003FFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x0003FFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x0004FFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x0004FFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x0004FFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x0004FFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x0005FFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x0005FFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x0005FFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x0005FFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x0006FFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x0006FFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x0006FFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x0006FFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x0007FFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x0007FFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x0007FFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x0007FFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x0008FFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x0008FFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x0008FFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x0008FFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x0009FFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x0009FFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x0009FFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x0009FFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x000AFFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x000AFFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x000AFFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x000AFFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x000BFFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x000BFFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x000BFFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x000BFFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x000CFFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x000CFFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x000CFFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x000CFFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x000DFFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x000DFFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x000DFFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x000DFFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x000EFFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x000EFFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x000EFFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x000EFFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x000FFFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x000FFFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x000FFFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x000FFFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x0010FFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x0010FFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x0010FFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x0010FFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x0011FFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x0011FFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x0011FFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x0011FFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x0012FFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x0012FFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x0012FFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x0012FFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x0013FFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x0013FFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x0013FFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x0013FFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x0014FFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x0014FFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x0014FFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x0014FFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x0015FFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x0015FFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x0015FFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x0015FFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x0016FFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x0016FFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x0016FFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x0016FFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x0017FFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x0017FFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x0017FFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x0017FFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x0018FFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x0018FFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x0018FFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x0018FFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x0019FFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x0019FFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x0019FFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x0019FFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x001AFFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x001AFFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x001AFFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x001AFFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x001BFFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x001BFFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x001BFFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x001BFFFF, 0x03, LNKB, 0x00,}, + + Package (0x04) {0x001CFFFF, 0x00, LNKD, 0x00,}, + Package (0x04) {0x001CFFFF, 0x01, LNKA, 0x00,}, + Package (0x04) {0x001CFFFF, 0x02, LNKB, 0x00,}, + Package (0x04) {0x001CFFFF, 0x03, LNKC, 0x00,}, + + Package (0x04) {0x001DFFFF, 0x00, LNKA, 0x00,}, + Package (0x04) {0x001DFFFF, 0x01, LNKB, 0x00,}, + Package (0x04) {0x001DFFFF, 0x02, LNKC, 0x00,}, + Package (0x04) {0x001DFFFF, 0x03, LNKD, 0x00,}, + + Package (0x04) {0x001EFFFF, 0x00, LNKB, 0x00,}, + Package (0x04) {0x001EFFFF, 0x01, LNKC, 0x00,}, + Package (0x04) {0x001EFFFF, 0x02, LNKD, 0x00,}, + Package (0x04) {0x001EFFFF, 0x03, LNKA, 0x00,}, + + Package (0x04) {0x001FFFFF, 0x00, LNKC, 0x00,}, + Package (0x04) {0x001FFFFF, 0x01, LNKD, 0x00,}, + Package (0x04) {0x001FFFFF, 0x02, LNKA, 0x00,}, + Package (0x04) {0x001FFFFF, 0x03, LNKB, 0x00,} + }) + + // PCI I/O APIC IRQ Routing table + // Must match pci.c:pci_slot_get_acpi_pirq + Name (PR01, Package () + { +/** @todo add devices 0/1 to be complete */ + Package (0x04) {0x0002FFFF, 0x00, 0x00, 0x12,}, + Package (0x04) {0x0002FFFF, 0x01, 0x00, 0x13,}, + Package (0x04) {0x0002FFFF, 0x02, 0x00, 0x14,}, + Package (0x04) {0x0002FFFF, 0x03, 0x00, 0x15,}, + + Package (0x04) {0x0003FFFF, 0x00, 0x00, 0x13,}, + Package (0x04) {0x0003FFFF, 0x01, 0x00, 0x14,}, + Package (0x04) {0x0003FFFF, 0x02, 0x00, 0x15,}, + Package (0x04) {0x0003FFFF, 0x03, 0x00, 0x16,}, + + Package (0x04) {0x0004FFFF, 0x00, 0x00, 0x14,}, + Package (0x04) {0x0004FFFF, 0x01, 0x00, 0x15,}, + Package (0x04) {0x0004FFFF, 0x02, 0x00, 0x16,}, + Package (0x04) {0x0004FFFF, 0x03, 0x00, 0x17,}, + + Package (0x04) {0x0005FFFF, 0x00, 0x00, 0x15,}, + Package (0x04) {0x0005FFFF, 0x01, 0x00, 0x16,}, + Package (0x04) {0x0005FFFF, 0x02, 0x00, 0x17,}, + Package (0x04) {0x0005FFFF, 0x03, 0x00, 0x10,}, + + Package (0x04) {0x0006FFFF, 0x00, 0x00, 0x16,}, + Package (0x04) {0x0006FFFF, 0x01, 0x00, 0x17,}, + Package (0x04) {0x0006FFFF, 0x02, 0x00, 0x10,}, + Package (0x04) {0x0006FFFF, 0x03, 0x00, 0x11,}, + + Package (0x04) {0x0007FFFF, 0x00, 0x00, 0x17,}, + Package (0x04) {0x0007FFFF, 0x01, 0x00, 0x10,}, + Package (0x04) {0x0007FFFF, 0x02, 0x00, 0x11,}, + Package (0x04) {0x0007FFFF, 0x03, 0x00, 0x12,}, + + Package (0x04) {0x0008FFFF, 0x00, 0x00, 0x10,}, + Package (0x04) {0x0008FFFF, 0x01, 0x00, 0x11,}, + Package (0x04) {0x0008FFFF, 0x02, 0x00, 0x12,}, + Package (0x04) {0x0008FFFF, 0x03, 0x00, 0x13,}, + + Package (0x04) {0x0009FFFF, 0x00, 0x00, 0x11,}, + Package (0x04) {0x0009FFFF, 0x01, 0x00, 0x12,}, + Package (0x04) {0x0009FFFF, 0x02, 0x00, 0x13,}, + Package (0x04) {0x0009FFFF, 0x03, 0x00, 0x14,}, + + Package (0x04) {0x000AFFFF, 0x00, 0x00, 0x12,}, + Package (0x04) {0x000AFFFF, 0x01, 0x00, 0x13,}, + Package (0x04) {0x000AFFFF, 0x02, 0x00, 0x14,}, + Package (0x04) {0x000AFFFF, 0x03, 0x00, 0x15,}, + + Package (0x04) {0x000BFFFF, 0x00, 0x00, 0x13,}, + Package (0x04) {0x000BFFFF, 0x01, 0x00, 0x14,}, + Package (0x04) {0x000BFFFF, 0x02, 0x00, 0x15,}, + Package (0x04) {0x000BFFFF, 0x03, 0x00, 0x16,}, + + Package (0x04) {0x000CFFFF, 0x00, 0x00, 0x14,}, + Package (0x04) {0x000CFFFF, 0x01, 0x00, 0x15,}, + Package (0x04) {0x000CFFFF, 0x02, 0x00, 0x16,}, + Package (0x04) {0x000CFFFF, 0x03, 0x00, 0x17,}, + + Package (0x04) {0x000DFFFF, 0x00, 0x00, 0x15,}, + Package (0x04) {0x000DFFFF, 0x01, 0x00, 0x16,}, + Package (0x04) {0x000DFFFF, 0x02, 0x00, 0x17,}, + Package (0x04) {0x000DFFFF, 0x03, 0x00, 0x10,}, + + Package (0x04) {0x000EFFFF, 0x00, 0x00, 0x16,}, + Package (0x04) {0x000EFFFF, 0x01, 0x00, 0x17,}, + Package (0x04) {0x000EFFFF, 0x02, 0x00, 0x10,}, + Package (0x04) {0x000EFFFF, 0x03, 0x00, 0x11,}, + + Package (0x04) {0x000FFFFF, 0x00, 0x00, 0x17,}, + Package (0x04) {0x000FFFFF, 0x01, 0x00, 0x10,}, + Package (0x04) {0x000FFFFF, 0x02, 0x00, 0x11,}, + Package (0x04) {0x000FFFFF, 0x03, 0x00, 0x12,}, + + Package (0x04) {0x0010FFFF, 0x00, 0x00, 0x10,}, + Package (0x04) {0x0010FFFF, 0x01, 0x00, 0x11,}, + Package (0x04) {0x0010FFFF, 0x02, 0x00, 0x12,}, + Package (0x04) {0x0010FFFF, 0x03, 0x00, 0x13,}, + + Package (0x04) {0x0011FFFF, 0x00, 0x00, 0x11,}, + Package (0x04) {0x0011FFFF, 0x01, 0x00, 0x12,}, + Package (0x04) {0x0011FFFF, 0x02, 0x00, 0x13,}, + Package (0x04) {0x0011FFFF, 0x03, 0x00, 0x14,}, + + Package (0x04) {0x0012FFFF, 0x00, 0x00, 0x12,}, + Package (0x04) {0x0012FFFF, 0x01, 0x00, 0x13,}, + Package (0x04) {0x0012FFFF, 0x02, 0x00, 0x14,}, + Package (0x04) {0x0012FFFF, 0x03, 0x00, 0x15,}, + + Package (0x04) {0x0013FFFF, 0x00, 0x00, 0x13,}, + Package (0x04) {0x0013FFFF, 0x01, 0x00, 0x14,}, + Package (0x04) {0x0013FFFF, 0x02, 0x00, 0x15,}, + Package (0x04) {0x0013FFFF, 0x03, 0x00, 0x16,}, + + Package (0x04) {0x0014FFFF, 0x00, 0x00, 0x14,}, + Package (0x04) {0x0014FFFF, 0x01, 0x00, 0x15,}, + Package (0x04) {0x0014FFFF, 0x02, 0x00, 0x16,}, + Package (0x04) {0x0014FFFF, 0x03, 0x00, 0x17,}, + + Package (0x04) {0x0015FFFF, 0x00, 0x00, 0x15,}, + Package (0x04) {0x0015FFFF, 0x01, 0x00, 0x16,}, + Package (0x04) {0x0015FFFF, 0x02, 0x00, 0x17,}, + Package (0x04) {0x0015FFFF, 0x03, 0x00, 0x10,}, + + Package (0x04) {0x0016FFFF, 0x00, 0x00, 0x16,}, + Package (0x04) {0x0016FFFF, 0x01, 0x00, 0x17,}, + Package (0x04) {0x0016FFFF, 0x02, 0x00, 0x10,}, + Package (0x04) {0x0016FFFF, 0x03, 0x00, 0x11,}, + + Package (0x04) {0x0017FFFF, 0x00, 0x00, 0x17,}, + Package (0x04) {0x0017FFFF, 0x01, 0x00, 0x10,}, + Package (0x04) {0x0017FFFF, 0x02, 0x00, 0x11,}, + Package (0x04) {0x0017FFFF, 0x03, 0x00, 0x12,}, + + Package (0x04) {0x0018FFFF, 0x00, 0x00, 0x10,}, + Package (0x04) {0x0018FFFF, 0x01, 0x00, 0x11,}, + Package (0x04) {0x0018FFFF, 0x02, 0x00, 0x12,}, + Package (0x04) {0x0018FFFF, 0x03, 0x00, 0x13,}, + + Package (0x04) {0x0019FFFF, 0x00, 0x00, 0x11,}, + Package (0x04) {0x0019FFFF, 0x01, 0x00, 0x12,}, + Package (0x04) {0x0019FFFF, 0x02, 0x00, 0x13,}, + Package (0x04) {0x0019FFFF, 0x03, 0x00, 0x14,}, + + Package (0x04) {0x001AFFFF, 0x00, 0x00, 0x12,}, + Package (0x04) {0x001AFFFF, 0x01, 0x00, 0x13,}, + Package (0x04) {0x001AFFFF, 0x02, 0x00, 0x14,}, + Package (0x04) {0x001AFFFF, 0x03, 0x00, 0x15,}, + + Package (0x04) {0x001BFFFF, 0x00, 0x00, 0x13,}, + Package (0x04) {0x001BFFFF, 0x01, 0x00, 0x14,}, + Package (0x04) {0x001BFFFF, 0x02, 0x00, 0x15,}, + Package (0x04) {0x001BFFFF, 0x03, 0x00, 0x16,}, + + Package (0x04) {0x001CFFFF, 0x00, 0x00, 0x14,}, + Package (0x04) {0x001CFFFF, 0x01, 0x00, 0x15,}, + Package (0x04) {0x001CFFFF, 0x02, 0x00, 0x16,}, + Package (0x04) {0x001CFFFF, 0x03, 0x00, 0x17,}, + + Package (0x04) {0x001DFFFF, 0x00, 0x00, 0x15,}, + Package (0x04) {0x001DFFFF, 0x01, 0x00, 0x16,}, + Package (0x04) {0x001DFFFF, 0x02, 0x00, 0x17,}, + Package (0x04) {0x001DFFFF, 0x03, 0x00, 0x10,}, + + Package (0x04) {0x001EFFFF, 0x00, 0x00, 0x16,}, + Package (0x04) {0x001EFFFF, 0x01, 0x00, 0x17,}, + Package (0x04) {0x001EFFFF, 0x02, 0x00, 0x10,}, + Package (0x04) {0x001EFFFF, 0x03, 0x00, 0x11,}, + + Package (0x04) {0x001FFFFF, 0x00, 0x00, 0x17,}, + Package (0x04) {0x001FFFFF, 0x01, 0x00, 0x10,}, + Package (0x04) {0x001FFFFF, 0x02, 0x00, 0x11,}, + Package (0x04) {0x001FFFFF, 0x03, 0x00, 0x12,} + }) + + // Possible resource settings for PCI link A + Name (PRSA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {5,9,10,11} + }) + + // Possible resource settings for PCI link B + Name (PRSB, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {5,9,10,11} + }) + + // Possible resource settings for PCI link C + Name (PRSC, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {5,9,10,11} + }) + + // Possible resource settings for PCI link D + Name (PRSD, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {5,9,10,11} + }) + + // PCI bus 0 + Device (PCI0) + { + + Name (_HID, EisaId ("PNP0A03")) // PCI bus PNP id + Method(_ADR, 0, NotSerialized) // PCI address + { + Return (HBCA) + } + Name (_BBN, 0x00) // base bus address (bus number) + Name (_UID, 0x00) + + // Method that returns routing table; also opens PCI to I/O APIC + // interrupt routing backdoor by writing 0xdead 0xbeef signature + // to ISA bridge config space. See DevPCI.cpp/pciSetIrqInternal(). + Method (_PRT, 0, NotSerialized) + { + if (LEqual (LAnd (PICM, UIOA), Zero)) { + DBG ("RETURNING PIC\n") + Store (0x00, \_SB.PCI0.SBRG.APDE) + Store (0x00, \_SB.PCI0.SBRG.APAD) + Return (PR00) + } + else { + DBG ("RETURNING APIC\n") + Store (0xbe, \_SB.PCI0.SBRG.APDE) + Store (0xef, \_SB.PCI0.SBRG.APAD) + Return (PR01) + } + } + + Device (SBRG) + { + // Address of the southbridge device (PIIX or ICH9) + Method(_ADR, 0, NotSerialized) + { + Return (IOCA) + } + OperationRegion (PCIC, PCI_Config, 0x00, 0xff) + + Field (PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0xad), + APAD, 8, + Offset (0xde), + APDE, 8, + } + + // PCI MCFG MMIO ranges + Device (^PCIE) + { + Name (_HID, EisaId ("PNP0C02")) + Name (_UID, 0x11) + Name (CRS, ResourceTemplate () + { + Memory32Fixed (ReadOnly, + 0xdc000000, // Address Base + 0x4000000, // Address Length + _Y13) + }) + Method (_CRS, 0, NotSerialized) + { + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y13._BAS, BAS1) + CreateDWordField (CRS, \_SB.PCI0.PCIE._Y13._LEN, LEN1) + Store (PCIB, BAS1) + Store (PCIL, LEN1) + Return (CRS) + } + Method (_STA, 0, NotSerialized) + { + if (LEqual (PCIB, Zero)) { + Return (0x00) + } + else { + Return (0x0F) + } + } + } + + // Keyboard device + Device (PS2K) + { + Name (_HID, EisaId ("PNP0303")) + Method (_STA, 0, NotSerialized) + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0060, 0x0060, 0x00, 0x01) + IO (Decode16, 0x0064, 0x0064, 0x00, 0x01) + IRQNoFlags () {1} + }) + } + + // DMA Controller + Device (DMAC) + { + Name (_HID, EisaId ("PNP0200")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x0000, 0x0000, 0x01, 0x10) + IO (Decode16, 0x0080, 0x0080, 0x01, 0x10) + IO (Decode16, 0x00C0, 0x00C0, 0x01, 0x20) + DMA (Compatibility, BusMaster, Transfer8_16) {4} + }) + } + + // Floppy disk controller + Device (FDC0) + { + Name (_HID, EisaId ("PNP0700")) + + Method (_STA, 0, NotSerialized) + { + Return (UFDC) + } + + // Current resource settings + Name (_CRS, ResourceTemplate () + { + IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06) + IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01) + IRQNoFlags () {6} + DMA (Compatibility, NotBusMaster, Transfer8) {2} + }) + + // Possible resource settings + Name (_PRS, ResourceTemplate () + { + IO (Decode16, 0x03F0, 0x03F0, 0x01, 0x06) + IO (Decode16, 0x03F7, 0x03F7, 0x01, 0x01) + IRQNoFlags () {6} + DMA (Compatibility, NotBusMaster, Transfer8) {2} + }) + + } + + // Mouse device + Device (PS2M) + { + Name (_HID, EisaId ("PNP0F03")) + Method (_STA, 0, NotSerialized) + { + Return (0x0F) + } + + Name (_CRS, ResourceTemplate () + { + IRQNoFlags () {12} + }) + } + + // Parallel port 0 + Device (^LPT0) + { + Name (_HID, EisaId ("PNP0400")) + Name (_UID, 0x01) + Method (_STA, 0, NotSerialized) + { + If (LEqual (PP0B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x0378, 0x0378, 0x08, 0x08, _Y18) + IRQNoFlags (_Y19) {7} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.LPT0._Y18._MIN, PMI0) + CreateWordField (CRS, \_SB.PCI0.LPT0._Y18._MAX, PMA0) + CreateWordField (CRS, \_SB.PCI0.LPT0._Y18._ALN, PAL0) + CreateWordField (CRS, \_SB.PCI0.LPT0._Y18._LEN, PLE0) + CreateWordField (CRS, \_SB.PCI0.LPT0._Y19._INT, PIQ0) + Store (PP0B, PMI0) + Store (PP0B, PMA0) + If (LEqual (0x3BC, PP0B)) { + Store (0x04, PAL0) + Store (0x04, PLE0) + } + ShiftLeft (0x01, PP0I, PIQ0) + Return (CRS) + } + } + + // Parallel port 1 + Device (^LPT1) + { + Name (_HID, EisaId ("PNP0400")) + Name (_UID, 0x02) + Method (_STA, 0, NotSerialized) + { + If (LEqual (PP1B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x0278, 0x0278, 0x08, 0x08, _Y20) + IRQNoFlags (_Y21) {5} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.LPT1._Y20._MIN, PMI1) + CreateWordField (CRS, \_SB.PCI0.LPT1._Y20._MAX, PMA1) + CreateWordField (CRS, \_SB.PCI0.LPT1._Y20._ALN, PAL1) + CreateWordField (CRS, \_SB.PCI0.LPT1._Y20._LEN, PLE1) + CreateWordField (CRS, \_SB.PCI0.LPT1._Y21._INT, PIQ1) + Store (PP1B, PMI1) + Store (PP1B, PMA1) + If (LEqual (0x3BC, PP1B)) { + Store (0x04, PAL1) + Store (0x04, PLE1) + } + ShiftLeft (0x01, PP1I, PIQ1) + Return (CRS) + } + } + + + // Serial port 0 + Device (^SRL0) + { + Name (_HID, EisaId ("PNP0501")) + Name (_UID, 0x01) + Method (_STA, 0, NotSerialized) + { + If (LEqual (SL0B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x03F8, 0x03F8, 0x01, 0x08, _Y14) + IRQNoFlags (_Y15) {4} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.SRL0._Y14._MIN, MIN0) + CreateWordField (CRS, \_SB.PCI0.SRL0._Y14._MAX, MAX0) + CreateWordField (CRS, \_SB.PCI0.SRL0._Y15._INT, IRQ0) + Store (SL0B, MIN0) + Store (SL0B, MAX0) + ShiftLeft (0x01, SL0I, IRQ0) + Return (CRS) + } + } + + // Serial port 1 + Device (^SRL1) + { + Name (_HID, EisaId ("PNP0501")) + Name (_UID, 0x02) + Method (_STA, 0, NotSerialized) + { + If (LEqual (SL1B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x02F8, 0x02F8, 0x01, 0x08, _Y16) + IRQNoFlags (_Y17) {3} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.SRL1._Y16._MIN, MIN1) + CreateWordField (CRS, \_SB.PCI0.SRL1._Y16._MAX, MAX1) + CreateWordField (CRS, \_SB.PCI0.SRL1._Y17._INT, IRQ1) + Store (SL1B, MIN1) + Store (SL1B, MAX1) + ShiftLeft (0x01, SL1I, IRQ1) + Return (CRS) + } + } + + // Serial port 2 + Device (^SRL2) + { + Name (_HID, EisaId ("PNP0501")) + Name (_UID, 0x03) + Method (_STA, 0, NotSerialized) + { + If (LEqual (SL2B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x03E8, 0x03E8, 0x01, 0x08, _Y22) + IRQNoFlags (_Y23) {3} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.SRL2._Y22._MIN, MIN1) + CreateWordField (CRS, \_SB.PCI0.SRL2._Y22._MAX, MAX1) + CreateWordField (CRS, \_SB.PCI0.SRL2._Y23._INT, IRQ1) + Store (SL2B, MIN1) + Store (SL2B, MAX1) + ShiftLeft (0x01, SL2I, IRQ1) + Return (CRS) + } + } + + // Serial port 3 + Device (^SRL3) + { + Name (_HID, EisaId ("PNP0501")) + Name (_UID, 0x04) + Method (_STA, 0, NotSerialized) + { + If (LEqual (SL3B, Zero)) + { + Return (0x00) + } + Else + { + Return (0x0F) + } + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, 0x02E8, 0x02E8, 0x01, 0x08, _Y24) + IRQNoFlags (_Y25) {3} + }) + Method (_CRS, 0, NotSerialized) + { + CreateWordField (CRS, \_SB.PCI0.SRL3._Y24._MIN, MIN1) + CreateWordField (CRS, \_SB.PCI0.SRL3._Y24._MAX, MAX1) + CreateWordField (CRS, \_SB.PCI0.SRL3._Y25._INT, IRQ1) + Store (SL3B, MIN1) + Store (SL3B, MAX1) + ShiftLeft (0x01, SL3I, IRQ1) + Return (CRS) + } + } + + // Programmable Interval Timer (i8254) + Device (TIMR) + { + Name (_HID, EisaId ("PNP0100")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, + 0x0040, // Range Minimum + 0x0040, // Range Maximum + 0x00, // Alignment + 0x04, // Length + ) + IO (Decode16, + 0x0050, // Range Minimum + 0x0050, // Range Maximum + 0x10, // Alignment + 0x04, // Length + ) + }) + } + + // Programmable Interrupt Controller (i8259) + Device (PIC) + { + Name (_HID, EisaId ("PNP0000")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, + 0x0020, // Range Minimum + 0x0020, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + IO (Decode16, + 0x00A0, // Range Minimum + 0x00A0, // Range Maximum + 0x00, // Alignment + 0x02, // Length + ) + // because in APIC configs PIC connected to pin 0, + // and ISA IRQ0 rerouted to pin 2 + IRQNoFlags () + {2} + }) + } + + + // Real Time Clock and CMOS (MC146818) + Device (RTC) + { + Name (_HID, EisaId ("PNP0B00")) + Name (_CRS, ResourceTemplate () + { + IO (Decode16, + 0x0070, // Range Minimum + 0x0070, // Range Maximum + 0x01, // Alignment + 0x02, // Length + ) + }) + Method (_STA, 0, NotSerialized) + { + Return (URTC) + } + } + + // High Precision Event Timer + Device(HPET) + { + Name (_HID, EISAID("PNP0103")) + Name (_CID, EISAID("PNP0C01")) + Name(_UID, 0) + + Method (_STA, 0, NotSerialized) + { + Return(UHPT) + } + + Name(CRS, ResourceTemplate() + { + IRQNoFlags () + {0} + IRQNoFlags () + {8} + Memory32Fixed (ReadWrite, + 0xFED00000, // Address Base + 0x00000400 // Address Length + ) + }) + + Method (_CRS, 0, NotSerialized) + { + Return (CRS) + } + } + + // AMD IOMMU (AMD-Vi), I/O Virtualization Reporting Structure + Device (IVRS) + { + Method(_ADR, 0, NotSerialized) + { + Return (IOMA) + } + Method (_STA, 0, NotSerialized) + { + if (LEqual (IOMA, Zero)) { + Return (0x00) + } + else { + Return (0x0F) + } + } + } + + // System Management Controller + Device (SMC) + { + Name (_HID, EisaId ("APP0001")) + Name (_CID, "smc-napa") + + Method (_STA, 0, NotSerialized) + { + Return (USMC) + } + Name (CRS, ResourceTemplate () + { + IO (Decode16, + 0x0300, // Range Minimum + 0x0300, // Range Maximum + 0x01, // Alignment + 0x20) // Length + IRQNoFlags () + {6} + + }) + Method (_CRS, 0, NotSerialized) + { + Return (CRS) + } + } + } + + // NVMe controller. Required to convince OS X that + // the controller is an internal (built-in) device. + Device (SSD0) + { + Method(_ADR, 0, NotSerialized) + { + Return (NVMA) + } + Method (_STA, 0, NotSerialized) + { + if (LEqual (NVMA, Zero)) { + Return (0x00) + } + else { + Return (0x0F) + } + } + // Port 0 + Device (PRT0) + { + Name (_ADR, 0xffff) + } + } + + // NIC + Device (GIGE) + { + /** + * Generic NIC, according to + * http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/devids.txt + * Needed by some Windows guests. + */ + Name (_HID, EisaId ("PNP8390")) + + Method(_ADR, 0, NotSerialized) + { + Return (NICA) + } + /* Name (_PRW, Package (0x02) + { + 0x09, + 0x04 + }) */ + + /* Wake up on LAN? */ + /* Method (EWOL, 1, NotSerialized) + { + Return (0x00) + } */ + + Method (_STA, 0, NotSerialized) + { + if (LEqual (NICA, Zero)) { + Return (0x00) + } + else { + Return (0x0F) + } + } + } + + // Graphics device + Device (GFX0) + { + Name (_ADR, 0x00020000) + + // Windows releases older than Windows 8 (starting with Windows 2000) + // get confused by this and lose the monitor device node. One of + // the consequences is that color management is not available. + // For Windows 2000 - Windows 7, disable this device (while keeping + // it enabled for non-Microsoft OSes). + Method (_STA, 0, NotSerialized) + { + If (LAnd (LGreater (MSWN(), 0x00), LLess (MSWN(), 0x08))) + { + Return(0x00) + } + Else + { + Return(0x0F) + } + } + + Scope (\_GPE) + { + // GPE bit 2 handler + // GPE.2 must be set and SCI raised when + // display information changes. + Method (_L02, 0, NotSerialized) + { + Notify (\_SB.PCI0.GFX0, 0x81) + } + } + + Method (_DOS, 1) { } + + Method (_DOD, 0, NotSerialized) + { + Return (Package() + { + 0x80000100 + }) + } + + Device (VGA) + { + Method (_ADR, 0, Serialized) + { + Return (0x0100) + } + } + } + + // HDA Audio card + Device (HDEF) + { + Method(_DSM, 4, NotSerialized) + { + Store (Package (0x04) + { + "layout-id", + Buffer (0x04) + { + /* 04 */ 0x04, 0x00, 0x00, 0x00 + }, + + "PinConfigurations", + Buffer (Zero) {} + }, Local0) + if (LEqual (Arg0, ToUUID("a0b5b7c6-1318-441c-b0c9-fe695eaf949b"))) + { + If (LEqual (Arg1, One)) + { + if (LEqual(Arg2, Zero)) + { + Store (Buffer (0x01) + { + 0x03 + } + , Local0) + Return (Local0) + } + if (LEqual(Arg2, One)) + { + Return (Local0) + } + } + } + Store (Buffer (0x01) + { + 0x0 + } + , Local0) + Return (Local0) + } + + Method(_ADR, 0, NotSerialized) + { + Return (HDAA) + } + + Method (_STA, 0, NotSerialized) + { + if (LEqual (HDAA, Zero)) { + Return (0x00) + } + else { + Return (0x0F) + } + } + } + + + // Control method battery + Device (BAT0) + { + Name (_HID, EisaId ("PNP0C0A")) + Name (_UID, 0x00) + + Scope (\_GPE) + { + // GPE bit 0 handler + // GPE.0 must be set and SCI raised when battery info + // changed. Do NOT re-evaluate _BIF (battery info, never + // changes) but DO re-evaluate _BST (dynamic state). Also + // re-evaluate the AC adapter status. + Method (_L00, 0, NotSerialized) + { + // _BST must be re-evaluated (battery state) + Notify (\_SB.PCI0.BAT0, 0x80) + // _PSR must be re-evaluated (AC adapter status) + Notify (\_SB.PCI0.AC, 0x80) + } + } + + OperationRegion (CBAT, SystemIO, 0x4040, 0x08) + Field (CBAT, DwordAcc, NoLock, Preserve) + { + IDX0, 32, + DAT0, 32, + } + + IndexField (IDX0, DAT0, DwordAcc, NoLock, Preserve) + { + STAT, 32, + PRAT, 32, + RCAP, 32, + PVOL, 32, + + UNIT, 32, + DCAP, 32, + LFCP, 32, + BTEC, 32, + DVOL, 32, + DWRN, 32, + DLOW, 32, + GRN1, 32, + GRN2, 32, + + BSTA, 32, + APSR, 32, + } + + Method (_STA, 0, NotSerialized) + { + return (BSTA) + } + + Name (PBIF, Package () + { + 0x01, // Power unit, 1 - mA + 0x7fffffff, // Design capacity + 0x7fffffff, // Last full charge capacity + 0x00, // Battery technology + 0xffffffff, // Design voltage + 0x00, // Design capacity of Warning + 0x00, // Design capacity of Low + 0x04, // Battery capacity granularity 1 + 0x04, // Battery capacity granularity 2 + "1", // Model number + "0", // Serial number + "VBOX", // Battery type + "innotek" // OEM Information + }) + + Name (PBST, Package () { + 0, // Battery state + 0x7fffffff, // Battery present rate + 0x7fffffff, // Battery remaining capacity + 0x7fffffff // Battery present voltage + }) + + // Battery information + Method (_BIF, 0, NotSerialized) + { + Store (UNIT, Index (PBIF, 0,)) + Store (DCAP, Index (PBIF, 1,)) + Store (LFCP, Index (PBIF, 2,)) + Store (BTEC, Index (PBIF, 3,)) + Store (DVOL, Index (PBIF, 4,)) + Store (DWRN, Index (PBIF, 5,)) + Store (DLOW, Index (PBIF, 6,)) + Store (GRN1, Index (PBIF, 7,)) + Store (GRN2, Index (PBIF, 8,)) + + DBG ("_BIF:\n") + HEX4 (DerefOf (Index (PBIF, 0,))) + HEX4 (DerefOf (Index (PBIF, 1,))) + HEX4 (DerefOf (Index (PBIF, 2,))) + HEX4 (DerefOf (Index (PBIF, 3,))) + HEX4 (DerefOf (Index (PBIF, 4,))) + HEX4 (DerefOf (Index (PBIF, 5,))) + HEX4 (DerefOf (Index (PBIF, 6,))) + HEX4 (DerefOf (Index (PBIF, 7,))) + HEX4 (DerefOf (Index (PBIF, 8,))) + + return (PBIF) + } + + // Battery status + Method (_BST, 0, NotSerialized) + { + Store (STAT, Index (PBST, 0,)) + Store (PRAT, Index (PBST, 1,)) + Store (RCAP, Index (PBST, 2,)) + Store (PVOL, Index (PBST, 3,)) +/* + DBG ("_BST:\n") + HEX4 (DerefOf (Index (PBST, 0,))) + HEX4 (DerefOf (Index (PBST, 1,))) + HEX4 (DerefOf (Index (PBST, 2,))) + HEX4 (DerefOf (Index (PBST, 3,))) +*/ + return (PBST) + } + } + + Device (AC) + { + Name (_HID, "ACPI0003") + Name (_UID, 0x00) + Name (_PCL, Package (0x01) + { + \_SB + }) + + Method (_PSR, 0, NotSerialized) + { + // DBG ("_PSR:\n") + // HEX4 (\_SB.PCI0.BAT0.APSR) + return (\_SB.PCI0.BAT0.APSR) + } + + Method (_STA, 0, NotSerialized) + { + return (0x0f) + } + } + } + } + + Scope (\_SB) + { + Scope (PCI0) + { + // PCI0 current resource settings + Name (CRS, ResourceTemplate () + { + WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode, + 0x0000, + 0x0000, + 0x00FF, + 0x0000, + 0x0100) + IO (Decode16, 0x0CF8, 0x0CF8, 0x01, 0x08) + WordIO (ResourceProducer, MinFixed, MaxFixed, + PosDecode, EntireRange, + 0x0000, + 0x0000, + 0x0CF7, + 0x0000, + 0x0CF8) + WordIO (ResourceProducer, MinFixed, MaxFixed, + PosDecode, EntireRange, + 0x0000, + 0x0D00, + 0xFFFF, + 0x0000, + 0xF300) + + /* Taken from ACPI faq (with some modifications) */ + DwordMemory( // descriptor for video RAM behind ISA bus + ResourceProducer, // bit 0 of general flags is 0 + PosDecode, + MinFixed, // Range is fixed + MaxFixed, // Range is Fixed + Cacheable, + ReadWrite, + 0x00000000, // Granularity + 0x000a0000, // Min + 0x000bffff, // Max + 0x00000000, // Translation + 0x00020000 // Range Length + ) + + DwordMemory( // Consumed-and-produced resource + // (all of low memory space) + ResourceProducer, // bit 0 of general flags is 0 + PosDecode, // positive Decode + MinFixed, // Range is fixed + MaxFixed, // Range is fixed + Cacheable, + ReadWrite, + 0x00000000, // Granularity + 0xe0000000, // Min (calculated dynamically) + + 0xfdffffff, // Max = 4GB - 32MB + 0x00000000, // Translation + 0x1e000000, // Range Length (calculated + // dynamically) + , // Optional field left blank + , // Optional field left blank + MEM3 // Name declaration for this + // descriptor + ) + }) + + Name (TOM, ResourceTemplate () + { + QwordMemory( + ResourceProducer, // bit 0 of general flags is 0 + PosDecode, // positive Decode + MinFixed, // Range is fixed + MaxFixed, // Range is fixed + Prefetchable, + ReadWrite, + 0x0000000000000000, // _GRA: Granularity. + 0x0000000100000000, // _MIN: Min address, def. 4GB, will be overwritten. + 0x0000000fffffffff, // _MAX: Max address, def. 64GB-1, will be overwritten. + 0x0000000000000000, // _TRA: Translation + 0x0000000f00000000, // _LEN: Range length (_MAX-_MIN+1) + , // ResourceSourceIndex: Optional field left blank + , // ResourceSource: Optional field left blank + MEM4 // Name declaration for this descriptor. + ) + }) + + Method (_CRS, 0, NotSerialized) + { + CreateDwordField (CRS, \_SB.PCI0.MEM3._MIN, RAMT) + CreateDwordField (CRS, \_SB.PCI0.MEM3._LEN, RAMR) + + Store (MEML, RAMT) + Subtract (0xfe000000, RAMT, RAMR) + + if (LNotEqual (PMNN, 0x00000000)) + { + // Not for Windows < 7! + If (LOr (LLess (MSWN(), 0x01), LGreater (MSWN(), 0x06))) + { + CreateQwordField (TOM, \_SB.PCI0.MEM4._MIN, TM4N) + CreateQwordField (TOM, \_SB.PCI0.MEM4._MAX, TM4X) + CreateQwordField (TOM, \_SB.PCI0.MEM4._LEN, TM4L) + + Multiply (PMNN, 0x10000, TM4N) // PMNN in units of 64KB + Subtract (Multiply (PMNX, 0x10000), 1, TM4X) // PMNX in units of 64KB + Add (Subtract (TM4X, TM4N), 1, TM4L) // determine LEN, MAX is already there + + ConcatenateResTemplate (CRS, TOM, Local2) + + Return (Local2) + } + } + + Return (CRS) + } + + /* Defined in PCI Firmware Specification 3.0 and ACPI 3.0, with both specs + * referencing each other. The _OSC method must be present to make Linux happy, + * but needs to prevent the OS from taking much control so as to not upset Windows. + * NB: The first DWORD is defined in the ACPI spec but not the PCI FW spec. + */ + Method (_OSC, 4) + { + Name(SUPP, 0) // Support field value + Name(CTRL, 0) // Control field value + + // Break down the input capabilities buffer into individual DWORDs + CreateDWordField(Arg3, 0, CDW1) + CreateDWordField(Arg3, 4, CDW2) + CreateDWordField(Arg3, 8, CDW3) + + If (LEqual (Arg0, ToUUID("33db4d5b-1ff7-401c-9657-7441c03dd766"))) + { + // Stash the Support and Control fields + Store(CDW2, SUPP) + Store(CDW3, CTRL) + + DBG("_OSC: SUPP=") + HEX4(SUPP) + DBG(" CTRL=") + HEX4(CTRL) + DBG("\n") + + // Mask off the PCI Express Capability Structure control + // Not emulated well enough to satisfy Windows (Vista and later) + And(CTRL, 0x0F, CTRL) + + // If capabilities were masked, set the Capabilities Masked flag (bit 4) + If (LNotEqual(CDW3, CTRL)) + { + Or(CDW1, 0x10, CDW1) + } + + // Update the Control field and return + Store(CTRL, CDW3) + Return(Arg3) + } + Else + { + // UUID not known, set Unrecognized UUID flag (bit 2) + Or(CDW1, 0x04, CDW1) + Return(Arg3) + } + } + } + } + + Scope (\_SB) + { + // Fields within PIIX3 configuration[0x60..0x63] with + // IRQ mappings + Field (\_SB.PCI0.SBRG.PCIC, ByteAcc, NoLock, Preserve) + { + Offset (0x60), + PIRA, 8, + PIRB, 8, + PIRC, 8, + PIRD, 8 + } + + Name (BUFA, ResourceTemplate () + { + IRQ (Level, ActiveLow, Shared) {15} + }) + CreateWordField (BUFA, 0x01, ICRS) + + // Generic status of IRQ routing entry + Method (LSTA, 1, NotSerialized) + { + And (Arg0, 0x80, Local0) +// DBG ("LSTA: ") +// HEX (Arg0) + If (Local0) + { + Return (0x09) + } + Else + { + Return (0x0B) + } + } + + // Generic "current resource settings" for routing entry + Method (LCRS, 1, NotSerialized) + { + And (Arg0, 0x0F, Local0) + ShiftLeft (0x01, Local0, ICRS) +// DBG ("LCRS: ") +// HEX (ICRS) + Return (BUFA) + } + + // Generic "set resource settings" for routing entry + Method (LSRS, 1, NotSerialized) + { + CreateWordField (Arg0, 0x01, ISRS) + FindSetRightBit (ISRS, Local0) + Return (Decrement (Local0)) + } + + // Generic "disable" for routing entry + Method (LDIS, 1, NotSerialized) + { + Return (Or (Arg0, 0x80)) + } + + // Link A + Device (LNKA) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x01) + + // Status + Method (_STA, 0, NotSerialized) + { + DBG ("LNKA._STA\n") + Return (LSTA (PIRA)) + } + + // Possible resource settings + Method (_PRS, 0, NotSerialized) + { + DBG ("LNKA._PRS\n") + Return (PRSA) + } + + // Disable + Method (_DIS, 0, NotSerialized) + { + DBG ("LNKA._DIS\n") + Store (LDIS (PIRA), PIRA) + } + + // Current resource settings + Method (_CRS, 0, NotSerialized) + { + DBG ("LNKA._CRS\n") + Return (LCRS (PIRA)) + } + + // Set resource settings + Method (_SRS, 1, NotSerialized) + { + DBG ("LNKA._SRS: ") + HEX (LSRS (Arg0)) + Store (LSRS (Arg0), PIRA) + } + } + + // Link B + Device (LNKB) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x02) + Method (_STA, 0, NotSerialized) + { + // DBG ("LNKB._STA\n") + Return (LSTA (PIRB)) + } + + Method (_PRS, 0, NotSerialized) + { + // DBG ("LNKB._PRS\n") + Return (PRSB) + } + + Method (_DIS, 0, NotSerialized) + { + // DBG ("LNKB._DIS\n") + Store (LDIS (PIRB), PIRB) + } + + Method (_CRS, 0, NotSerialized) + { + // DBG ("LNKB._CRS\n") + Return (LCRS (PIRB)) + } + + Method (_SRS, 1, NotSerialized) + { + DBG ("LNKB._SRS: ") + HEX (LSRS (Arg0)) + Store (LSRS (Arg0), PIRB) + } + } + + // Link C + Device (LNKC) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x03) + Method (_STA, 0, NotSerialized) + { + // DBG ("LNKC._STA\n") + Return (LSTA (PIRC)) + } + + Method (_PRS, 0, NotSerialized) + { + // DBG ("LNKC._PRS\n") + Return (PRSC) + } + + Method (_DIS, 0, NotSerialized) + { + // DBG ("LNKC._DIS\n") + Store (LDIS (PIRC), PIRC) + } + + Method (_CRS, 0, NotSerialized) + { + // DBG ("LNKC._CRS\n") + Return (LCRS (PIRC)) + } + + Method (_SRS, 1, NotSerialized) + { + DBG ("LNKC._SRS: ") + HEX (LSRS (Arg0)) + Store (LSRS (Arg0), PIRC) + } + } + + // Link D + Device (LNKD) + { + Name (_HID, EisaId ("PNP0C0F")) + Name (_UID, 0x04) + Method (_STA, 0, NotSerialized) + { + // DBG ("LNKD._STA\n") + Return (LSTA (PIRD)) + } + + Method (_PRS, 0, NotSerialized) + { + // DBG ("LNKD._PRS\n") + Return (PRSD) + } + + Method (_DIS, 0, NotSerialized) + { + // DBG ("LNKD._DIS\n") + Store (LDIS (PIRA), PIRD) + } + + Method (_CRS, 0, NotSerialized) + { + // DBG ("LNKD._CRS\n") + Return (LCRS (PIRD)) + } + + Method (_SRS, 1, NotSerialized) + { + DBG ("LNKD._SRS: ") + HEX (LSRS (Arg0)) + Store (LSRS (Arg0), PIRD) + } + } + } + + // Sx states + Name (_S0, Package (2) { + 0x00, + 0x00, + }) + + // Shift one by the power state number + If (And(PWRS, ShiftLeft(One,1))) { + Name (_S1, Package (2) { + 0x01, + 0x01, + }) + } + + If (And(PWRS, ShiftLeft(One,4))) { + Name (_S4, Package (2) { + 0x05, + 0x05, + }) + } + + Name (_S5, Package (2) { + 0x05, + 0x05, + }) + + Method (_PTS, 1, NotSerialized) + { + DBG ("Prepare to sleep: ") + HEX (Arg0) + } +} + +/* + * Local Variables: + * comment-start: "//" + * End: + */ -- cgit v1.2.3