From 8ea9ca8b19d64bb4314f02b9000ef15d1be9dd4b Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Fri, 10 Jun 2022 22:22:13 +0200 Subject: [PATCH 01/35] Update ACPI parsing --- source/Cosmos.Core/ACPI.cs | 426 +++++++++++++++++-------------------- 1 file changed, 197 insertions(+), 229 deletions(-) diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index abec288da9..f69aa38984 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -2,6 +2,7 @@ using Cosmos.Debug.Kernel; using System; using System.Runtime.InteropServices; +using System.Text; namespace Cosmos.Core { @@ -26,24 +27,147 @@ public unsafe struct RSDPtr /// Signature. /// public fixed byte Signature[8]; + /// /// CheckSum /// public byte CheckSum; + /// /// OemID /// public fixed byte OemID[6]; + /// /// Revision /// public byte Revision; + /// /// RSDT Address /// public int RsdtAddress; }; + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct AcpiHeader + { + /// + /// Signature. + /// + public fixed byte Signature[4]; + + /// + /// Length. + /// + public uint Length; + + /// + /// Revision. + /// + public byte Revision; + + /// + /// Checksum. + /// + public byte Checksum; + + /// + /// OEM ID. + /// + public fixed byte OEMID[6]; + + /// + /// OEM Table ID. + /// + public fixed byte OEMTableID[8]; + + /// + /// OEM Revision. + /// + public uint OEMRevision; + + /// + /// CreatorID. + /// + public uint CreatorID; + + /// + /// Creator Revision. + /// + public uint CreatorRevision; + }; + + /// + /// FADT struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + private struct FADTPtr + { + /// + /// ACPI Header. + /// + public AcpiHeader Header; + + /// + /// Firmware Control. + /// + public uint FirmwareCtrl; + + /// + /// DSDT Signature. + /// + public uint Dsdt; + + public byte Reserved; + public byte PreferredPowerManagementProfile; + public ushort SCI_Interrupt; + public uint SMI_CommandPort; + + /// + /// ACPI Enable. + /// + public byte AcpiEnable; + + /// + /// ACPI Disable. + /// + public byte AcpiDisable; + + public byte S4BIOS_REQ; + public byte PSTATE_Control; + public uint PM1aEventBlock; + public uint PM1bEventBlock; + public uint PM1aControlBlock; + public uint PM1bControlBlock; + public uint PM2ControlBlock; + public uint PMTimerBlock; + public uint GPE0Block; + public uint GPE1Block; + public byte PM1EventLength; + public byte PM1ControlLength; + public byte PM2ControlLength; + public byte PMTimerLength; + public byte GPE0Length; + public byte GPE1Length; + public byte GPE1Base; + public byte CStateControl; + public ushort WorstC2Latency; + public ushort WorstC3Latency; + public ushort FlushSize; + public ushort FlushStride; + public byte DutyOffset; + public byte DutyWidth; + public byte DayAlarm; + public byte MonthAlarm; + public byte Century; + + public ushort BootArchitectureFlags; + + public byte Reserved2; + public uint Flags; + } + // New Port I/O /// /// IO port. @@ -99,71 +223,6 @@ static int acpiCheckHeader(byte* ptr, string sig) return Compare(sig, ptr); } - /// - /// FACP. - /// - private static byte* Facp = null; - /// - /// FACP struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - struct FACP - { - /// - /// Signature. - /// - public fixed byte Signature[4]; - /// - /// Length. - /// - public int Length; - - /// - /// Unused. - /// - public fixed byte unneded1[40 - 8]; - /// - /// DSDT. - /// - public int* DSDT; - /// - /// Unused. - /// - public fixed byte unneded2[48 - 44]; - /// - /// SMI CMD. - /// - public int* SMI_CMD; - /// - /// ACPI ENABLE. - /// - public byte ACPI_ENABLE; - /// - /// ACPI DISABLE. - /// - public byte ACPI_DISABLE; - /// - /// Unused. - /// - public fixed byte unneded3[64 - 54]; - /// - /// PM1a CNT BLK. - /// - public int* PM1a_CNT_BLK; - /// - /// PM1b CNT BLK. - /// - public int* PM1b_CNT_BLK; - /// - /// Unused. - /// - public fixed byte unneded4[89 - 72]; - /// - /// PM1 CNT LEN. - /// - public byte PM1_CNT_LEN; - }; - /// /// Compare string to byte array. /// @@ -253,98 +312,102 @@ public static void Reboot() /// true on success, false on failure. private static bool Init() { - byte* ptr = (byte*)RSDPAddress(); - int addr = 0; + var rsdp = RSDPAddress(); + byte* ptr = (byte*)rsdp; - for (int i = 19; i >= 16; i--) - { - addr += (*(ptr + i)); - addr = (i == 16) ? addr : addr << 8; - } + Global.mDebugger.Send("ACPI v" + rsdp->Revision); + + var rsdt = (AcpiHeader*)rsdp->RsdtAddress; + ptr = (byte*)rsdt; - ptr = (byte*)addr; - ptr += 4; addr = 0; + uint* p = (uint*)(rsdt + 1); + uint* end = (uint*)((byte*)rsdt + rsdt->Length); - for (int i = 3; i >= 0; i--) + while (p < end) { - addr += (*(ptr + i)); - addr = (i == 0) ? addr : addr << 8; + uint address = *p++; + + if (ParseDT((AcpiHeader*)address) == false) + { + return false; + } } - int length = addr; - ptr -= 4; + return true; + } + + private static bool ParseDT(AcpiHeader *header) + { + var signature = Encoding.ASCII.GetString(header->Signature, 4); - if (ptr != null && acpiCheckHeader(ptr, "RSDT") == 0) + Global.mDebugger.Send(signature + "detected"); + + if (signature == "FACP") { - addr = 0; - int entrys = length; - entrys = (entrys - 36) / 4; - ptr += 36; - byte* yeuse; + Global.mDebugger.Send("Parse FACP"); + + var Fadt = (FADTPtr*)header; - while (0 < entrys--) + if (acpiCheckHeader((byte*)Fadt->Dsdt, "DSDT") == 0) { - for (int i = 3; i >= 0; i--) + byte* S5Addr = (byte*)Fadt->Dsdt + sizeof(AcpiHeader); + int dsdtLength = *((int*)Fadt->Dsdt + 1) - sizeof(AcpiHeader); + + while (0 < dsdtLength--) { - addr += (*(ptr + i)); - addr = (i == 0) ? addr : addr << 8; + if (Compare("_S5_", S5Addr) == 0) + { + break; + } + S5Addr++; } - yeuse = (byte*)addr; - Facp = yeuse; - - if (acpiCheckHeader((byte*)facpget(0), "DSDT") == 0) + if (dsdtLength > 0) { - byte* S5Addr = (byte*)facpget(0) + 36; - int dsdtLength = *(facpget(0) + 1) - 36; - - while (0 < dsdtLength--) + if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) { - if (Compare("_S5_", S5Addr) == 0) + S5Addr += 5; + S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; + if (*S5Addr == 0x0A) { - break; + S5Addr++; } + SLP_TYPa = (short)(*(S5Addr) << 10); S5Addr++; - } - - if (dsdtLength > 0) - { - if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) + if (*S5Addr == 0x0A) { - S5Addr += 5; - S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPa = (short)(*(S5Addr) << 10); S5Addr++; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPb = (short)(*(S5Addr) << 10); - SMI_CMD = facpget(1); - ACPI_ENABLE = facpbget(0); - ACPI_DISABLE = facpbget(1); - PM1a_CNT = facpget(2); - PM1b_CNT = facpget(3); - PM1_CNT_LEN = facpbget(3); - SLP_EN = 1 << 13; - - smiIO = new IOPort((ushort)SMI_CMD); - pm1aIO = new IOPort((ushort)PM1a_CNT); - pm1bIO = new IOPort((ushort)PM1b_CNT); - - return true; } + SLP_TYPb = (short)(*(S5Addr) << 10); + SMI_CMD = (int*)Fadt->SMI_CommandPort; + ACPI_ENABLE = Fadt->AcpiEnable; + ACPI_DISABLE = Fadt->AcpiDisable; + PM1a_CNT = (int*)Fadt->PM1aControlBlock; + PM1b_CNT = (int*)Fadt->PM1bControlBlock; + PM1_CNT_LEN = Fadt->PM1ControlLength; + SLP_EN = 1 << 13; + + smiIO = new IOPort((ushort)SMI_CMD); + pm1aIO = new IOPort((ushort)PM1a_CNT); + pm1bIO = new IOPort((ushort)PM1b_CNT); + + return true; } } - ptr += 4; } + + return false; } + else if (signature == "APIC") + { + Global.mDebugger.Send("Parse APIC"); - return false; + return true; + } + else + { + return true; + } } /// @@ -367,7 +430,7 @@ public static void Disable() /// Get the RSDP address. /// /// uint value. - private static unsafe uint RSDPAddress() + private static unsafe RSDPtr *RSDPAddress() { for (uint addr = 0xE0000; addr < 0x100000; addr += 4) { @@ -375,7 +438,7 @@ private static unsafe uint RSDPAddress() { if (Check_RSD(addr)) { - return addr; + return (RSDPtr*)addr; } } } @@ -387,106 +450,11 @@ private static unsafe uint RSDPAddress() { if (Compare("RSD PTR ", (byte*)addr) == 0) { - return addr; - } - } - - return 0; - } - - /// - /// Check RSDT table - /// - /// A pointer to the RSDT - /// RSDT table address - private static uint* acpiCheckRSDPtr(uint* ptr) - { - string sig = "RSD PTR "; - var rsdp = (RSDPtr*)ptr; - - byte* bptr; - byte check = 0; - int i; - - if (Compare(sig, (byte*)rsdp) == 0) - { - bptr = (byte*)ptr; - - for (i = 0; i < 20; i++) - { - check += *bptr; - bptr++; - } - - if (check == 0) - { - Compare("RSDT", (byte*)rsdp->RsdtAddress); - - if (rsdp->RsdtAddress != 0) - { - return (uint*)rsdp->RsdtAddress; - } + return (RSDPtr*)addr; } } return null; } - - /// - /// Get data from the FACP table. - /// - /// Index number of the data to get. - /// - /// 0 - ACPI ENABLE - /// 1 - ACPI DISABLE - /// 2 - PM1 CNT LEN - /// other - 0 - /// - /// - /// byte value. - private static byte facpbget(int number) - { - switch (number) - { - case 0: - return *(Facp + 52); - case 1: - return *(Facp + 53); - case 2: - return *(Facp + 89); - default: - return 0; - } - } - - /// - /// Get pointer to the data on the FACP. - /// - /// Index number of the data to get. - /// - /// 0 - DSDT - /// 1 - SMI CMD - /// 2 - PM1a - /// 3 - PM1b - /// other - null - /// - /// - /// int pointer. - private static int* facpget(int number) - { - switch (number) - { - case 0: - return (int*)*((int*)(Facp + 40)); - case 1: - return (int*)*((int*)(Facp + 48)); - case 2: - return (int*)*((int*)(Facp + 64)); - case 3: - return (int*)*((int*)(Facp + 68)); - default: - return null; - } - } } } From c2feeee31d80ddc32a8b70e832ba54b48abe3ff7 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Fri, 10 Jun 2022 23:52:55 +0200 Subject: [PATCH 02/35] Parse local APIC + Add Local APIC class --- source/Cosmos.Core/ACPI.cs | 140 +++++++++++++++++++++++++---- source/Cosmos.Core/APIC.cs | 85 ++++++++++++++++++ source/Cosmos.Core/IOGroup/APIC.cs | 110 +++++++++++++++++++++++ 3 files changed, 318 insertions(+), 17 deletions(-) create mode 100644 source/Cosmos.Core/APIC.cs create mode 100644 source/Cosmos.Core/IOGroup/APIC.cs diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index f69aa38984..fcc9f0e929 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -1,6 +1,7 @@ using Cosmos.Core; using Cosmos.Debug.Kernel; using System; +using System.Collections.Generic; using System.Runtime.InteropServices; using System.Text; @@ -168,6 +169,82 @@ private struct FADTPtr public uint Flags; } + /// + /// MADT struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct MADTPtr + { + /// + /// ACPI Header. + /// + public AcpiHeader Header; + + /// + /// Local APIC Address. + /// + public uint LocalAPICAddress; + + /// + /// Flags. + /// + public uint Flags; + } + + /// + /// APIC Header struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ApicHeader + { + /// + /// APIC Type. + /// + public ApicType Type; + + /// + /// Length. + /// + public byte Length; + } + + /// + /// APIC Type enum. + /// + public enum ApicType : byte + { + LocalAPIC, + IOAPIC, + InterruptOverride + } + + /// + /// ApicLocalApic struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + struct ApicLocalApic + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// ACPI Processor ID. + /// + public byte AcpiProcessorId; + + /// + /// APIC ID. + /// + public byte ApicId; + + /// + /// APIC Flags. + /// + public uint Flags; + } + // New Port I/O /// /// IO port. @@ -211,6 +288,14 @@ private struct FADTPtr /// PM1 CNT LEN1 /// private static byte PM1_CNT_LEN; + /// + /// Global MADT. + /// + public static MADTPtr* MADT; + /// + /// Local APIC CPUID list. + /// + public static List LocalAPIC_CPUIDs; /// /// Check ACPI header. @@ -312,6 +397,8 @@ public static void Reboot() /// true on success, false on failure. private static bool Init() { + LocalAPIC_CPUIDs = new List(); + var rsdp = RSDPAddress(); byte* ptr = (byte*)rsdp; @@ -327,18 +414,15 @@ private static bool Init() { uint address = *p++; - if (ParseDT((AcpiHeader*)address) == false) - { - return false; - } + ParseDT((AcpiHeader*)address); } return true; } - private static bool ParseDT(AcpiHeader *header) + private static void ParseDT(AcpiHeader *hdr) { - var signature = Encoding.ASCII.GetString(header->Signature, 4); + var signature = Encoding.ASCII.GetString(hdr->Signature, 4); Global.mDebugger.Send(signature + "detected"); @@ -346,7 +430,7 @@ private static bool ParseDT(AcpiHeader *header) { Global.mDebugger.Send("Parse FACP"); - var Fadt = (FADTPtr*)header; + var Fadt = (FADTPtr*)hdr; if (acpiCheckHeader((byte*)Fadt->Dsdt, "DSDT") == 0) { @@ -390,23 +474,45 @@ private static bool ParseDT(AcpiHeader *header) smiIO = new IOPort((ushort)SMI_CMD); pm1aIO = new IOPort((ushort)PM1a_CNT); pm1bIO = new IOPort((ushort)PM1b_CNT); - - return true; } } } - - return false; } else if (signature == "APIC") { - Global.mDebugger.Send("Parse APIC"); + Global.mDebugger.Send("Parse ACPI"); - return true; - } - else - { - return true; + MADT = (MADTPtr*)hdr; + + byte* p = (byte*)(MADT + 1); + byte* end = (byte*)MADT + MADT->Header.Length; + while (p < end) + { + var header = (ApicHeader*)p; + var type = header->Type; + byte length = header->Length; + + if (type == ApicType.LocalAPIC) + { + Global.mDebugger.Send("Parse local APIC"); + + var pic = (ApicLocalApic*)p; + if (((pic->Flags & 1) ^ ((pic->Flags >> 1) & 1)) == 1) + { + LocalAPIC_CPUIDs.Add(pic->ApicId); + } + } + else if (type == ApicType.IOAPIC) + { + Console.WriteLine("IO APIC not implemented."); + } + else if (type == ApicType.InterruptOverride) + { + Console.WriteLine("InterruptOverride not implemented."); + } + + p += length; + } } } diff --git a/source/Cosmos.Core/APIC.cs b/source/Cosmos.Core/APIC.cs new file mode 100644 index 0000000000..b903aa86cc --- /dev/null +++ b/source/Cosmos.Core/APIC.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Cosmos.Core.IOGroup; + +namespace Cosmos.Core +{ + /// + /// Local APIC class. + /// + public unsafe partial class LocalAPIC + { + /// + /// Local APIC IO group. + /// + protected APICIOGroup IO; + + /// + /// End of Interrupt. + /// + public void EndOfInterrupt() + { + IO.EndOfInterrupts.DWord = 0; + } + + /// + /// Initialize local APIC. + /// + public void Initialize() + { + //PIC.Disable(); TODO + + IO = new APICIOGroup((ushort)ACPI.MADT->LocalAPICAddress); + + //Enable All Interrupts + IO.Tpr.DWord = 0; + + // Logical Destination Mode + IO.Tpr.DWord = 0xffffffff; // Flat mode + IO.Ldr.DWord = 0 << 24; // All cpus use logical id 0 + + // Configure Spurious Interrupt Vector Register + IO.Svr.DWord = 0x100 | 0xff; + + Console.WriteLine("Local APIC initialized"); + } + + /// + /// Get Local APIC ID. + /// + /// integer value. + public uint GetId() + { + return IO.Id.DWord >> 24; + } + + /// + /// Send Init Command to Local APIC. + /// + /// APIC ID. + public void SendInit(uint apic_id) + { + IO.ICRHI.DWord = apic_id << IO.ICR_DESTINATION_SHIFT; + IO.ICRLO.DWord = (uint)(IO.ICR_INIT | IO.ICR_PHYSICAL | IO.ICR_ASSERT | IO.ICR_EDGE | IO.ICR_NO_SHORTHAND); + + while ((IO.ICRLO.DWord & IO.ICR_SEND_PENDING) != 0) { } + } + + + /// + /// Send Startup Command to Local APIC. + /// + /// APIC ID. + /// Vector. + public void SendStartup(uint apic_id, ushort vector) + { + IO.ICRHI.DWord = apic_id << IO.ICR_DESTINATION_SHIFT; + IO.ICRLO.DWord = (uint)(vector | IO.ICR_STARTUP | IO.ICR_PHYSICAL | IO.ICR_ASSERT | IO.ICR_EDGE | IO.ICR_NO_SHORTHAND); + + while ((IO.ICRLO.DWord & IO.ICR_SEND_PENDING) != 0) { } + } + } +} diff --git a/source/Cosmos.Core/IOGroup/APIC.cs b/source/Cosmos.Core/IOGroup/APIC.cs new file mode 100644 index 0000000000..92236af150 --- /dev/null +++ b/source/Cosmos.Core/IOGroup/APIC.cs @@ -0,0 +1,110 @@ +using Cosmos.Core; + +namespace Cosmos.Core.IOGroup +{ + /// + /// Local APIC IOGroup class. + /// + public class APICIOGroup : IOGroup + { + public const ushort LAPIC_ID = 0x0020; + public const ushort LAPIC_VER = 0x0030; + public const ushort LAPIC_TPR = 0x0080; + public const ushort LAPIC_APR = 0x0090; + public const ushort LAPIC_PPR = 0x00a0; + public const ushort LAPIC_EOI = 0x00b0; + public const ushort LAPIC_RRD = 0x00c0; + public const ushort LAPIC_LDR = 0x00d0; + public const ushort LAPIC_DFR = 0x00e0; + public const ushort LAPIC_SVR = 0x00f0; + public const ushort LAPIC_ISR = 0x0100; + public const ushort LAPIC_TMR = 0x0180; + public const ushort LAPIC_IRR = 0x0200; + public const ushort LAPIC_ESR = 0x0280; + public const ushort LAPIC_ICRLO = 0x0300; + public const ushort LAPIC_ICRHI = 0x0310; + public const ushort LAPIC_TIMER = 0x0320; + public const ushort LAPIC_THERMAL = 0x0330; + public const ushort LAPIC_PERF = 0x0340; + public const ushort LAPIC_LINT0 = 0x0350; + public const ushort LAPIC_LINT1 = 0x0360; + public const ushort LAPIC_ERROR = 0x0370; + public const ushort LAPIC_TICR = 0x0380; + public const ushort LAPIC_TCCR = 0x0390; + public const ushort LAPIC_TDCR = 0x03e0; + + public const ushort ICR_FIXED = 0x00000000; + public const ushort ICR_LOWEST = 0x00000100; + public const ushort ICR_SMI = 0x00000200; + public const ushort ICR_NMI = 0x00000400; + public const ushort ICR_INIT = 0x00000500; + public const ushort ICR_STARTUP = 0x00000600; + + public const ushort ICR_PHYSICAL = 0x00000000; + public const ushort ICR_LOGICAL = 0x00000800; + + public const ushort ICR_IDLE = 0x00000000; + public const ushort ICR_SEND_PENDING = 0x00001000; + + public const ushort ICR_DEASSERT = 0x00000000; + public const ushort ICR_ASSERT = 0x00004000; + + public const ushort ICR_EDGE = 0x00000000; + public const ushort ICR_LEVEL = 0x00008000; + + public const int ICR_NO_SHORTHAND = 0x00000000; + public const int ICR_SELF = 0x00040000; + public const int ICR_ALL_INCLUDING_SELF = 0x00080000; + public const int ICR_ALL_EXCLUDING_SELF = 0x000c0000; + + public const int ICR_DESTINATION_SHIFT = 24; + + /// + /// Id port. + /// + public readonly IOPort Id; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort EndOfInterrupts; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort Tpr; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort Dfr; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort Ldr; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort Svr; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort ICRHI; + /// + /// EndOfInterrupts port. + /// + public readonly IOPort ICRLO; + + /// + /// Create new instance of the class. + /// + internal APICIOGroup(ushort baseAddress) + { + Id = new IOPort(baseAddress, LAPIC_ID); + EndOfInterrupts = new IOPort(baseAddress, LAPIC_EOI); + Tpr = new IOPort(baseAddress, LAPIC_TPR); + Dfr = new IOPort(baseAddress, LAPIC_DFR); + Ldr = new IOPort(baseAddress, LAPIC_LDR); + Svr = new IOPort(baseAddress, LAPIC_SVR); + ICRHI = new IOPort(baseAddress, LAPIC_ICRHI); + ICRLO = new IOPort(baseAddress, LAPIC_ICRLO); + } + } +} From 8b021bd1c1f76e1517a75dc180b224ba77625130 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 00:12:52 +0200 Subject: [PATCH 03/35] Add local APIC timer --- source/Cosmos.Core/APIC.cs | 14 +++---- source/Cosmos.Core/IOGroup/APICTimer.cs | 38 +++++++++++++++++ source/Cosmos.Core/LocalAPICTimer.cs | 54 +++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 7 deletions(-) create mode 100644 source/Cosmos.Core/IOGroup/APICTimer.cs create mode 100644 source/Cosmos.Core/LocalAPICTimer.cs diff --git a/source/Cosmos.Core/APIC.cs b/source/Cosmos.Core/APIC.cs index b903aa86cc..5d9654d302 100644 --- a/source/Cosmos.Core/APIC.cs +++ b/source/Cosmos.Core/APIC.cs @@ -15,7 +15,7 @@ public unsafe partial class LocalAPIC /// /// Local APIC IO group. /// - protected APICIOGroup IO; + internal APICIOGroup IO; /// /// End of Interrupt. @@ -62,10 +62,10 @@ public uint GetId() /// APIC ID. public void SendInit(uint apic_id) { - IO.ICRHI.DWord = apic_id << IO.ICR_DESTINATION_SHIFT; - IO.ICRLO.DWord = (uint)(IO.ICR_INIT | IO.ICR_PHYSICAL | IO.ICR_ASSERT | IO.ICR_EDGE | IO.ICR_NO_SHORTHAND); + IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; + IO.ICRLO.DWord = (uint)(APICIOGroup.ICR_INIT | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); - while ((IO.ICRLO.DWord & IO.ICR_SEND_PENDING) != 0) { } + while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } } @@ -76,10 +76,10 @@ public void SendInit(uint apic_id) /// Vector. public void SendStartup(uint apic_id, ushort vector) { - IO.ICRHI.DWord = apic_id << IO.ICR_DESTINATION_SHIFT; - IO.ICRLO.DWord = (uint)(vector | IO.ICR_STARTUP | IO.ICR_PHYSICAL | IO.ICR_ASSERT | IO.ICR_EDGE | IO.ICR_NO_SHORTHAND); + IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; + IO.ICRLO.DWord = (uint)(vector | APICIOGroup.ICR_STARTUP | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); - while ((IO.ICRLO.DWord & IO.ICR_SEND_PENDING) != 0) { } + while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } } } } diff --git a/source/Cosmos.Core/IOGroup/APICTimer.cs b/source/Cosmos.Core/IOGroup/APICTimer.cs new file mode 100644 index 0000000000..4a38231992 --- /dev/null +++ b/source/Cosmos.Core/IOGroup/APICTimer.cs @@ -0,0 +1,38 @@ +using Cosmos.Core; + +namespace Cosmos.Core.IOGroup +{ + /// + /// Local APIC Timer IOGroup class. + /// + public class APICTimerIOGroup : IOGroup + { + /// + /// Id port. + /// + public readonly IOPort Timer; + /// + /// Id port. + /// + public readonly IOPort TimerDiv; + /// + /// Id port. + /// + public readonly IOPort TimerInitCount; + /// + /// Id port. + /// + public readonly IOPort TimerCurrentCount; + + /// + /// Create new instance of the class. + /// + internal APICTimerIOGroup() + { + Timer = new IOPort(0x320); + TimerDiv = new IOPort(0x3e0); + TimerInitCount = new IOPort(0x380); + TimerCurrentCount = new IOPort(0x390); + } + } +} diff --git a/source/Cosmos.Core/LocalAPICTimer.cs b/source/Cosmos.Core/LocalAPICTimer.cs new file mode 100644 index 0000000000..08fee0c2dc --- /dev/null +++ b/source/Cosmos.Core/LocalAPICTimer.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Cosmos.Core.IOGroup; + +namespace Cosmos.Core +{ + /// + /// LocalAPICTimer class. Used to manage Local APIC Timer. + /// + public partial class LocalAPICTimer + { + /// + /// Local APIC Timer IO group. + /// + APICTimerIOGroup IO; + + /// + /// Constructor. + /// + public LocalAPICTimer() + { + IO = new APICTimerIOGroup(); + } + + /// + /// Ticks. + /// + public ulong Ticks => IO.TimerCurrentCount.DWord; + + /// + /// Send Init Command to Local APIC timer. + /// + /// Frequency. + /// Vector. + public void StartTimer(ulong freq, uint vector) + { + IO.Timer.DWord = 0x00020000 | vector; + IO.TimerDiv.DWord = 0x3; + IO.TimerInitCount.DWord = (uint)freq; + //INTs.EnableInterrupt(0x20); TODO + } + + /// + /// Send Stop command to Local APIC timer. + /// + public void StopTimer() + { + IO.Timer.DWord = 0x00020000 | 0x10000; + } + } +} From ebb443923d1fdfc2ec6c6651de4ec5bbde42de66 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 00:49:34 +0200 Subject: [PATCH 04/35] Rename APIC file + Add disable PIC method --- source/Cosmos.Core/{APIC.cs => LocalAPIC.cs} | 29 +++++++++----------- source/Cosmos.Core/PIC.cs | 9 ++++++ source/Cosmos.HAL2/Global.cs | 4 +++ 3 files changed, 26 insertions(+), 16 deletions(-) rename source/Cosmos.Core/{APIC.cs => LocalAPIC.cs} (87%) diff --git a/source/Cosmos.Core/APIC.cs b/source/Cosmos.Core/LocalAPIC.cs similarity index 87% rename from source/Cosmos.Core/APIC.cs rename to source/Cosmos.Core/LocalAPIC.cs index 5d9654d302..634203bf4b 100644 --- a/source/Cosmos.Core/APIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -15,22 +15,14 @@ public unsafe partial class LocalAPIC /// /// Local APIC IO group. /// - internal APICIOGroup IO; - - /// - /// End of Interrupt. - /// - public void EndOfInterrupt() - { - IO.EndOfInterrupts.DWord = 0; - } + internal static APICIOGroup IO; /// /// Initialize local APIC. /// - public void Initialize() + public static void Initialize() { - //PIC.Disable(); TODO + Global.PIC.Disable(); IO = new APICIOGroup((ushort)ACPI.MADT->LocalAPICAddress); @@ -43,15 +35,21 @@ public void Initialize() // Configure Spurious Interrupt Vector Register IO.Svr.DWord = 0x100 | 0xff; + } - Console.WriteLine("Local APIC initialized"); + /// + /// End of Interrupt. + /// + public static void EndOfInterrupt() + { + IO.EndOfInterrupts.DWord = 0; } /// /// Get Local APIC ID. /// /// integer value. - public uint GetId() + public static uint GetId() { return IO.Id.DWord >> 24; } @@ -60,7 +58,7 @@ public uint GetId() /// Send Init Command to Local APIC. /// /// APIC ID. - public void SendInit(uint apic_id) + public static void SendInit(uint apic_id) { IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; IO.ICRLO.DWord = (uint)(APICIOGroup.ICR_INIT | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); @@ -68,13 +66,12 @@ public void SendInit(uint apic_id) while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } } - /// /// Send Startup Command to Local APIC. /// /// APIC ID. /// Vector. - public void SendStartup(uint apic_id, ushort vector) + public static void SendStartup(uint apic_id, ushort vector) { IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; IO.ICRLO.DWord = (uint)(vector | APICIOGroup.ICR_STARTUP | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); diff --git a/source/Cosmos.Core/PIC.cs b/source/Cosmos.Core/PIC.cs index e8b44ce048..fb6037e86e 100644 --- a/source/Cosmos.Core/PIC.cs +++ b/source/Cosmos.Core/PIC.cs @@ -177,5 +177,14 @@ protected void Init(IOGroup.PIC aPIC, byte aBase, byte aIDunno, byte aMask) Master.Data.Byte = aMask; IOPort.Wait(); } + + /// + /// Disable PIC. + /// + public void Disable() + { + Master.Data.Byte = 0xFF; + Slave.Data.Byte = 0xFF; + } } } diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index 16803fefeb..1f130a0594 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -54,6 +54,10 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In mDebugger.Send("ACPI Init"); ACPI.Start(); + //Console.WriteLine("Starting APIC"); + //mDebugger.Send("APIC Init"); + //LocalAPIC.Initialize(); + // http://wiki.osdev.org/%228042%22_PS/2_Controller#Initialising_the_PS.2F2_Controller // TODO: USB should be initialized before the PS/2 controller // TODO: ACPI should be used to check if a PS/2 controller exists From b62855e4b4730157303c4697540c76e6c8ce9522 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 01:37:37 +0200 Subject: [PATCH 05/35] Add IO APIC --- source/Cosmos.Core/ACPI.cs | 114 ++++++++++++++++++++++++--- source/Cosmos.Core/IOAPIC.cs | 65 +++++++++++++++ source/Cosmos.Core/IOGroup/IOAPIC.cs | 46 +++++++++++ source/Cosmos.Core/LocalAPIC.cs | 2 + 4 files changed, 216 insertions(+), 11 deletions(-) create mode 100644 source/Cosmos.Core/IOAPIC.cs create mode 100644 source/Cosmos.Core/IOGroup/IOAPIC.cs diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index fcc9f0e929..4d197ee95e 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -245,6 +245,70 @@ struct ApicLocalApic public uint Flags; } + /// + /// ApicIOApic struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ApicIOApic + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// APIC ID. + /// + public byte IOApicId; + + /// + /// Reserved. + /// + public byte Reserved; + + /// + /// IO APIC Base Address. + /// + public uint IOApicAddress; + + /// + /// Global System Interrupt Base Address. + /// + public uint GlobalSystemInterruptBase; + } + + /// + /// ApicInterruptOverride struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + struct ApicInterruptOverride + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// Bus. + /// + public byte Bus; + + /// + /// Source. + /// + public byte Source; + + /// + /// Interrupt. + /// + public uint Interrupt; + + /// + /// Floags. + /// + public ushort Flags; + } + // New Port I/O /// /// IO port. @@ -293,9 +357,9 @@ struct ApicLocalApic /// public static MADTPtr* MADT; /// - /// Local APIC CPUID list. + /// Global IO APIC. /// - public static List LocalAPIC_CPUIDs; + public static ApicIOApic* IOAPIC; /// /// Check ACPI header. @@ -397,8 +461,6 @@ public static void Reboot() /// true on success, false on failure. private static bool Init() { - LocalAPIC_CPUIDs = new List(); - var rsdp = RSDPAddress(); byte* ptr = (byte*)rsdp; @@ -495,20 +557,23 @@ private static void ParseDT(AcpiHeader *hdr) if (type == ApicType.LocalAPIC) { Global.mDebugger.Send("Parse local APIC"); - var pic = (ApicLocalApic*)p; - if (((pic->Flags & 1) ^ ((pic->Flags >> 1) & 1)) == 1) - { - LocalAPIC_CPUIDs.Add(pic->ApicId); - } + Global.mDebugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); } else if (type == ApicType.IOAPIC) { - Console.WriteLine("IO APIC not implemented."); + var ioapic = (ApicIOApic*)p; + if (ioapic == null) + { + IOAPIC = ioapic; + } + Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + "(Address:" + ((ulong)ioapic->IOApicAddress).ToString("x2") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); } else if (type == ApicType.InterruptOverride) { - Console.WriteLine("InterruptOverride not implemented."); + var ovr = (ApicInterruptOverride*)p; + + Global.mDebugger.Send("Found APIC Interrupt Override (Bus: " + (((ulong)ovr->Bus).ToString()) + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:" + ((ulong)ovr->Interrupt).ToString("x2") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); } p += length; @@ -562,5 +627,32 @@ public static void Disable() return null; } + + public static uint RemapIRQ(uint irq) + { + byte* p = (byte*)(MADT + 1); + byte* end = (byte*)MADT + MADT->Header.Length; + + while (p < end) + { + var header = (ApicHeader*)p; + var type = header->Type; + byte length = header->Length; + + if (type == ApicType.InterruptOverride) + { + var ovr = (ApicInterruptOverride*)p; + + if (ovr->Source == irq) + { + return ovr->Interrupt; + } + } + + p += length; + } + + return irq; + } } } diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs new file mode 100644 index 0000000000..c37df1a545 --- /dev/null +++ b/source/Cosmos.Core/IOAPIC.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Cosmos.Core.IOGroup; + +namespace Cosmos.Core +{ + /// + /// Local APIC class. + /// + public unsafe partial class IOAPIC + { + /// + /// IO APIC IO group. + /// + internal static IOAPICIOGroup IO; + + /// + /// Initialize local APIC. + /// + public static void Initialize() + { + if (ACPI.IOAPIC == null) + { + Console.WriteLine("Can't initialize IO APIC"); + + return; + } + uint value = IO.Ver.DWord; + uint count = ((value >> 16) & 0xFF) + 1; + + //Disable All Entries + for (uint i = 0; i < count; ++i) + { + SetEntry((byte)i, 1 << 16); + } + Console.WriteLine("IO APIC Initialized"); + } + + public static uint In(byte reg) + { + IO.RegSel.Byte = reg; + return IO.Win.DWord; + } + + public static void Out(byte reg, uint value) + { + IO.RegSel.Byte = reg; + IO.Win.DWord = value; + } + + public static void SetEntry(byte index, ulong data) + { + Out((byte)(IOAPICIOGroup.IOREDTBL + index * 2), (uint)data); + Out((byte)(IOAPICIOGroup.IOREDTBL + index * 2 + 1), (uint)(data >> 32)); + } + + public static void SetEntry(uint irq) + { + IOAPIC.SetEntry((byte)ACPI.RemapIRQ(irq - 0x20), irq); + } + } +} diff --git a/source/Cosmos.Core/IOGroup/IOAPIC.cs b/source/Cosmos.Core/IOGroup/IOAPIC.cs new file mode 100644 index 0000000000..99f736c4ba --- /dev/null +++ b/source/Cosmos.Core/IOGroup/IOAPIC.cs @@ -0,0 +1,46 @@ +using Cosmos.Core; + +namespace Cosmos.Core.IOGroup +{ + /// + /// IO APIC IOGroup class. + /// + public class IOAPICIOGroup : IOGroup + { + public const ushort IOREGSEL = 0x00; + public const ushort IOWIN = 0x10; + public const ushort IOAPICID = 0x00; + public const ushort IOAPICVER = 0x01; + public const ushort IOAPICARB = 0x02; + public const ushort IOREDTBL = 0x10; + + /// + /// Ver port. + /// + public readonly IOPort Ver; + /// + /// RegSel port. + /// + public readonly IOPort RegSel; + /// + /// Win port. + /// + public readonly IOPort Win; + /// + /// RedTbl port. + /// + public readonly IOPort RedTbl; + + /// + /// Create new instance of the class. + /// + /// IO APIC Base Address. + internal IOAPICIOGroup(ushort baseAddress) + { + Ver = new IOPort(baseAddress, IOAPICVER); + RegSel = new IOPort(baseAddress, IOREGSEL); + Win = new IOPort(baseAddress, IOWIN); + RedTbl = new IOPort(baseAddress, IOREDTBL); + } + } +} diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 634203bf4b..41c0aa8b18 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -35,6 +35,8 @@ public static void Initialize() // Configure Spurious Interrupt Vector Register IO.Svr.DWord = 0x100 | 0xff; + + Console.WriteLine("Local APIC initialized"); } /// From c39a89726c04a4489438fa2b9fd6e20a1d404e22 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 02:10:48 +0200 Subject: [PATCH 06/35] Move from PIC to APIC --- source/Cosmos.Core/INTs.cs | 41 ++++++++----------- source/Cosmos.Core/LocalAPIC.cs | 2 +- source/Cosmos.Core/PIC.cs | 15 ++++++- .../Drivers/PCI/Network/AMDPCNetII.cs | 2 +- source/Cosmos.HAL2/Global.cs | 10 +++-- 5 files changed, 40 insertions(+), 30 deletions(-) diff --git a/source/Cosmos.Core/INTs.cs b/source/Cosmos.Core/INTs.cs index 9aefc57f98..4a9eb83a96 100644 --- a/source/Cosmos.Core/INTs.cs +++ b/source/Cosmos.Core/INTs.cs @@ -258,6 +258,7 @@ public static void SetIntHandler(byte aIntNo, IRQDelegate aHandler) { /// IRQ index. /// IRQ handler. public static void SetIrqHandler(byte aIrqNo, IRQDelegate aHandler) { + IOAPIC.SetEntry(aIrqNo); SetIntHandler((byte)(0x20 + aIrqNo), aHandler); } @@ -278,13 +279,7 @@ private static void IRQ(uint irq, ref IRQContext aContext) { /// /// A IEQ context. public static void HandleInterrupt_Default(ref IRQContext aContext) { - if (aContext.Interrupt >= 0x20 && aContext.Interrupt <= 0x2F) { - if (aContext.Interrupt >= 0x28) { - Global.PIC.EoiSlave(); - } else { - Global.PIC.EoiMaster(); - } - } + LocalAPIC.EndOfInterrupt(); } /// @@ -307,7 +302,7 @@ public static void HandleInterrupt_Default(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_20(ref IRQContext aContext) { IRQ(0x20, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } //public static IRQDelegate IRQ01; @@ -318,43 +313,43 @@ public static void HandleInterrupt_20(ref IRQContext aContext) { public static void HandleInterrupt_21(ref IRQContext aContext) { IRQ(0x21, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_22(ref IRQContext aContext) { IRQ(0x22, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_23(ref IRQContext aContext) { IRQ(0x23, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_24(ref IRQContext aContext) { IRQ(0x24, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_25(ref IRQContext aContext) { IRQ(0x25, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_26(ref IRQContext aContext) { IRQ(0x26, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_27(ref IRQContext aContext) { IRQ(0x27, ref aContext); - Global.PIC.EoiMaster(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_28(ref IRQContext aContext) { IRQ(0x28, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// @@ -363,7 +358,7 @@ public static void HandleInterrupt_28(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_29(ref IRQContext aContext) { IRQ(0x29, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// @@ -372,7 +367,7 @@ public static void HandleInterrupt_29(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_2A(ref IRQContext aContext) { IRQ(0x2A, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// @@ -381,19 +376,19 @@ public static void HandleInterrupt_2A(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_2B(ref IRQContext aContext) { IRQ(0x2B, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_2C(ref IRQContext aContext) { IRQ(0x2C, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } public static void HandleInterrupt_2D(ref IRQContext aContext) { IRQ(0x2D, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// @@ -402,7 +397,7 @@ public static void HandleInterrupt_2D(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_2E(ref IRQContext aContext) { IRQ(0x2E, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// @@ -411,7 +406,7 @@ public static void HandleInterrupt_2E(ref IRQContext aContext) { /// IRQ context. public static void HandleInterrupt_2F(ref IRQContext aContext) { IRQ(0x2F, ref aContext); - Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } public static event IRQDelegate Interrupt30; diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 41c0aa8b18..277b9b2c68 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -10,7 +10,7 @@ namespace Cosmos.Core /// /// Local APIC class. /// - public unsafe partial class LocalAPIC + public static unsafe class LocalAPIC { /// /// Local APIC IO group. diff --git a/source/Cosmos.Core/PIC.cs b/source/Cosmos.Core/PIC.cs index fb6037e86e..ed7e4ac061 100644 --- a/source/Cosmos.Core/PIC.cs +++ b/source/Cosmos.Core/PIC.cs @@ -37,6 +37,7 @@ protected enum Cmd EOI = 0x20 } + /* /// /// Master end of interrupt. /// @@ -52,7 +53,7 @@ public void EoiSlave() { Master.Cmd.Byte = (byte) Cmd.EOI; Slave.Cmd.Byte = (byte) Cmd.EOI; - } + }*/ /// /// Create new instance of the class. @@ -71,7 +72,7 @@ public PIC() //Init(Master, 0x20, 4, 0xFD | 0x08); //Init(Slave, 0x28, 2, 0xFF); //for now enable keyboard, mouse(ps2) - Remap(0x20, 0xF8 | 0x08, 0x28, 0xEB); + //Remap(0x20, 0xF8 | 0x08, 0x28, 0xEB); } /// @@ -183,6 +184,16 @@ protected void Init(IOGroup.PIC aPIC, byte aBase, byte aIDunno, byte aMask) /// public void Disable() { + //init + Master.Cmd.Byte = 0x11; + Slave.Cmd.Byte = 0x11; + Master.Data.Byte = 0x20; + Slave.Data.Byte = 40; + Master.Data.Byte = 0x04; + Slave.Data.Byte = 0x02; + Master.Data.Byte = 0x01; + Slave.Data.Byte = 0x01; + Master.Data.Byte = 0xFF; Slave.Data.Byte = 0xFF; } diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index 6c0fa2858e..a4184d0660 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -124,7 +124,7 @@ protected void HandleNetworkInterrupt(ref INTs.IRQContext aContext) } StatusRegister = cur_status; - Cosmos.Core.Global.PIC.EoiSlave(); + LocalAPIC.EndOfInterrupt(); } /// diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index 1f130a0594..ef463cc0e7 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -54,9 +54,13 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In mDebugger.Send("ACPI Init"); ACPI.Start(); - //Console.WriteLine("Starting APIC"); - //mDebugger.Send("APIC Init"); - //LocalAPIC.Initialize(); + Console.WriteLine("Starting Local APIC"); + mDebugger.Send("Local APIC Init"); + LocalAPIC.Initialize(); + + Console.WriteLine("Starting IO APIC"); + mDebugger.Send("IO APIC Init"); + IOAPIC.Initialize(); // http://wiki.osdev.org/%228042%22_PS/2_Controller#Initialising_the_PS.2F2_Controller // TODO: USB should be initialized before the PS/2 controller From 438421a5ea118375292432af7bcc3bd5f5d5207f Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 03:28:00 +0200 Subject: [PATCH 07/35] ACPI parse fix + IOAPIC fix + Add MMIO class --- source/Cosmos.Core/ACPI.cs | 14 ++- source/Cosmos.Core/IOAPIC.cs | 2 + source/Cosmos.Core/IOGroup/APIC.cs | 34 +++--- source/Cosmos.Core/IOGroup/IOAPIC.cs | 18 ++-- source/Cosmos.Core/LocalAPIC.cs | 4 +- source/Cosmos.Core/MMIO.cs | 149 +++++++++++++++++++++++++++ source/Cosmos.HAL2/Global.cs | 38 ++++--- 7 files changed, 210 insertions(+), 49 deletions(-) create mode 100644 source/Cosmos.Core/MMIO.cs diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index 4d197ee95e..29a5cb6be8 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -461,6 +461,7 @@ public static void Reboot() /// true on success, false on failure. private static bool Init() { + IOAPIC = null; var rsdp = RSDPAddress(); byte* ptr = (byte*)rsdp; @@ -486,7 +487,7 @@ private static void ParseDT(AcpiHeader *hdr) { var signature = Encoding.ASCII.GetString(hdr->Signature, 4); - Global.mDebugger.Send(signature + "detected"); + Global.mDebugger.Send(signature + " detected"); if (signature == "FACP") { @@ -542,7 +543,7 @@ private static void ParseDT(AcpiHeader *hdr) } else if (signature == "APIC") { - Global.mDebugger.Send("Parse ACPI"); + Global.mDebugger.Send("Parse APIC"); MADT = (MADTPtr*)hdr; @@ -562,18 +563,21 @@ private static void ParseDT(AcpiHeader *hdr) } else if (type == ApicType.IOAPIC) { + Global.mDebugger.Send("Parse IO APIC"); var ioapic = (ApicIOApic*)p; - if (ioapic == null) + if (IOAPIC == null) { IOAPIC = ioapic; } - Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + "(Address:" + ((ulong)ioapic->IOApicAddress).ToString("x2") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); + Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + "(Address:0x" + ((ulong)ioapic->IOApicAddress).ToString("X") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); } else if (type == ApicType.InterruptOverride) { + Global.mDebugger.Send("Parse Interrupt Override APIC"); + var ovr = (ApicInterruptOverride*)p; - Global.mDebugger.Send("Found APIC Interrupt Override (Bus: " + (((ulong)ovr->Bus).ToString()) + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:" + ((ulong)ovr->Interrupt).ToString("x2") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); + Global.mDebugger.Send("Found APIC Interrupt Override (Bus: " + ((ulong)ovr->Bus).ToString() + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:0x" + ((ulong)ovr->Interrupt).ToString("X") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); } p += length; diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index c37df1a545..2b2f26291e 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -22,6 +22,8 @@ public unsafe partial class IOAPIC /// public static void Initialize() { + IO = new IOAPICIOGroup((ushort)ACPI.IOAPIC->IOApicAddress); + if (ACPI.IOAPIC == null) { Console.WriteLine("Can't initialize IO APIC"); diff --git a/source/Cosmos.Core/IOGroup/APIC.cs b/source/Cosmos.Core/IOGroup/APIC.cs index 92236af150..d7bd1f3a3d 100644 --- a/source/Cosmos.Core/IOGroup/APIC.cs +++ b/source/Cosmos.Core/IOGroup/APIC.cs @@ -62,49 +62,49 @@ public class APICIOGroup : IOGroup /// /// Id port. /// - public readonly IOPort Id; + public readonly MMIO Id; /// /// EndOfInterrupts port. /// - public readonly IOPort EndOfInterrupts; + public readonly MMIO EndOfInterrupts; /// /// EndOfInterrupts port. /// - public readonly IOPort Tpr; + public readonly MMIO Tpr; /// /// EndOfInterrupts port. /// - public readonly IOPort Dfr; + public readonly MMIO Dfr; /// /// EndOfInterrupts port. /// - public readonly IOPort Ldr; + public readonly MMIO Ldr; /// /// EndOfInterrupts port. /// - public readonly IOPort Svr; + public readonly MMIO Svr; /// /// EndOfInterrupts port. /// - public readonly IOPort ICRHI; + public readonly MMIO ICRHI; /// /// EndOfInterrupts port. /// - public readonly IOPort ICRLO; + public readonly MMIO ICRLO; /// /// Create new instance of the class. /// - internal APICIOGroup(ushort baseAddress) + internal APICIOGroup(uint baseAddress) { - Id = new IOPort(baseAddress, LAPIC_ID); - EndOfInterrupts = new IOPort(baseAddress, LAPIC_EOI); - Tpr = new IOPort(baseAddress, LAPIC_TPR); - Dfr = new IOPort(baseAddress, LAPIC_DFR); - Ldr = new IOPort(baseAddress, LAPIC_LDR); - Svr = new IOPort(baseAddress, LAPIC_SVR); - ICRHI = new IOPort(baseAddress, LAPIC_ICRHI); - ICRLO = new IOPort(baseAddress, LAPIC_ICRLO); + Id = new MMIO(baseAddress, LAPIC_ID); + EndOfInterrupts = new MMIO(baseAddress, LAPIC_EOI); + Tpr = new MMIO(baseAddress, LAPIC_TPR); + Dfr = new MMIO(baseAddress, LAPIC_DFR); + Ldr = new MMIO(baseAddress, LAPIC_LDR); + Svr = new MMIO(baseAddress, LAPIC_SVR); + ICRHI = new MMIO(baseAddress, LAPIC_ICRHI); + ICRLO = new MMIO(baseAddress, LAPIC_ICRLO); } } } diff --git a/source/Cosmos.Core/IOGroup/IOAPIC.cs b/source/Cosmos.Core/IOGroup/IOAPIC.cs index 99f736c4ba..e4dcd2a062 100644 --- a/source/Cosmos.Core/IOGroup/IOAPIC.cs +++ b/source/Cosmos.Core/IOGroup/IOAPIC.cs @@ -17,30 +17,30 @@ public class IOAPICIOGroup : IOGroup /// /// Ver port. /// - public readonly IOPort Ver; + public readonly MMIO Ver; /// /// RegSel port. /// - public readonly IOPort RegSel; + public readonly MMIO RegSel; /// /// Win port. /// - public readonly IOPort Win; + public readonly MMIO Win; /// /// RedTbl port. /// - public readonly IOPort RedTbl; + public readonly MMIO RedTbl; /// /// Create new instance of the class. /// /// IO APIC Base Address. - internal IOAPICIOGroup(ushort baseAddress) + internal IOAPICIOGroup(uint baseAddress) { - Ver = new IOPort(baseAddress, IOAPICVER); - RegSel = new IOPort(baseAddress, IOREGSEL); - Win = new IOPort(baseAddress, IOWIN); - RedTbl = new IOPort(baseAddress, IOREDTBL); + Ver = new MMIO(baseAddress, IOAPICVER); + RegSel = new MMIO(baseAddress, IOREGSEL); + Win = new MMIO(baseAddress, IOWIN); + RedTbl = new MMIO(baseAddress, IOREDTBL); } } } diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 277b9b2c68..727a279f06 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -24,7 +24,7 @@ public static void Initialize() { Global.PIC.Disable(); - IO = new APICIOGroup((ushort)ACPI.MADT->LocalAPICAddress); + IO = new APICIOGroup(ACPI.MADT->LocalAPICAddress); //Enable All Interrupts IO.Tpr.DWord = 0; @@ -63,7 +63,7 @@ public static uint GetId() public static void SendInit(uint apic_id) { IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; - IO.ICRLO.DWord = (uint)(APICIOGroup.ICR_INIT | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); + IO.ICRLO.DWord = APICIOGroup.ICR_INIT | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND; while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } } diff --git a/source/Cosmos.Core/MMIO.cs b/source/Cosmos.Core/MMIO.cs new file mode 100644 index 0000000000..ba2602dd99 --- /dev/null +++ b/source/Cosmos.Core/MMIO.cs @@ -0,0 +1,149 @@ +using IL2CPU.API.Attribs; + +namespace Cosmos.Core +{ + /// + /// MMIOBase abstract class. + /// + public unsafe abstract class MMIOBase + { + /// + /// Address. + /// + protected readonly uint Address; + + // all ctors are internal - Only Core ring can create it.. but hardware ring can use it. + /// + /// Create new instance of the class. + /// + /// An address. + protected MMIOBase(uint address) + { + Address = address; + } + + /// + /// Create new instance of the class. + /// + /// A base address. + /// An offset from the base address. + protected MMIOBase(uint aBase, uint aOffset) + { + // C# math promotes things to integers, so we have this constructor + // to relieve the use from having to do so many casts + Address = aBase + aOffset; + } + + /// + /// Write byte to adress. + /// + /// An address to write to. + /// A data. + static protected void Write8(uint address, byte aData) + { + *(uint*)address = aData; + } + + /// + /// Write Word to address. + /// + /// A address to write to. + /// A data. + static protected void Write16(uint address, ushort aData) + { + *(uint*)address = aData; + } + + /// + /// Write DWord to address. + /// + /// An address to write to. + /// A data. + static protected void Write32(uint address, uint aData) + { + *(uint*)address = aData; + } + + /// + /// Read byte from address. + /// + /// An address to read from. + /// byte value. + static protected byte Read8(uint address) + { + return (byte)(*(uint*)address); + } + + /// + /// Read Word from address. + /// + /// An address to read from. + /// ushort value. + static protected ushort Read16(uint address) + { + return (ushort)(*(uint*)address); + } + + /// + /// Read DWord from address. + /// + /// An address to read from. + /// uint value. + static protected uint Read32(uint address) + { + return *(uint*)address; + } + } + + /// + /// MMIO class. Used to read and write to address. + /// + public class MMIO : MMIOBase + { + /// + /// Create new instance of the class. + /// + /// An address. + public MMIO(uint address) + : base(address) + { + } + + /// + /// Create new instance of the class. + /// + /// A base address. + /// Offset from the base address. + public MMIO(uint address, uint aOffset) + : base(address, aOffset) + { + } + + /// + /// Get and set Byte value in address. + /// + public byte Byte + { + get => Read8(Address); + set => Write8(Address, value); + } + + /// + /// Get and set Word value in address. + /// + public ushort Word + { + get => Read16(Address); + set => Write16(Address, value); + } + + /// + /// Get and set DWord value in address. + /// + public uint DWord + { + get => Read32(Address); + set => Write32(Address, value); + } + } +} diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index ef463cc0e7..c87d338360 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -12,13 +12,13 @@ public static class Global { public static readonly Debugger mDebugger = new Debugger("HAL", "Global"); - public static PIT PIT = new PIT(); + public static PIT PIT; // Must be static init, other static inits rely on it not being null - public static TextScreenBase TextScreen = new TextScreen(); + public static TextScreenBase TextScreen; public static PCI Pci; - public static readonly PS2Controller PS2Controller = new PS2Controller(); + public static PS2Controller PS2Controller; // TODO: continue adding exceptions to the list, as HAL and Core would be documented. /// @@ -28,14 +28,33 @@ public static class Global /// Thrown on IO error. static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool InitPS2, bool InitNetwork, bool IDEInit) { + textScreen = new TextScreen(); + if (textScreen != null) { TextScreen = textScreen; } + Console.Clear(); + mDebugger.Send("Before Core.Global.Init"); Core.Global.Init(); + Console.WriteLine("Starting ACPI"); + mDebugger.Send("ACPI Init"); + ACPI.Start(); + + Console.WriteLine("Starting Local APIC"); + mDebugger.Send("Local APIC Init"); + LocalAPIC.Initialize(); + + Console.WriteLine("Starting IO APIC"); + mDebugger.Send("IO APIC Init"); + IOAPIC.Initialize(); + + PIT = new PIT(); + PS2Controller = new PS2Controller(); + //TODO Redo this - Global init should be other. // Move PCI detection to hardware? Or leave it in core? Is Core PC specific, or deeper? // If we let hardware do it, we need to protect it from being used by System. @@ -45,23 +64,10 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In //TODO: Since this is FCL, its "common". Otherwise it should be // system level and not accessible from Core. Need to think about this // for the future. - Console.Clear(); Console.WriteLine("Finding PCI Devices"); mDebugger.Send("PCI Devices"); PCI.Setup(); - Console.WriteLine("Starting ACPI"); - mDebugger.Send("ACPI Init"); - ACPI.Start(); - - Console.WriteLine("Starting Local APIC"); - mDebugger.Send("Local APIC Init"); - LocalAPIC.Initialize(); - - Console.WriteLine("Starting IO APIC"); - mDebugger.Send("IO APIC Init"); - IOAPIC.Initialize(); - // http://wiki.osdev.org/%228042%22_PS/2_Controller#Initialising_the_PS.2F2_Controller // TODO: USB should be initialized before the PS/2 controller // TODO: ACPI should be used to check if a PS/2 controller exists From dcc7815eb4d2c1fa8bb171d40adf1453723ba23a Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 03:42:07 +0200 Subject: [PATCH 08/35] Boot fix --- source/Cosmos.Core/ACPI.cs | 2 +- source/Cosmos.Core/IOAPIC.cs | 4 ++-- source/Cosmos.Core/IOGroup/{APIC.cs => LocalAPIC.cs} | 0 source/Cosmos.Core/MMIO.cs | 6 +++--- 4 files changed, 6 insertions(+), 6 deletions(-) rename source/Cosmos.Core/IOGroup/{APIC.cs => LocalAPIC.cs} (100%) diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index 29a5cb6be8..0e830eda07 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -569,7 +569,7 @@ private static void ParseDT(AcpiHeader *hdr) { IOAPIC = ioapic; } - Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + "(Address:0x" + ((ulong)ioapic->IOApicAddress).ToString("X") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); + Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + " (Address:0x" + ((ulong)ioapic->IOApicAddress).ToString("X") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); } else if (type == ApicType.InterruptOverride) { diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 2b2f26291e..d7a81e7a8e 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -22,7 +22,7 @@ public unsafe partial class IOAPIC /// public static void Initialize() { - IO = new IOAPICIOGroup((ushort)ACPI.IOAPIC->IOApicAddress); + IO = new IOAPICIOGroup(ACPI.IOAPIC->IOApicAddress); if (ACPI.IOAPIC == null) { @@ -61,7 +61,7 @@ public static void SetEntry(byte index, ulong data) public static void SetEntry(uint irq) { - IOAPIC.SetEntry((byte)ACPI.RemapIRQ(irq - 0x20), irq); + SetEntry((byte)ACPI.RemapIRQ(irq - 0x20), irq); } } } diff --git a/source/Cosmos.Core/IOGroup/APIC.cs b/source/Cosmos.Core/IOGroup/LocalAPIC.cs similarity index 100% rename from source/Cosmos.Core/IOGroup/APIC.cs rename to source/Cosmos.Core/IOGroup/LocalAPIC.cs diff --git a/source/Cosmos.Core/MMIO.cs b/source/Cosmos.Core/MMIO.cs index ba2602dd99..6385ffd696 100644 --- a/source/Cosmos.Core/MMIO.cs +++ b/source/Cosmos.Core/MMIO.cs @@ -25,13 +25,13 @@ protected MMIOBase(uint address) /// /// Create new instance of the class. /// - /// A base address. + /// A base address. /// An offset from the base address. - protected MMIOBase(uint aBase, uint aOffset) + protected MMIOBase(uint address, uint aOffset) { // C# math promotes things to integers, so we have this constructor // to relieve the use from having to do so many casts - Address = aBase + aOffset; + Address = address + aOffset; } /// From f8750c5e03ffb09d54dbcbf5ae477da3509380bc Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 03:55:14 +0200 Subject: [PATCH 09/35] Fix SetEntry --- source/Cosmos.Core/IOAPIC.cs | 18 ++++-------------- 1 file changed, 4 insertions(+), 14 deletions(-) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index d7a81e7a8e..c305ed85f3 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -41,22 +41,12 @@ public static void Initialize() Console.WriteLine("IO APIC Initialized"); } - public static uint In(byte reg) - { - IO.RegSel.Byte = reg; - return IO.Win.DWord; - } - - public static void Out(byte reg, uint value) - { - IO.RegSel.Byte = reg; - IO.Win.DWord = value; - } - public static void SetEntry(byte index, ulong data) { - Out((byte)(IOAPICIOGroup.IOREDTBL + index * 2), (uint)data); - Out((byte)(IOAPICIOGroup.IOREDTBL + index * 2 + 1), (uint)(data >> 32)); + var mmio = new MMIO((uint)(IOAPICIOGroup.IOREDTBL + index * 2)); + mmio.DWord = (uint)data; + var mmio2 = new MMIO((uint)(IOAPICIOGroup.IOREDTBL + index * 2 + 1)); + mmio2.DWord = (uint)(data >> 32); } public static void SetEntry(uint irq) From 59ce89f7af7b4a198d16eca54991f01e870d43bb Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 18:56:15 +0200 Subject: [PATCH 10/35] Remove APICTimer for now + move APIC to MemoryGroup --- source/Cosmos.Core/IOAPIC.cs | 2 +- source/Cosmos.Core/IOGroup/APICTimer.cs | 38 ------------- source/Cosmos.Core/LocalAPIC.cs | 2 +- source/Cosmos.Core/LocalAPICTimer.cs | 54 ------------------- .../{IOGroup => MemoryGroup}/IOAPIC.cs | 8 ++- .../{IOGroup => MemoryGroup}/LocalAPIC.cs | 8 ++- 6 files changed, 8 insertions(+), 104 deletions(-) delete mode 100644 source/Cosmos.Core/IOGroup/APICTimer.cs delete mode 100644 source/Cosmos.Core/LocalAPICTimer.cs rename source/Cosmos.Core/{IOGroup => MemoryGroup}/IOAPIC.cs (89%) rename source/Cosmos.Core/{IOGroup => MemoryGroup}/LocalAPIC.cs (96%) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index c305ed85f3..2f18856463 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using Cosmos.Core.IOGroup; +using Cosmos.Core.MemoryGroup; namespace Cosmos.Core { diff --git a/source/Cosmos.Core/IOGroup/APICTimer.cs b/source/Cosmos.Core/IOGroup/APICTimer.cs deleted file mode 100644 index 4a38231992..0000000000 --- a/source/Cosmos.Core/IOGroup/APICTimer.cs +++ /dev/null @@ -1,38 +0,0 @@ -using Cosmos.Core; - -namespace Cosmos.Core.IOGroup -{ - /// - /// Local APIC Timer IOGroup class. - /// - public class APICTimerIOGroup : IOGroup - { - /// - /// Id port. - /// - public readonly IOPort Timer; - /// - /// Id port. - /// - public readonly IOPort TimerDiv; - /// - /// Id port. - /// - public readonly IOPort TimerInitCount; - /// - /// Id port. - /// - public readonly IOPort TimerCurrentCount; - - /// - /// Create new instance of the class. - /// - internal APICTimerIOGroup() - { - Timer = new IOPort(0x320); - TimerDiv = new IOPort(0x3e0); - TimerInitCount = new IOPort(0x380); - TimerCurrentCount = new IOPort(0x390); - } - } -} diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 727a279f06..0743f2d7cd 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -using Cosmos.Core.IOGroup; +using Cosmos.Core.MemoryGroup; namespace Cosmos.Core { diff --git a/source/Cosmos.Core/LocalAPICTimer.cs b/source/Cosmos.Core/LocalAPICTimer.cs deleted file mode 100644 index 08fee0c2dc..0000000000 --- a/source/Cosmos.Core/LocalAPICTimer.cs +++ /dev/null @@ -1,54 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using Cosmos.Core.IOGroup; - -namespace Cosmos.Core -{ - /// - /// LocalAPICTimer class. Used to manage Local APIC Timer. - /// - public partial class LocalAPICTimer - { - /// - /// Local APIC Timer IO group. - /// - APICTimerIOGroup IO; - - /// - /// Constructor. - /// - public LocalAPICTimer() - { - IO = new APICTimerIOGroup(); - } - - /// - /// Ticks. - /// - public ulong Ticks => IO.TimerCurrentCount.DWord; - - /// - /// Send Init Command to Local APIC timer. - /// - /// Frequency. - /// Vector. - public void StartTimer(ulong freq, uint vector) - { - IO.Timer.DWord = 0x00020000 | vector; - IO.TimerDiv.DWord = 0x3; - IO.TimerInitCount.DWord = (uint)freq; - //INTs.EnableInterrupt(0x20); TODO - } - - /// - /// Send Stop command to Local APIC timer. - /// - public void StopTimer() - { - IO.Timer.DWord = 0x00020000 | 0x10000; - } - } -} diff --git a/source/Cosmos.Core/IOGroup/IOAPIC.cs b/source/Cosmos.Core/MemoryGroup/IOAPIC.cs similarity index 89% rename from source/Cosmos.Core/IOGroup/IOAPIC.cs rename to source/Cosmos.Core/MemoryGroup/IOAPIC.cs index e4dcd2a062..b6f14546b9 100644 --- a/source/Cosmos.Core/IOGroup/IOAPIC.cs +++ b/source/Cosmos.Core/MemoryGroup/IOAPIC.cs @@ -1,11 +1,9 @@ -using Cosmos.Core; - -namespace Cosmos.Core.IOGroup +namespace Cosmos.Core.MemoryGroup { /// /// IO APIC IOGroup class. /// - public class IOAPICIOGroup : IOGroup + public class IOAPICMMIOGroup { public const ushort IOREGSEL = 0x00; public const ushort IOWIN = 0x10; @@ -35,7 +33,7 @@ public class IOAPICIOGroup : IOGroup /// Create new instance of the class. /// /// IO APIC Base Address. - internal IOAPICIOGroup(uint baseAddress) + internal IOAPICMMIOGroup(uint baseAddress) { Ver = new MMIO(baseAddress, IOAPICVER); RegSel = new MMIO(baseAddress, IOREGSEL); diff --git a/source/Cosmos.Core/IOGroup/LocalAPIC.cs b/source/Cosmos.Core/MemoryGroup/LocalAPIC.cs similarity index 96% rename from source/Cosmos.Core/IOGroup/LocalAPIC.cs rename to source/Cosmos.Core/MemoryGroup/LocalAPIC.cs index d7bd1f3a3d..32c75da9b8 100644 --- a/source/Cosmos.Core/IOGroup/LocalAPIC.cs +++ b/source/Cosmos.Core/MemoryGroup/LocalAPIC.cs @@ -1,11 +1,9 @@ -using Cosmos.Core; - -namespace Cosmos.Core.IOGroup +namespace Cosmos.Core.MemoryGroup { /// /// Local APIC IOGroup class. /// - public class APICIOGroup : IOGroup + public class APICMMIOGroup { public const ushort LAPIC_ID = 0x0020; public const ushort LAPIC_VER = 0x0030; @@ -95,7 +93,7 @@ public class APICIOGroup : IOGroup /// /// Create new instance of the class. /// - internal APICIOGroup(uint baseAddress) + internal APICMMIOGroup(uint baseAddress) { Id = new MMIO(baseAddress, LAPIC_ID); EndOfInterrupts = new MMIO(baseAddress, LAPIC_EOI); From b77b01ff78727853285fea5b8a90b9c098169be7 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sat, 11 Jun 2022 18:58:21 +0200 Subject: [PATCH 11/35] Fix build --- source/Cosmos.Core/IOAPIC.cs | 8 ++++---- source/Cosmos.Core/LocalAPIC.cs | 29 ++--------------------------- source/Cosmos.Core/MMIO.cs | 4 ++-- 3 files changed, 8 insertions(+), 33 deletions(-) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 2f18856463..8ded2c69c1 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -15,14 +15,14 @@ public unsafe partial class IOAPIC /// /// IO APIC IO group. /// - internal static IOAPICIOGroup IO; + internal static IOAPICMMIOGroup IO; /// /// Initialize local APIC. /// public static void Initialize() { - IO = new IOAPICIOGroup(ACPI.IOAPIC->IOApicAddress); + IO = new IOAPICMMIOGroup(ACPI.IOAPIC->IOApicAddress); if (ACPI.IOAPIC == null) { @@ -43,9 +43,9 @@ public static void Initialize() public static void SetEntry(byte index, ulong data) { - var mmio = new MMIO((uint)(IOAPICIOGroup.IOREDTBL + index * 2)); + var mmio = new MMIO((uint)(IOAPICMMIOGroup.IOREDTBL + index * 2)); mmio.DWord = (uint)data; - var mmio2 = new MMIO((uint)(IOAPICIOGroup.IOREDTBL + index * 2 + 1)); + var mmio2 = new MMIO((uint)(IOAPICMMIOGroup.IOREDTBL + index * 2 + 1)); mmio2.DWord = (uint)(data >> 32); } diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 0743f2d7cd..afff3932b2 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -15,7 +15,7 @@ public static unsafe class LocalAPIC /// /// Local APIC IO group. /// - internal static APICIOGroup IO; + internal static APICMMIOGroup IO; /// /// Initialize local APIC. @@ -24,7 +24,7 @@ public static void Initialize() { Global.PIC.Disable(); - IO = new APICIOGroup(ACPI.MADT->LocalAPICAddress); + IO = new APICMMIOGroup(ACPI.MADT->LocalAPICAddress); //Enable All Interrupts IO.Tpr.DWord = 0; @@ -55,30 +55,5 @@ public static uint GetId() { return IO.Id.DWord >> 24; } - - /// - /// Send Init Command to Local APIC. - /// - /// APIC ID. - public static void SendInit(uint apic_id) - { - IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; - IO.ICRLO.DWord = APICIOGroup.ICR_INIT | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND; - - while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } - } - - /// - /// Send Startup Command to Local APIC. - /// - /// APIC ID. - /// Vector. - public static void SendStartup(uint apic_id, ushort vector) - { - IO.ICRHI.DWord = apic_id << APICIOGroup.ICR_DESTINATION_SHIFT; - IO.ICRLO.DWord = (uint)(vector | APICIOGroup.ICR_STARTUP | APICIOGroup.ICR_PHYSICAL | APICIOGroup.ICR_ASSERT | APICIOGroup.ICR_EDGE | APICIOGroup.ICR_NO_SHORTHAND); - - while ((IO.ICRLO.DWord & APICIOGroup.ICR_SEND_PENDING) != 0) { } - } } } diff --git a/source/Cosmos.Core/MMIO.cs b/source/Cosmos.Core/MMIO.cs index 6385ffd696..c043c20c31 100644 --- a/source/Cosmos.Core/MMIO.cs +++ b/source/Cosmos.Core/MMIO.cs @@ -71,7 +71,7 @@ static protected void Write32(uint address, uint aData) /// byte value. static protected byte Read8(uint address) { - return (byte)(*(uint*)address); + return (byte)*(uint*)address; } /// @@ -81,7 +81,7 @@ static protected byte Read8(uint address) /// ushort value. static protected ushort Read16(uint address) { - return (ushort)(*(uint*)address); + return (ushort)*(uint*)address; } /// From 3271625759547498385d8f2ad9117f5e17397d90 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 03:01:40 +0200 Subject: [PATCH 12/35] Update MMIO class + Update IO APIC + Remove IO APIC MMIO Group --- source/Cosmos.Core/IOAPIC.cs | 80 +++++++++++++++++++----- source/Cosmos.Core/MMIO.cs | 12 ++-- source/Cosmos.Core/MemoryGroup/IOAPIC.cs | 44 ------------- 3 files changed, 70 insertions(+), 66 deletions(-) delete mode 100644 source/Cosmos.Core/MemoryGroup/IOAPIC.cs diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 8ded2c69c1..8b3b0ed329 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -12,46 +12,94 @@ namespace Cosmos.Core /// public unsafe partial class IOAPIC { - /// - /// IO APIC IO group. - /// - internal static IOAPICMMIOGroup IO; + public const byte IOREGSEL = 0x00; + public const byte IOWIN = 0x10; + + //IO APIC Registers + public const byte IOAPICID = 0x00; + public const byte IOAPICVER = 0x01; + public const byte IOAPICARB = 0x02; + public const byte IOREDTBL = 0x10; + + private static uint Address = 0; /// /// Initialize local APIC. /// public static void Initialize() { - IO = new IOAPICMMIOGroup(ACPI.IOAPIC->IOApicAddress); - if (ACPI.IOAPIC == null) { - Console.WriteLine("Can't initialize IO APIC"); - + Global.mDebugger.Send("Can't initialize IO APIC"); return; } - uint value = IO.Ver.DWord; - uint count = ((value >> 16) & 0xFF) + 1; + + Address = ACPI.IOAPIC->IOApicAddress; + + Global.mDebugger.Send("IO APIC address:0x" + Address.ToString("X")); + + uint x = In(IOAPICVER); + uint count = ((x >> 16) & 0xFF) + 1; + + Global.mDebugger.Send("IO APIC pins:" + count); //Disable All Entries for (uint i = 0; i < count; ++i) { SetEntry((byte)i, 1 << 16); } - Console.WriteLine("IO APIC Initialized"); + + Global.mDebugger.Send("IO APIC " + GetId() + " Initialized"); + } + + /// + /// IO APIC MMIO Out. + /// + /// IO APIC Register. + /// Data. + public static void Out(byte reg, uint val) + { + MMIOBase.Write32(Address + IOREGSEL, reg); + MMIOBase.Write32(Address + IOWIN, val); + } + + /// + /// IO APIC MMIO In. + /// + /// IO APIC Register. + public static uint In(byte reg) + { + MMIOBase.Write32(Address + IOREGSEL, reg); + return MMIOBase.Read32(Address + IOWIN); } + /// + /// Set IO APIC Entry. + /// + /// Entry index. + /// Data. public static void SetEntry(byte index, ulong data) { - var mmio = new MMIO((uint)(IOAPICMMIOGroup.IOREDTBL + index * 2)); - mmio.DWord = (uint)data; - var mmio2 = new MMIO((uint)(IOAPICMMIOGroup.IOREDTBL + index * 2 + 1)); - mmio2.DWord = (uint)(data >> 32); + Out((byte)(IOREDTBL + index * 2), (uint)data); + Out((byte)(IOREDTBL + index * 2 + 1), (uint)(data >> 32)); } + /// + /// Set IO APIC Entry. + /// + /// Irq ID. public static void SetEntry(uint irq) { - SetEntry((byte)ACPI.RemapIRQ(irq - 0x20), irq); + SetEntry((byte)ACPI.RemapIRQ(irq), irq); + } + + /// + /// Get IO APIC ID. + /// + /// byte value. + public static byte GetId() + { + return (byte)((In(IOAPICID) >> 24) & 0xF0); } } } diff --git a/source/Cosmos.Core/MMIO.cs b/source/Cosmos.Core/MMIO.cs index c043c20c31..ab6504a9ce 100644 --- a/source/Cosmos.Core/MMIO.cs +++ b/source/Cosmos.Core/MMIO.cs @@ -39,7 +39,7 @@ protected MMIOBase(uint address, uint aOffset) /// /// An address to write to. /// A data. - static protected void Write8(uint address, byte aData) + public static void Write8(uint address, byte aData) { *(uint*)address = aData; } @@ -49,7 +49,7 @@ static protected void Write8(uint address, byte aData) /// /// A address to write to. /// A data. - static protected void Write16(uint address, ushort aData) + public static void Write16(uint address, ushort aData) { *(uint*)address = aData; } @@ -59,7 +59,7 @@ static protected void Write16(uint address, ushort aData) /// /// An address to write to. /// A data. - static protected void Write32(uint address, uint aData) + public static void Write32(uint address, uint aData) { *(uint*)address = aData; } @@ -69,7 +69,7 @@ static protected void Write32(uint address, uint aData) /// /// An address to read from. /// byte value. - static protected byte Read8(uint address) + public static byte Read8(uint address) { return (byte)*(uint*)address; } @@ -79,7 +79,7 @@ static protected byte Read8(uint address) /// /// An address to read from. /// ushort value. - static protected ushort Read16(uint address) + public static ushort Read16(uint address) { return (ushort)*(uint*)address; } @@ -89,7 +89,7 @@ static protected ushort Read16(uint address) /// /// An address to read from. /// uint value. - static protected uint Read32(uint address) + public static uint Read32(uint address) { return *(uint*)address; } diff --git a/source/Cosmos.Core/MemoryGroup/IOAPIC.cs b/source/Cosmos.Core/MemoryGroup/IOAPIC.cs deleted file mode 100644 index b6f14546b9..0000000000 --- a/source/Cosmos.Core/MemoryGroup/IOAPIC.cs +++ /dev/null @@ -1,44 +0,0 @@ -namespace Cosmos.Core.MemoryGroup -{ - /// - /// IO APIC IOGroup class. - /// - public class IOAPICMMIOGroup - { - public const ushort IOREGSEL = 0x00; - public const ushort IOWIN = 0x10; - public const ushort IOAPICID = 0x00; - public const ushort IOAPICVER = 0x01; - public const ushort IOAPICARB = 0x02; - public const ushort IOREDTBL = 0x10; - - /// - /// Ver port. - /// - public readonly MMIO Ver; - /// - /// RegSel port. - /// - public readonly MMIO RegSel; - /// - /// Win port. - /// - public readonly MMIO Win; - /// - /// RedTbl port. - /// - public readonly MMIO RedTbl; - - /// - /// Create new instance of the class. - /// - /// IO APIC Base Address. - internal IOAPICMMIOGroup(uint baseAddress) - { - Ver = new MMIO(baseAddress, IOAPICVER); - RegSel = new MMIO(baseAddress, IOREGSEL); - Win = new MMIO(baseAddress, IOWIN); - RedTbl = new MMIO(baseAddress, IOREDTBL); - } - } -} From a776f78c5b49c281122e0757c28cbe2dd51f5180 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 03:13:56 +0200 Subject: [PATCH 13/35] Delete Local APIC MMIO Group + Update Local APIC --- source/Cosmos.Core/IOAPIC.cs | 3 + source/Cosmos.Core/LocalAPIC.cs | 99 ++++++++++++++++-- source/Cosmos.Core/MemoryGroup/LocalAPIC.cs | 108 -------------------- 3 files changed, 92 insertions(+), 118 deletions(-) delete mode 100644 source/Cosmos.Core/MemoryGroup/LocalAPIC.cs diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 8b3b0ed329..d4184c48fc 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -21,6 +21,9 @@ public unsafe partial class IOAPIC public const byte IOAPICARB = 0x02; public const byte IOREDTBL = 0x10; + /// + /// IO APIC Base Address. + /// private static uint Address = 0; /// diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index afff3932b2..cbcab92148 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -12,31 +12,110 @@ namespace Cosmos.Core /// public static unsafe class LocalAPIC { + public const ushort LAPIC_ID = 0x0020; + public const ushort LAPIC_VER = 0x0030; + public const ushort LAPIC_TPR = 0x0080; + public const ushort LAPIC_APR = 0x0090; + public const ushort LAPIC_PPR = 0x00a0; + public const ushort LAPIC_EOI = 0x00b0; + public const ushort LAPIC_RRD = 0x00c0; + public const ushort LAPIC_LDR = 0x00d0; + public const ushort LAPIC_DFR = 0x00e0; + public const ushort LAPIC_SVR = 0x00f0; + public const ushort LAPIC_ISR = 0x0100; + public const ushort LAPIC_TMR = 0x0180; + public const ushort LAPIC_IRR = 0x0200; + public const ushort LAPIC_ESR = 0x0280; + public const ushort LAPIC_ICRLO = 0x0300; + public const ushort LAPIC_ICRHI = 0x0310; + public const ushort LAPIC_TIMER = 0x0320; + public const ushort LAPIC_THERMAL = 0x0330; + public const ushort LAPIC_PERF = 0x0340; + public const ushort LAPIC_LINT0 = 0x0350; + public const ushort LAPIC_LINT1 = 0x0360; + public const ushort LAPIC_ERROR = 0x0370; + public const ushort LAPIC_TICR = 0x0380; + public const ushort LAPIC_TCCR = 0x0390; + public const ushort LAPIC_TDCR = 0x03e0; + + public const ushort ICR_FIXED = 0x00000000; + public const ushort ICR_LOWEST = 0x00000100; + public const ushort ICR_SMI = 0x00000200; + public const ushort ICR_NMI = 0x00000400; + public const ushort ICR_INIT = 0x00000500; + public const ushort ICR_STARTUP = 0x00000600; + + public const ushort ICR_PHYSICAL = 0x00000000; + public const ushort ICR_LOGICAL = 0x00000800; + + public const ushort ICR_IDLE = 0x00000000; + public const ushort ICR_SEND_PENDING = 0x00001000; + + public const ushort ICR_DEASSERT = 0x00000000; + public const ushort ICR_ASSERT = 0x00004000; + + public const ushort ICR_EDGE = 0x00000000; + public const ushort ICR_LEVEL = 0x00008000; + + public const int ICR_NO_SHORTHAND = 0x00000000; + public const int ICR_SELF = 0x00040000; + public const int ICR_ALL_INCLUDING_SELF = 0x00080000; + public const int ICR_ALL_EXCLUDING_SELF = 0x000c0000; + + public const int ICR_DESTINATION_SHIFT = 24; + /// - /// Local APIC IO group. + /// Local APIC Base Address. /// - internal static APICMMIOGroup IO; + private static uint Address = 0; /// /// Initialize local APIC. /// public static void Initialize() { + if (ACPI.MADT == null) + { + Global.mDebugger.Send("Can't initialize Local APIC"); + return; + } + Global.PIC.Disable(); - IO = new APICMMIOGroup(ACPI.MADT->LocalAPICAddress); + Address = ACPI.MADT->LocalAPICAddress; + + Global.mDebugger.Send("Local APIC address:0x" + Address.ToString("X")); //Enable All Interrupts - IO.Tpr.DWord = 0; + Out(LAPIC_TPR, 0); // Logical Destination Mode - IO.Tpr.DWord = 0xffffffff; // Flat mode - IO.Ldr.DWord = 0 << 24; // All cpus use logical id 0 + Out(LAPIC_DFR, 0xffffffff); // Flat mode + Out(LAPIC_LDR, 0x01000000); // All cpus use logical id 1 // Configure Spurious Interrupt Vector Register - IO.Svr.DWord = 0x100 | 0xff; + Out(LAPIC_SVR, 0x100 | 0xFF); - Console.WriteLine("Local APIC initialized"); + Global.mDebugger.Send("Local APIC " + GetId() + " initialized"); + } + + /// + /// IO APIC MMIO Out. + /// + /// IO APIC Register. + /// Data. + public static void Out(uint reg, uint val) + { + MMIOBase.Write32(Address + reg, val); + } + + /// + /// IO APIC MMIO In. + /// + /// IO APIC Register. + public static uint In(uint reg) + { + return MMIOBase.Read32(Address + reg); } /// @@ -44,7 +123,7 @@ public static void Initialize() /// public static void EndOfInterrupt() { - IO.EndOfInterrupts.DWord = 0; + Out(LAPIC_EOI, 0); } /// @@ -53,7 +132,7 @@ public static void EndOfInterrupt() /// integer value. public static uint GetId() { - return IO.Id.DWord >> 24; + return In(LAPIC_ID) >> 24; } } } diff --git a/source/Cosmos.Core/MemoryGroup/LocalAPIC.cs b/source/Cosmos.Core/MemoryGroup/LocalAPIC.cs deleted file mode 100644 index 32c75da9b8..0000000000 --- a/source/Cosmos.Core/MemoryGroup/LocalAPIC.cs +++ /dev/null @@ -1,108 +0,0 @@ -namespace Cosmos.Core.MemoryGroup -{ - /// - /// Local APIC IOGroup class. - /// - public class APICMMIOGroup - { - public const ushort LAPIC_ID = 0x0020; - public const ushort LAPIC_VER = 0x0030; - public const ushort LAPIC_TPR = 0x0080; - public const ushort LAPIC_APR = 0x0090; - public const ushort LAPIC_PPR = 0x00a0; - public const ushort LAPIC_EOI = 0x00b0; - public const ushort LAPIC_RRD = 0x00c0; - public const ushort LAPIC_LDR = 0x00d0; - public const ushort LAPIC_DFR = 0x00e0; - public const ushort LAPIC_SVR = 0x00f0; - public const ushort LAPIC_ISR = 0x0100; - public const ushort LAPIC_TMR = 0x0180; - public const ushort LAPIC_IRR = 0x0200; - public const ushort LAPIC_ESR = 0x0280; - public const ushort LAPIC_ICRLO = 0x0300; - public const ushort LAPIC_ICRHI = 0x0310; - public const ushort LAPIC_TIMER = 0x0320; - public const ushort LAPIC_THERMAL = 0x0330; - public const ushort LAPIC_PERF = 0x0340; - public const ushort LAPIC_LINT0 = 0x0350; - public const ushort LAPIC_LINT1 = 0x0360; - public const ushort LAPIC_ERROR = 0x0370; - public const ushort LAPIC_TICR = 0x0380; - public const ushort LAPIC_TCCR = 0x0390; - public const ushort LAPIC_TDCR = 0x03e0; - - public const ushort ICR_FIXED = 0x00000000; - public const ushort ICR_LOWEST = 0x00000100; - public const ushort ICR_SMI = 0x00000200; - public const ushort ICR_NMI = 0x00000400; - public const ushort ICR_INIT = 0x00000500; - public const ushort ICR_STARTUP = 0x00000600; - - public const ushort ICR_PHYSICAL = 0x00000000; - public const ushort ICR_LOGICAL = 0x00000800; - - public const ushort ICR_IDLE = 0x00000000; - public const ushort ICR_SEND_PENDING = 0x00001000; - - public const ushort ICR_DEASSERT = 0x00000000; - public const ushort ICR_ASSERT = 0x00004000; - - public const ushort ICR_EDGE = 0x00000000; - public const ushort ICR_LEVEL = 0x00008000; - - public const int ICR_NO_SHORTHAND = 0x00000000; - public const int ICR_SELF = 0x00040000; - public const int ICR_ALL_INCLUDING_SELF = 0x00080000; - public const int ICR_ALL_EXCLUDING_SELF = 0x000c0000; - - public const int ICR_DESTINATION_SHIFT = 24; - - /// - /// Id port. - /// - public readonly MMIO Id; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO EndOfInterrupts; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO Tpr; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO Dfr; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO Ldr; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO Svr; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO ICRHI; - /// - /// EndOfInterrupts port. - /// - public readonly MMIO ICRLO; - - /// - /// Create new instance of the class. - /// - internal APICMMIOGroup(uint baseAddress) - { - Id = new MMIO(baseAddress, LAPIC_ID); - EndOfInterrupts = new MMIO(baseAddress, LAPIC_EOI); - Tpr = new MMIO(baseAddress, LAPIC_TPR); - Dfr = new MMIO(baseAddress, LAPIC_DFR); - Ldr = new MMIO(baseAddress, LAPIC_LDR); - Svr = new MMIO(baseAddress, LAPIC_SVR); - ICRHI = new MMIO(baseAddress, LAPIC_ICRHI); - ICRLO = new MMIO(baseAddress, LAPIC_ICRLO); - } - } -} From 1667b3bdd5c6a1d028eb8e1bac3a4e189d3c9d5d Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 03:58:34 +0200 Subject: [PATCH 14/35] Remove PIC init since it's already done in CosmosAssembler + Better boot logs --- source/Cosmos.Core/IOAPIC.cs | 5 +++- source/Cosmos.Core/PIC.cs | 58 ++---------------------------------- source/Cosmos.HAL2/Global.cs | 8 ++--- 3 files changed, 11 insertions(+), 60 deletions(-) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index d4184c48fc..5e0a45160f 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -52,6 +52,9 @@ public static void Initialize() SetEntry((byte)i, 1 << 16); } + // Enable IO APIC entries + SetEntry((byte)ACPI.RemapIRQ(0x00), 0x20); + Global.mDebugger.Send("IO APIC " + GetId() + " Initialized"); } @@ -93,7 +96,7 @@ public static void SetEntry(byte index, ulong data) /// Irq ID. public static void SetEntry(uint irq) { - SetEntry((byte)ACPI.RemapIRQ(irq), irq); + SetEntry((byte)ACPI.RemapIRQ(irq), 0x20 + irq); } /// diff --git a/source/Cosmos.Core/PIC.cs b/source/Cosmos.Core/PIC.cs index ed7e4ac061..f0655c7e95 100644 --- a/source/Cosmos.Core/PIC.cs +++ b/source/Cosmos.Core/PIC.cs @@ -134,68 +134,16 @@ private void Remap(byte masterStart, byte masterMask, byte slaveStart, byte slav //IOPort.Wait(); } - /// - /// Initialize PIC. - /// - /// A PIC. - /// A base data port. - /// Slave relationship message. - /// A mask. - protected void Init(IOGroup.PIC aPIC, byte aBase, byte aIDunno, byte aMask) - { - // We need to remap the PIC interrupt lines to the CPU. The BIOS sets - // them in a way compatible for 16 bit mode, but in a way that causes problems - // for 32 bit mode. - // The only way to remap them however is to completely reinitialize the PICs. - - byte xOldMask = aPIC.Data.Byte; - - //#define ICW1_ICW4 0x01 /* ICW4 (not) needed */ - //#define ICW1_SINGLE 0x02 /* Single (cascade) mode */ - //#define ICW1_INTERVAL4 0x04 /* Call address interval 4 (8) */ - //#define ICW1_LEVEL 0x08 /* Level triggered (edge) mode */ - Master.Cmd.Byte = (byte) Cmd.Init | 0x01; - IOPort.Wait(); - - // ICW2 - Master.Data.Byte = aBase; - IOPort.Wait(); - - // ICW3 - // Somehow tells them about master/slave relationship - Master.Data.Byte = aIDunno; - IOPort.Wait(); - - //#define ICW4_AUTO 0x02 /C:\Data\Cosmos\source2\Kernel\System\Hardware\Core\Cosmos.Core\CPU.cs* Auto (normal) EOI */ - //#define ICW4_BUF_SLAVE 0x08 /* Buffered mode/slave */ - //#define ICW4_BUF_MASTER 0x0C /* Buffered mode/master */ - //#define ICW4_SFNM 0x10 /* Special fully nested (not) */ - //0x01 8086/88 (MCS-80/85) mode - Master.Data.Byte = 0x01; - IOPort.Wait(); - - // Set mask - Master.Data.Byte = aMask; - IOPort.Wait(); - } - /// /// Disable PIC. /// public void Disable() { - //init - Master.Cmd.Byte = 0x11; - Slave.Cmd.Byte = 0x11; - Master.Data.Byte = 0x20; - Slave.Data.Byte = 40; - Master.Data.Byte = 0x04; - Slave.Data.Byte = 0x02; - Master.Data.Byte = 0x01; - Slave.Data.Byte = 0x01; - + //disable Master.Data.Byte = 0xFF; + IOPort.Wait(); Slave.Data.Byte = 0xFF; + IOPort.Wait(); } } } diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index c87d338360..0e3b8b487b 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -44,16 +44,14 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In mDebugger.Send("ACPI Init"); ACPI.Start(); - Console.WriteLine("Starting Local APIC"); + Console.WriteLine("Starting APIC"); mDebugger.Send("Local APIC Init"); LocalAPIC.Initialize(); - - Console.WriteLine("Starting IO APIC"); mDebugger.Send("IO APIC Init"); IOAPIC.Initialize(); + Console.WriteLine("Starting PIT"); PIT = new PIT(); - PS2Controller = new PS2Controller(); //TODO Redo this - Global init should be other. // Move PCI detection to hardware? Or leave it in core? Is Core PC specific, or deeper? @@ -71,7 +69,9 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In // http://wiki.osdev.org/%228042%22_PS/2_Controller#Initialising_the_PS.2F2_Controller // TODO: USB should be initialized before the PS/2 controller // TODO: ACPI should be used to check if a PS/2 controller exists + Console.WriteLine("Starting PS/2 Controller"); mDebugger.Send("PS/2 Controller Init"); + PS2Controller = new PS2Controller(); if (InitPS2) { PS2Controller.Initialize(InitScrollWheel); From 09ba3beb41ecc2e1d756b8e57073849916ce4e4a Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 05:08:02 +0200 Subject: [PATCH 15/35] Remove useless EOI + Useless PIT timer --- source/Cosmos.Core/IOAPIC.cs | 3 --- source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs | 1 - 2 files changed, 4 deletions(-) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 5e0a45160f..7d619bcd6e 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -52,9 +52,6 @@ public static void Initialize() SetEntry((byte)i, 1 << 16); } - // Enable IO APIC entries - SetEntry((byte)ACPI.RemapIRQ(0x00), 0x20); - Global.mDebugger.Send("IO APIC " + GetId() + " Initialized"); } diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index a4184d0660..043502cc16 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -124,7 +124,6 @@ protected void HandleNetworkInterrupt(ref INTs.IRQContext aContext) } StatusRegister = cur_status; - LocalAPIC.EndOfInterrupt(); } /// From d75016dcdb7878524389ba9da58b120fe21ea3e4 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 08:47:52 +0200 Subject: [PATCH 16/35] Change PIT from IRQ0 to IRQ2 + Set APIC Timer to IRQ0 --- source/Cosmos.HAL2/APICTimer.cs | 86 +++++++++++++++++++++++++++++++++ source/Cosmos.HAL2/Global.cs | 3 ++ source/Cosmos.HAL2/PIT.cs | 6 ++- 3 files changed, 93 insertions(+), 2 deletions(-) create mode 100644 source/Cosmos.HAL2/APICTimer.cs diff --git a/source/Cosmos.HAL2/APICTimer.cs b/source/Cosmos.HAL2/APICTimer.cs new file mode 100644 index 0000000000..372c514ade --- /dev/null +++ b/source/Cosmos.HAL2/APICTimer.cs @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Cosmos.Core; +using Cosmos.Core.MemoryGroup; + +namespace Cosmos.HAL +{ + /// + /// Local APIC Timer class. + /// + public static class APICTimer + { + /// + /// Tick Counter. + /// + //public static uint Tick = 0; + + /// + /// Tick Frequency. + /// + public static uint TickFrequency = 0; + + /// + /// Initialize local APIC timer. + /// + public static void Initialize() + { + INTs.SetIrqHandler(0, HandleApicTimer); + + // setup timer, Intel IA manual 10-16 Vol. 3A + LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); // divide timer counts by 1 + + Calibrate(); + + if (TickFrequency == 0) + { + throw new Exception("APIC timer is not calibrated"); + } + + //Start timer + LocalAPIC.Out(LocalAPIC.LAPIC_TIMER, 0x20000 | 0x20); // periodic, bind to corresponding IRQ + LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); + SetTimerCount(TickFrequency / 100); + + Global.mDebugger.Send("Local APIC Timer Initialized"); + } + + public static void HandleApicTimer(ref INTs.IRQContext aContext) + { + //Tick++; + } + + /// + /// Stop local APIC timer. + /// + public static void Stop() + { + LocalAPIC.Out(LocalAPIC.LAPIC_TIMER, 0x10000); + } + + public static void SetTimerCount(uint count) + { + LocalAPIC.Out(LocalAPIC.LAPIC_TICR, count); + } + + public static void Calibrate() + { + SetTimerCount(0xFFFFFFFF); // Set APIC init counter to -1 + + Global.PIT.Wait(1000); // PIT sleep for 1000ms (10000µs) + + Stop(); + + ulong ticks = 0xFFFFFFFF - LocalAPIC.In(LocalAPIC.LAPIC_TCCR); // Now we know how often the APIC timer has ticked in 10ms + + Global.mDebugger.Send("APIC timer ticks per 10ms: " + ticks); + + TickFrequency = (uint)(ticks * 1000 / 1000); + + Global.mDebugger.Send("APIC timer tick frequency: " + TickFrequency); + } + } +} diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index 0e3b8b487b..f0067dac8a 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -53,6 +53,9 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In Console.WriteLine("Starting PIT"); PIT = new PIT(); + mDebugger.Send("Local APIC Timer Init"); + APICTimer.Initialize(); + //TODO Redo this - Global init should be other. // Move PCI detection to hardware? Or leave it in core? Is Core PC specific, or deeper? // If we let hardware do it, we need to protect it from being used by System. diff --git a/source/Cosmos.HAL2/PIT.cs b/source/Cosmos.HAL2/PIT.cs index 6f68ed4e2b..9dfe3d6c47 100644 --- a/source/Cosmos.HAL2/PIT.cs +++ b/source/Cosmos.HAL2/PIT.cs @@ -72,8 +72,10 @@ public void Dispose() public PIT() { - INTs.SetIrqHandler(0x00, HandleIRQ); - T0Countdown = 65535; + INTs.SetIntHandler(0x20 + 15, HandleIRQ); + IOAPIC.SetEntry(2); //PIT is mapped to IOAPIC via IRQ2 instead of IRQ0 + + T0Countdown = 65535; } public ushort T0Countdown From 882f516e2af5eb364741c2e84938263462233cd4 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 12 Jun 2022 10:18:56 +0200 Subject: [PATCH 17/35] Add Local APIC ID in SetEntry --- source/Cosmos.Core/IOAPIC.cs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 7d619bcd6e..c41e9f0308 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -81,10 +81,11 @@ public static uint In(byte reg) /// /// Entry index. /// Data. - public static void SetEntry(byte index, ulong data) + /// Local APIC Id. + public static void SetEntry(byte index, ulong data, uint lapicId = 0) { Out((byte)(IOREDTBL + index * 2), (uint)data); - Out((byte)(IOREDTBL + index * 2 + 1), (uint)(data >> 32)); + Out((byte)(IOREDTBL + index * 2 + 1), (uint)(lapicId << 24)); } /// From 965f3edafee7a2950692dfaab1ebfc01f653e03a Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Mon, 13 Jun 2022 01:30:32 +0200 Subject: [PATCH 18/35] Fix IRQ conflict between PIT and ATAPI --- source/Cosmos.Core/INTs.cs | 7 +++++-- source/Cosmos.Core/IOAPIC.cs | 6 +++--- source/Cosmos.Core/LocalAPIC.cs | 7 +++++++ source/Cosmos.HAL2/APICTimer.cs | 14 ++++++++++---- 4 files changed, 25 insertions(+), 9 deletions(-) diff --git a/source/Cosmos.Core/INTs.cs b/source/Cosmos.Core/INTs.cs index 4a9eb83a96..1c72eb6211 100644 --- a/source/Cosmos.Core/INTs.cs +++ b/source/Cosmos.Core/INTs.cs @@ -297,7 +297,7 @@ public static void HandleInterrupt_Default(ref IRQContext aContext) { #region Default Interrupt Handlers /// - /// IRQ 0 - System timer. Reserved for the system. Cannot be changed by a user. + /// IRQ 0 - System (APIC) timer. Reserved for the system. Cannot be changed by a user. /// /// IRQ context. public static void HandleInterrupt_20(ref IRQContext aContext) { @@ -379,13 +379,16 @@ public static void HandleInterrupt_2B(ref IRQContext aContext) { LocalAPIC.EndOfInterrupt(); } + /// + /// IRQ 12 - (Added for PIT Timer). + /// + /// IRQ context. public static void HandleInterrupt_2C(ref IRQContext aContext) { IRQ(0x2C, ref aContext); LocalAPIC.EndOfInterrupt(); } - public static void HandleInterrupt_2D(ref IRQContext aContext) { IRQ(0x2D, ref aContext); LocalAPIC.EndOfInterrupt(); diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index c41e9f0308..9d55c0cf38 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -46,10 +46,10 @@ public static void Initialize() Global.mDebugger.Send("IO APIC pins:" + count); - //Disable All Entries + //Disable All Entries, Make all interrupts edge triggered and not routed to any CPUs for (uint i = 0; i < count; ++i) { - SetEntry((byte)i, 1 << 16); + SetEntry((byte)i, (1 << 16) | 0x20 + i); } Global.mDebugger.Send("IO APIC " + GetId() + " Initialized"); @@ -85,7 +85,7 @@ public static uint In(byte reg) public static void SetEntry(byte index, ulong data, uint lapicId = 0) { Out((byte)(IOREDTBL + index * 2), (uint)data); - Out((byte)(IOREDTBL + index * 2 + 1), (uint)(lapicId << 24)); + Out((byte)(IOREDTBL + index * 2 + 1), (lapicId << 24)); } /// diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index cbcab92148..d3a9c3de26 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -96,6 +96,13 @@ public static void Initialize() // Configure Spurious Interrupt Vector Register Out(LAPIC_SVR, 0x100 | 0xFF); + // clear error status + Out(LAPIC_ESR, 0); + // clear unfinished interrupt + Out(LAPIC_EOI, 0); + // accept all level of interrupts + Out(LAPIC_TPR, 0); + Global.mDebugger.Send("Local APIC " + GetId() + " initialized"); } diff --git a/source/Cosmos.HAL2/APICTimer.cs b/source/Cosmos.HAL2/APICTimer.cs index 372c514ade..910dad716b 100644 --- a/source/Cosmos.HAL2/APICTimer.cs +++ b/source/Cosmos.HAL2/APICTimer.cs @@ -16,7 +16,7 @@ public static class APICTimer /// /// Tick Counter. /// - //public static uint Tick = 0; + public static uint Tick = 0; /// /// Tick Frequency. @@ -28,7 +28,7 @@ public static class APICTimer /// public static void Initialize() { - INTs.SetIrqHandler(0, HandleApicTimer); + INTs.SetIntHandler(0x20, HandleApicTimer); // setup timer, Intel IA manual 10-16 Vol. 3A LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); // divide timer counts by 1 @@ -40,19 +40,23 @@ public static void Initialize() throw new Exception("APIC timer is not calibrated"); } - //Start timer LocalAPIC.Out(LocalAPIC.LAPIC_TIMER, 0x20000 | 0x20); // periodic, bind to corresponding IRQ LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); - SetTimerCount(TickFrequency / 100); Global.mDebugger.Send("Local APIC Timer Initialized"); } public static void HandleApicTimer(ref INTs.IRQContext aContext) { + Global.mDebugger.Send("APIC Timer IRQ"); //Tick++; } + public static void Start() + { + SetTimerCount(TickFrequency / 100); + } + /// /// Stop local APIC timer. /// @@ -68,6 +72,8 @@ public static void SetTimerCount(uint count) public static void Calibrate() { + Global.mDebugger.Send("Calibrating APIC timer..."); + SetTimerCount(0xFFFFFFFF); // Set APIC init counter to -1 Global.PIT.Wait(1000); // PIT sleep for 1000ms (10000µs) From 562a3144031ca184cce28d9f7a49a34c2043dd89 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Mon, 13 Jun 2022 01:41:26 +0200 Subject: [PATCH 19/35] =?UTF-8?q?Fix=20IRQ=20conflict=20between=20PIT=20an?= =?UTF-8?q?d=20PS/2=20Mouse=20=F0=9F=A4=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/Cosmos.Core/INTs.cs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/source/Cosmos.Core/INTs.cs b/source/Cosmos.Core/INTs.cs index 1c72eb6211..322cd36257 100644 --- a/source/Cosmos.Core/INTs.cs +++ b/source/Cosmos.Core/INTs.cs @@ -380,7 +380,7 @@ public static void HandleInterrupt_2B(ref IRQContext aContext) { } /// - /// IRQ 12 - (Added for PIT Timer). + /// IRQ 12 - PS/2 Mouse. Reserved for the system. /// /// IRQ context. public static void HandleInterrupt_2C(ref IRQContext aContext) { @@ -389,6 +389,11 @@ public static void HandleInterrupt_2C(ref IRQContext aContext) { LocalAPIC.EndOfInterrupt(); } + + /// + /// IRQ 13 - (Added for PIT Timer). + /// + /// IRQ context. public static void HandleInterrupt_2D(ref IRQContext aContext) { IRQ(0x2D, ref aContext); LocalAPIC.EndOfInterrupt(); From 2e66c2eced5c0de794e8dec07513f24c08ee27a4 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Mon, 13 Jun 2022 05:41:01 +0200 Subject: [PATCH 20/35] Add MSI detection to PCI device + Fix PIT again (forgot to commit file lol) --- source/Cosmos.Core/ACPI.cs | 2 ++ source/Cosmos.Core/INTs.cs | 1 - source/Cosmos.HAL2/PCIDevice.cs | 51 ++++++++++++++++++++++++++++++++- source/Cosmos.HAL2/PIT.cs | 6 ++-- 4 files changed, 55 insertions(+), 5 deletions(-) diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index 0e830eda07..b8bc4e8943 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -649,6 +649,8 @@ public static uint RemapIRQ(uint irq) if (ovr->Source == irq) { + Global.mDebugger.Send("IRQ" + irq + " remapped to IRQ" + ovr->Interrupt); + return ovr->Interrupt; } } diff --git a/source/Cosmos.Core/INTs.cs b/source/Cosmos.Core/INTs.cs index 322cd36257..e5611146dd 100644 --- a/source/Cosmos.Core/INTs.cs +++ b/source/Cosmos.Core/INTs.cs @@ -389,7 +389,6 @@ public static void HandleInterrupt_2C(ref IRQContext aContext) { LocalAPIC.EndOfInterrupt(); } - /// /// IRQ 13 - (Added for PIT Timer). /// diff --git a/source/Cosmos.HAL2/PCIDevice.cs b/source/Cosmos.HAL2/PCIDevice.cs index 86008c7e1d..651e594f74 100644 --- a/source/Cosmos.HAL2/PCIDevice.cs +++ b/source/Cosmos.HAL2/PCIDevice.cs @@ -108,6 +108,10 @@ public enum Config : byte /// public bool Claimed { get; set; } + public bool SupportMsi = false; + + public byte MsiOffset = 0; + public PCIDevice(uint bus, uint slot, uint function) { this.bus = bus; @@ -133,6 +137,8 @@ public PCIDevice(uint bus, uint slot, uint function) InterruptPIN = (PCIInterruptPIN)ReadRegister8((byte)Config.InterruptPIN); InterruptLine = ReadRegister8((byte)Config.InterruptLine); + CheckMSI(); + if ((uint)VendorID == 0xFF && (uint)DeviceID == 0xFFFF) { DeviceExists = false; @@ -150,7 +156,7 @@ public PCIDevice(uint bus, uint slot, uint function) BaseAddressBar[3] = new PCIBaseAddressBar(ReadRegister32(0x1C)); BaseAddressBar[4] = new PCIBaseAddressBar(ReadRegister32(0x20)); BaseAddressBar[5] = new PCIBaseAddressBar(ReadRegister32(0x24)); - } + } } public void EnableDevice() @@ -186,6 +192,49 @@ public static ushort GetVendorID(ushort Bus, ushort Slot, ushort Function) return (ushort)(IO.ConfigDataPort.DWord >> ((0x0 % 4) * 8) & 0xFFFF); } + /// + /// Check if PCI Device supports MSI + /// + /// Boolean value. + private bool CheckMSI() + { + byte offset = ReadRegister8((byte)Config.CapabilityPointer); + + while (offset > 0) + { + byte id = ReadRegister8(offset); + + switch (id) + { + case 0x05: + SupportMsi = true; + MsiOffset = offset; + return true; + } + offset = ReadRegister8((byte)(offset + 1)); + } + + return false; + } + + /// + /// Configure PCI Device to use MSI for interrupts. + /// + public void SetMSI(byte vector) + { + if (!SupportMsi) + { + return; + } + + /* + ushort msgControl = ReadRegister16((byte)(MsiOffset + 2)); + WriteRegister32((byte)(MsiOffset + 0x04), (uint)((0x0FEE << 20) | (0 << 12))); //use only APIC 0 since we don't support multiprocessing yet! + WriteRegister32((byte)(MsiOffset + (((msgControl << 7) & 1) == 1 ? 0x0C : 0x08)), vector); + WriteRegister16((byte)(MsiOffset + 2), (ushort)((msgControl | 1) & ~(0b111 << 4))); + */ + } + #region IOReadWrite /// /// Read register - 8-bit. diff --git a/source/Cosmos.HAL2/PIT.cs b/source/Cosmos.HAL2/PIT.cs index 9dfe3d6c47..367b598d4f 100644 --- a/source/Cosmos.HAL2/PIT.cs +++ b/source/Cosmos.HAL2/PIT.cs @@ -72,11 +72,11 @@ public void Dispose() public PIT() { - INTs.SetIntHandler(0x20 + 15, HandleIRQ); - IOAPIC.SetEntry(2); //PIT is mapped to IOAPIC via IRQ2 instead of IRQ0 + INTs.SetIntHandler(0x20 + 13, HandleIRQ); + IOAPIC.SetEntry(2, 0x20 + 13); //PIT is mapped to IOAPIC via IRQ2 instead of IRQ0 T0Countdown = 65535; - } + } public ushort T0Countdown { From cc48ad2d63fb4217ef5632103dff831d3d02677c Mon Sep 17 00:00:00 2001 From: Misha <46088515+MishaTY@users.noreply.github.com> Date: Mon, 13 Jun 2022 21:45:53 +0200 Subject: [PATCH 21/35] implement reboot [broken] --- source/Cosmos.Core/ACPI.cs | 83 +++++++++++++++++++++++++++++++------- 1 file changed, 69 insertions(+), 14 deletions(-) diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index b8bc4e8943..c274d44fb4 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -103,7 +103,7 @@ public struct AcpiHeader /// FADT struct. /// [StructLayout(LayoutKind.Sequential, Pack = 1)] - private struct FADTPtr + public struct FADTPtr { /// /// ACPI Header. @@ -167,8 +167,39 @@ private struct FADTPtr public byte Reserved2; public uint Flags; + + // 12 public byte structure; see below for details + public GenericAddressStructure ResetReg; + + public byte ResetValue; + public byte Reserved3; + public byte Reserved34; + public byte Reserved35; + + // 64bit pointers - Available on ACPI 2.0+ + public ulong X_FirmwareControl; + public ulong X_Dsdt; + + public GenericAddressStructure X_PM1aEventBlock; + public GenericAddressStructure X_PM1bEventBlock; + public GenericAddressStructure X_PM1aControlBlock; + public GenericAddressStructure X_PM1bControlBlock; + public GenericAddressStructure X_PM2ControlBlock; + public GenericAddressStructure X_PMTimerBlock; + public GenericAddressStructure X_GPE0Block; + public GenericAddressStructure X_GPE1Block; } + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct GenericAddressStructure + { + public byte AddressSpace; + public byte BitWidth; + public byte BitOffset; + public byte AccessSize; + public ulong Address; + }; + /// /// MADT struct. /// @@ -313,7 +344,7 @@ struct ApicInterruptOverride /// /// IO port. /// - private static IOPort smiIO, pm1aIO, pm1bIO; + private static IOPort smiIO, pm1aIO, pm1bIO, ResetRegister; // ACPI variables /// @@ -329,6 +360,10 @@ struct ApicInterruptOverride /// private static byte ACPI_DISABLE; /// + /// Reset value to write into reset register when you need to reboot + /// + private static byte ResetValue; + /// /// PM1a CNT /// private static int* PM1a_CNT; @@ -360,6 +395,10 @@ struct ApicInterruptOverride /// Global IO APIC. /// public static ApicIOApic* IOAPIC; + /// + /// FADT table + /// + public static FADTPtr* FADT; /// /// Check ACPI header. @@ -429,7 +468,6 @@ public static void Start(bool initialize = true, bool enable = true) /// Thrown on IO error. public static void Shutdown() { - Console.Clear(); if (PM1a_CNT == null) { Init(); @@ -452,7 +490,22 @@ public static void Shutdown() /// Thrown always. public static void Reboot() { - throw new NotImplementedException("ACPI Reset not implemented yet."); //TODO + if (PM1a_CNT == null) + { + Init(); + } + + var header = FADT->Header; + if (header.Revision >= 2 && (FADT->Flags & (1 << 10)) != 0) + { + ResetRegister.Byte = ResetValue; + } + else + { + throw new NotImplementedException("Hardware does not support ACPI reboot."); + } + + throw new NotImplementedException("ACPI reboot failed."); } /// @@ -493,12 +546,12 @@ private static void ParseDT(AcpiHeader *hdr) { Global.mDebugger.Send("Parse FACP"); - var Fadt = (FADTPtr*)hdr; + FADT = (FADTPtr*)hdr; - if (acpiCheckHeader((byte*)Fadt->Dsdt, "DSDT") == 0) + if (acpiCheckHeader((byte*)FADT->Dsdt, "DSDT") == 0) { - byte* S5Addr = (byte*)Fadt->Dsdt + sizeof(AcpiHeader); - int dsdtLength = *((int*)Fadt->Dsdt + 1) - sizeof(AcpiHeader); + byte* S5Addr = (byte*)FADT->Dsdt + sizeof(AcpiHeader); + int dsdtLength = *((int*)FADT->Dsdt + 1) - sizeof(AcpiHeader); while (0 < dsdtLength--) { @@ -526,17 +579,19 @@ private static void ParseDT(AcpiHeader *hdr) S5Addr++; } SLP_TYPb = (short)(*(S5Addr) << 10); - SMI_CMD = (int*)Fadt->SMI_CommandPort; - ACPI_ENABLE = Fadt->AcpiEnable; - ACPI_DISABLE = Fadt->AcpiDisable; - PM1a_CNT = (int*)Fadt->PM1aControlBlock; - PM1b_CNT = (int*)Fadt->PM1bControlBlock; - PM1_CNT_LEN = Fadt->PM1ControlLength; + SMI_CMD = (int*)FADT->SMI_CommandPort; + ACPI_ENABLE = FADT->AcpiEnable; + ACPI_DISABLE = FADT->AcpiDisable; + PM1a_CNT = (int*)FADT->PM1aControlBlock; + PM1b_CNT = (int*)FADT->PM1bControlBlock; + PM1_CNT_LEN = FADT->PM1ControlLength; + ResetValue = FADT->ResetValue; SLP_EN = 1 << 13; smiIO = new IOPort((ushort)SMI_CMD); pm1aIO = new IOPort((ushort)PM1a_CNT); pm1bIO = new IOPort((ushort)PM1b_CNT); + ResetRegister = new IOPort((ushort)FADT->ResetReg.Address); } } } From 2322aea22a401067118543b347ca8f478d8619a2 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Tue, 14 Jun 2022 00:04:46 +0200 Subject: [PATCH 22/35] Move ACPI + Add AML Parser + DSDT Header --- source/Cosmos.Core/{ => ACPI}/ACPI.cs | 224 ++++++--- source/Cosmos.Core/ACPI/AML/Definitions.cs | 22 + .../Cosmos.Core/ACPI/AML/InterpreterArgs.cs | 163 ++++++ source/Cosmos.Core/ACPI/AML/ObjectType.cs | 49 ++ source/Cosmos.Core/ACPI/AML/OpCode.cs | 72 +++ source/Cosmos.Core/ACPI/AML/OpCodeClass.cs | 20 + source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs | 154 ++++++ source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs | 40 ++ source/Cosmos.Core/ACPI/AML/OpCodeTable.cs | 244 +++++++++ source/Cosmos.Core/ACPI/AML/OpCodeType.cs | 39 ++ source/Cosmos.Core/ACPI/AML/ParseArgs.cs | 162 ++++++ source/Cosmos.Core/ACPI/Parser/AMLOp.cs | 71 +++ source/Cosmos.Core/ACPI/Parser/Parser.cs | 472 ++++++++++++++++++ source/Cosmos.Core/ACPI/Parser2/ParseNode.cs | 29 ++ source/Cosmos.Core/ACPI/Parser2/Parser.cs | 395 +++++++++++++++ source/Cosmos.Core/MemoryBlock.cs | 27 + 16 files changed, 2118 insertions(+), 65 deletions(-) rename source/Cosmos.Core/{ => ACPI}/ACPI.cs (74%) create mode 100644 source/Cosmos.Core/ACPI/AML/Definitions.cs create mode 100644 source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs create mode 100644 source/Cosmos.Core/ACPI/AML/ObjectType.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCode.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeClass.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeTable.cs create mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeType.cs create mode 100644 source/Cosmos.Core/ACPI/AML/ParseArgs.cs create mode 100644 source/Cosmos.Core/ACPI/Parser/AMLOp.cs create mode 100644 source/Cosmos.Core/ACPI/Parser/Parser.cs create mode 100644 source/Cosmos.Core/ACPI/Parser2/ParseNode.cs create mode 100644 source/Cosmos.Core/ACPI/Parser2/Parser.cs diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs similarity index 74% rename from source/Cosmos.Core/ACPI.cs rename to source/Cosmos.Core/ACPI/ACPI.cs index c274d44fb4..99de73c9e5 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -1,7 +1,9 @@ -using Cosmos.Core; +using ACPILib.AML; +using ACPILib.Parser2; using Cosmos.Debug.Kernel; using System; using System.Collections.Generic; +using System.IO; using System.Runtime.InteropServices; using System.Text; @@ -419,7 +421,7 @@ static int acpiCheckHeader(byte* ptr, string sig) /// 0 - identical, -1 different. static int Compare(string c1, byte* c2) { - for (int i = 0; i < c1.Length; i++) + for (var i = 0; i < c1.Length; i++) { if (c1[i] != c2[i]) { return -1; } } @@ -434,14 +436,14 @@ static int Compare(string c1, byte* c2) static bool Check_RSD(uint address) { byte sum = 0; - byte* check = (byte*)address; + var check = (byte*)address; - for (int i = 0; i < 20; i++) + for (var i = 0; i < 20; i++) { - sum += *(check++); + sum += *check++; } - return (sum == 0); + return sum == 0; } /// @@ -502,10 +504,10 @@ public static void Reboot() } else { - throw new NotImplementedException("Hardware does not support ACPI reboot."); + throw new Exception("Hardware does not support ACPI reboot."); } - throw new NotImplementedException("ACPI reboot failed."); + throw new Exception("ACPI reboot failed."); } /// @@ -516,19 +518,19 @@ private static bool Init() { IOAPIC = null; var rsdp = RSDPAddress(); - byte* ptr = (byte*)rsdp; + var ptr = (byte*)rsdp; Global.mDebugger.Send("ACPI v" + rsdp->Revision); var rsdt = (AcpiHeader*)rsdp->RsdtAddress; ptr = (byte*)rsdt; - uint* p = (uint*)(rsdt + 1); - uint* end = (uint*)((byte*)rsdt + rsdt->Length); + var p = (uint*)(rsdt + 1); + var end = (uint*)((byte*)rsdt + rsdt->Length); while (p < end) { - uint address = *p++; + var address = *p++; ParseDT((AcpiHeader*)address); } @@ -536,7 +538,115 @@ private static bool Init() return true; } - private static void ParseDT(AcpiHeader *hdr) + private static uint SdtLength = 0; + + private static void ReadHeader(BinaryReader _reader) + { + Global.mDebugger.Send("SDT header:"); + + //Signature + Global.mDebugger.Send("\tSignature: " + Encoding.ASCII.GetString(_reader.ReadBytes(4))); + + //Length + SdtLength = _reader.ReadUInt32(); + Global.mDebugger.Send("\tLendth: " + SdtLength.ToString()); + + //Revision + Global.mDebugger.Send("\tRevision: " + _reader.ReadByte().ToString()); + + //Checksum + Global.mDebugger.Send("\tChecksum: " + _reader.ReadByte().ToString()); + + //OEM ID + Global.mDebugger.Send("\tOEM ID: " + Encoding.ASCII.GetString(_reader.ReadBytes(6))); + + //OEMTableID + Global.mDebugger.Send("\tOEMTableID: " + Encoding.ASCII.GetString(_reader.ReadBytes(8))); + + //OEMRevision + Global.mDebugger.Send("\tOEMRevision: " + _reader.ReadUInt32().ToString()); + + //OEMRevision + Global.mDebugger.Send("\tCreatorID: " + _reader.ReadUInt32().ToString()); + + //OEMRevision + Global.mDebugger.Send("\tCreatorRevision: " + _reader.ReadUInt32().ToString()); + } + + private static string ValueToString(object val) + { + if (val == null) + return "null"; + + if (val is string) + return "\"" + val.ToString() + "\""; + + if (val is byte) + return "0x" + ((byte)val).ToString("X2"); + + if (val.GetType().IsArray) + { + Array ar = (Array)val; + + string rt = ""; + + for (int x = 0; x < ar.Length; x++) + rt += ValueToString(ar.GetValue(x)) + (x < ar.Length - 1 ? ", " : string.Empty); + + return rt; + } + + if (val is ParseNode) + { + ParseNode node = (ParseNode)val; + + if (node.ConstantValue != null) + return ValueToString(node.ConstantValue); + } + + return val.ToString(); + } + + private static void PopulateNode(ParseNode op, int depth) + { + Global.mDebugger.Send("=========== DEPTH " + depth + " ==========="); + + if (!string.IsNullOrEmpty(op.Name)) + Global.mDebugger.Send(op.Name); + + if (op.Op != null) + { + Global.mDebugger.Send("OpCode = " + op.Op.ToString()); + Global.mDebugger.Send("Start = " + op.Start.ToString()); + Global.mDebugger.Send("Length = " + op.Length.ToString()); + Global.mDebugger.Send("End = " + op.End.ToString()); + if (op.ConstantValue != null) + { + Global.mDebugger.Send("Value = " + ValueToString(op.ConstantValue)); + } + } + + if (op.Arguments.Count > 0) + { + for (int x = 0; x < op.Op.ParseArgs.Length; x++) + { + if (op.Op.ParseArgs[x] == ParseArgFlags.DataObjectList || op.Op.ParseArgs[x] == ParseArgFlags.TermList || op.Op.ParseArgs[x] == ParseArgFlags.ObjectList) + continue; + + Global.mDebugger.Send(ValueToString(op.Arguments[x]) + " (" + op.Op.ParseArgs[x].ToString() + ")"); + } + } + + if (op.Nodes.Count > 0) + { + foreach (ParseNode ch in op.Nodes) + { + PopulateNode(ch, depth + 1); + } + } + } + + private static void ParseDT(AcpiHeader* hdr) { var signature = Encoding.ASCII.GetString(hdr->Signature, 4); @@ -548,52 +658,36 @@ private static void ParseDT(AcpiHeader *hdr) FADT = (FADTPtr*)hdr; + SMI_CMD = (int*)FADT->SMI_CommandPort; + ACPI_ENABLE = FADT->AcpiEnable; + ACPI_DISABLE = FADT->AcpiDisable; + PM1a_CNT = (int*)FADT->PM1aControlBlock; + PM1b_CNT = (int*)FADT->PM1bControlBlock; + PM1_CNT_LEN = FADT->PM1ControlLength; + SLP_EN = 1 << 13; + + smiIO = new IOPort((ushort)SMI_CMD); + pm1aIO = new IOPort((ushort)PM1a_CNT); + pm1bIO = new IOPort((ushort)PM1b_CNT); + ResetRegister = new IOPort((ushort)FADT->ResetReg.Address); + if (acpiCheckHeader((byte*)FADT->Dsdt, "DSDT") == 0) { - byte* S5Addr = (byte*)FADT->Dsdt + sizeof(AcpiHeader); - int dsdtLength = *((int*)FADT->Dsdt + 1) - sizeof(AcpiHeader); + uint dsdtAddress = FADT->Dsdt; + uint dsdtLength = (uint)(*((int*)FADT->Dsdt + 1) - sizeof(AcpiHeader)); - while (0 < dsdtLength--) - { - if (Compare("_S5_", S5Addr) == 0) - { - break; - } - S5Addr++; - } + var dsdtHeader = new MemoryBlock08(dsdtAddress, 36); + var _reader = new BinaryReader(new MemoryStream(dsdtHeader.ToArray())); - if (dsdtLength > 0) - { - if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) - { - S5Addr += 5; - S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPa = (short)(*(S5Addr) << 10); - S5Addr++; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPb = (short)(*(S5Addr) << 10); - SMI_CMD = (int*)FADT->SMI_CommandPort; - ACPI_ENABLE = FADT->AcpiEnable; - ACPI_DISABLE = FADT->AcpiDisable; - PM1a_CNT = (int*)FADT->PM1aControlBlock; - PM1b_CNT = (int*)FADT->PM1bControlBlock; - PM1_CNT_LEN = FADT->PM1ControlLength; - ResetValue = FADT->ResetValue; - SLP_EN = 1 << 13; - - smiIO = new IOPort((ushort)SMI_CMD); - pm1aIO = new IOPort((ushort)PM1a_CNT); - pm1bIO = new IOPort((ushort)PM1b_CNT); - ResetRegister = new IOPort((ushort)FADT->ResetReg.Address); - } - } + ReadHeader(_reader); + + var dsdtBlock = new MemoryBlock08(dsdtAddress, SdtLength); + + Stream stream = new MemoryStream(dsdtBlock.ToArray()); + + //var root = new Parser(stream).Parse(); + + //PopulateNode(root, 0); } } else if (signature == "APIC") @@ -602,13 +696,13 @@ private static void ParseDT(AcpiHeader *hdr) MADT = (MADTPtr*)hdr; - byte* p = (byte*)(MADT + 1); - byte* end = (byte*)MADT + MADT->Header.Length; + var p = (byte*)(MADT + 1); + var end = (byte*)MADT + MADT->Header.Length; while (p < end) { var header = (ApicHeader*)p; var type = header->Type; - byte length = header->Length; + var length = header->Length; if (type == ApicType.LocalAPIC) { @@ -660,7 +754,7 @@ public static void Disable() /// Get the RSDP address. /// /// uint value. - private static unsafe RSDPtr *RSDPAddress() + private static unsafe RSDPtr* RSDPAddress() { for (uint addr = 0xE0000; addr < 0x100000; addr += 4) { @@ -673,10 +767,10 @@ public static void Disable() } } - uint ebda_address = *((uint*)0x040E); - ebda_address = (ebda_address * 0x10) & 0x000fffff; + var ebda_address = *(uint*)0x040E; + ebda_address = ebda_address * 0x10 & 0x000fffff; - for (uint addr = ebda_address; addr < ebda_address + 1024; addr += 4) + for (var addr = ebda_address; addr < ebda_address + 1024; addr += 4) { if (Compare("RSD PTR ", (byte*)addr) == 0) { @@ -689,14 +783,14 @@ public static void Disable() public static uint RemapIRQ(uint irq) { - byte* p = (byte*)(MADT + 1); - byte* end = (byte*)MADT + MADT->Header.Length; + var p = (byte*)(MADT + 1); + var end = (byte*)MADT + MADT->Header.Length; while (p < end) { var header = (ApicHeader*)p; var type = header->Type; - byte length = header->Length; + var length = header->Length; if (type == ApicType.InterruptOverride) { diff --git a/source/Cosmos.Core/ACPI/AML/Definitions.cs b/source/Cosmos.Core/ACPI/AML/Definitions.cs new file mode 100644 index 0000000000..4f22eb393f --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/Definitions.cs @@ -0,0 +1,22 @@ +namespace ACPILib.AML +{ + public class Definitions + { + public const int NameSize = 4; + + public const byte ExtendedOpCodePrefix = 0x5B; + + public const byte DualNamePrefix = (byte)OpCodeEnum.DualNamePrefix; + public const byte MultiNamePrefix = (byte)OpCodeEnum.MultiNamePrefix; + + public static bool IsNameRootPrefixOrParentPrefix(byte b) + { + return (b == 0x5C || b == 0x5E); + } + + public static bool IsLeadingChar(byte b) + { + return (b == '_' || (b >= 'A' && b <= 'Z')); + } + } +} diff --git a/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs b/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs new file mode 100644 index 0000000000..dac9a8185a --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs @@ -0,0 +1,163 @@ +using System; + +namespace ACPILib.AML +{ + [Flags] + public enum InterpreterArgFlags : uint + { + None = 0x0, + AnyType = 0x01, + Package = 0x02, + Event = 0x03, + Mutex = 0x04, + DDBHandle = 0x05, + Integer = 0x06, + String = 0x07, + Buffer = 0x08, + BufferOrString = 0x09, + ComputeData = 0x0A, + ObjectReference = 0x0C, + DeviceReference = 0x0D, + TargetReference = 0x0F, + SimpleTarget = 0x10, + DataObject = 0x13, + ComplexObject = 0x14, + ReferenceOrString = 0x15, + RegionOrBuffer = 0x16, + DataReferenceObject = 0x17, + InvalidOpCode = 0xFFFFFFFF, + Reference = 0xB, + StoreTarget = 0xE, + } + + class InterpreterArgs + { + public static InterpreterArgFlags[] ARGI_ACCESSFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_ACQUIRE_OP = { InterpreterArgFlags.Mutex, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_ADD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_ALIAS_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_ARG0 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG1 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG2 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG3 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG4 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG5 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ARG6 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_BANK_FIELD_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_BIT_AND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BIT_NAND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BIT_NOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BIT_NOT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BIT_OR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BIT_XOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_BREAK_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_BREAK_POINT_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_BUFFER_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_BYTE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_BYTELIST_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_COMMENT_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_CONCAT_OP = { InterpreterArgFlags.AnyType, InterpreterArgFlags.AnyType, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_CONCAT_RES_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Buffer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_COND_REF_OF_OP = { InterpreterArgFlags.ObjectReference, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_CONNECTFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_CONTINUE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_COPY_OP = { InterpreterArgFlags.AnyType, InterpreterArgFlags.SimpleTarget }; + public static InterpreterArgFlags[] ARGI_CREATE_BIT_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_CREATE_BYTE_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_CREATE_DWORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_CREATE_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_CREATE_QWORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_CREATE_WORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; + public static InterpreterArgFlags[] ARGI_DATA_REGION_OP = { InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String }; + public static InterpreterArgFlags[] ARGI_DEBUG_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_DECREMENT_OP = { InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_DEREF_OF_OP = { InterpreterArgFlags.ReferenceOrString }; + public static InterpreterArgFlags[] ARGI_DEVICE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_DIVIDE_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_DWORD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_ELSE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_EVENT_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_EXTERNAL_OP = { InterpreterArgFlags.String, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_FATAL_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_FIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_FIND_SET_LEFT_BIT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_FIND_SET_RIGHT_BIT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_FROM_BCD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_IF_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_INCREMENT_OP = { InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_INDEX_FIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_INDEX_OP = { InterpreterArgFlags.ComplexObject, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_LAND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_LEQUAL_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; + public static InterpreterArgFlags[] ARGI_LGREATER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; + public static InterpreterArgFlags[] ARGI_LGREATEREQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_LLESS_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; + public static InterpreterArgFlags[] ARGI_LLESSEQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_LNOT_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_LNOTEQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_LOAD_OP = { InterpreterArgFlags.RegionOrBuffer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_LOAD_TABLE_OP = { InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.AnyType }; + public static InterpreterArgFlags[] ARGI_LOCAL0 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL1 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL2 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL3 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL4 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL5 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL6 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOCAL7 = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_LOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_MATCH_OP = { InterpreterArgFlags.Package, InterpreterArgFlags.Integer, InterpreterArgFlags.ComputeData, InterpreterArgFlags.Integer, InterpreterArgFlags.ComputeData, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_METHOD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_METHODCALL_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_MID_OP = { InterpreterArgFlags.BufferOrString, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_MOD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_MULTIPLY_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_MUTEX_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_NAME_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_NAMEDFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_NAMEPATH_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_NOOP_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_NOTIFY_OP = { InterpreterArgFlags.DeviceReference, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_OBJECT_TYPE_OP = { InterpreterArgFlags.AnyType }; + public static InterpreterArgFlags[] ARGI_ONE_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_ONES_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_PACKAGE_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_POWER_RES_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_PROCESSOR_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_QWORD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_REF_OF_OP = { InterpreterArgFlags.ObjectReference }; + public static InterpreterArgFlags[] ARGI_REGION_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_RELEASE_OP = { InterpreterArgFlags.Mutex }; + public static InterpreterArgFlags[] ARGI_RESERVEDFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_RESET_OP = { InterpreterArgFlags.Event }; + public static InterpreterArgFlags[] ARGI_RETURN_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_REVISION_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_SCOPE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_SERIALFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_SHIFT_LEFT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_SHIFT_RIGHT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_SIGNAL_OP = { InterpreterArgFlags.Event }; + public static InterpreterArgFlags[] ARGI_SIZE_OF_OP = { InterpreterArgFlags.DataObject }; + public static InterpreterArgFlags[] ARGI_SLEEP_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_STALL_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_STATICSTRING_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_STORE_OP = { InterpreterArgFlags.DataReferenceObject, InterpreterArgFlags.StoreTarget }; + public static InterpreterArgFlags[] ARGI_STRING_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_SUBTRACT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_THERMAL_ZONE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_TIMER_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARGI_TO_BCD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_TO_BUFFER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_TO_DEC_STR_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_TO_HEX_STR_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_TO_INTEGER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_TO_STRING_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; + public static InterpreterArgFlags[] ARGI_UNLOAD_OP = { InterpreterArgFlags.DDBHandle }; + public static InterpreterArgFlags[] ARGI_VAR_PACKAGE_OP = { InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_WAIT_OP = { InterpreterArgFlags.Event, InterpreterArgFlags.Integer }; + public static InterpreterArgFlags[] ARGI_WHILE_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_WORD_OP = { InterpreterArgFlags.InvalidOpCode }; + public static InterpreterArgFlags[] ARGI_ZERO_OP = { InterpreterArgFlags.None }; + public static InterpreterArgFlags[] ARG_NONE = { InterpreterArgFlags.None }; + } +} diff --git a/source/Cosmos.Core/ACPI/AML/ObjectType.cs b/source/Cosmos.Core/ACPI/AML/ObjectType.cs new file mode 100644 index 0000000000..1dbbb98504 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/ObjectType.cs @@ -0,0 +1,49 @@ +using System; + +namespace ACPILib.AML +{ + [Flags] + public enum ObjectTypeEnum : uint + { + Any = 0x00, + Integer = 0x01, + String = 0x02, + Buffer = 0x03, + Package = 0x04, + FieldUnit = 0x05, + Device = 0x06, + Event = 0x07, + Method = 0x08, + Mutex = 0x09, + Region = 0x0A, + Power = 0x0B, + Processor = 0x0C, + Thermal = 0x0D, + BufferField = 0x0E, + DDBHandle = 0x0F, + DebugObject = 0x10, + ExternalMax = 0x10, + + LocalRegionFIeld = 0x11, + LocalBankField = 0x12, + LocalIndexField = 0x13, + LocalReference = 0x14, + LocalAlias = 0x15, + LocalMethodAlias = 0x16, + LocalNotify = 0x17, + LocalAddressHandler = 0x18, + LocalResource = 0x19, + LocalResourceField = 0x1A, + LocalScope = 0x1B, + + NsNodeMax = 0x1B, + + LocalExtra = 0x1C, + LocalData = 0x1D, + + LocalMax = 0x1D, + + Invalid = 0x1E, + NotFound = 0xFF, + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCode.cs b/source/Cosmos.Core/ACPI/AML/OpCode.cs new file mode 100644 index 0000000000..6f3076aabd --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCode.cs @@ -0,0 +1,72 @@ +//Based on the ACPICA source code (https://github.com/acpica/acpica) +using System; + +namespace ACPILib.AML +{ + public class OpCode + { + public string Name + { + get; + private set; + } + + public ushort CodeValue + { + get { return (ushort)Code; } + } + + public int CodeByteSize + { + get + { + if (CodeValue > 0x00FF) + return 2; + + return 1; + } + } + + public OpCodeEnum Code; + public ParseArgFlags[] ParseArgs; + public InterpreterArgFlags[] RuntimeArgs; + public ObjectTypeEnum ObjectType; + public OpCodeClass Class; + public OpCodeType Type; + public OpCodeFlags Flags; + + public OpCode(string name, ParseArgFlags[] parseArgs, InterpreterArgFlags[] rtArgs, ObjectTypeEnum objectType, OpCodeClass cls, OpCodeType type, OpCodeFlags flags) + { + Code = OpCodeEnum.Unknown; + Name = name; + ParseArgs = parseArgs; + RuntimeArgs = rtArgs; + ObjectType = objectType; + Class = cls; + Type = type; + } + + public OpCode(OpCodeEnum code, ParseArgFlags[] parseArgs, InterpreterArgFlags[] rtArgs, ObjectTypeEnum objectType, OpCodeClass cls, OpCodeType type, OpCodeFlags flags) + { + Code = code; + ParseArgs = parseArgs; + RuntimeArgs = rtArgs; + ObjectType = objectType; + Class = cls; + Type = type; + Flags = flags; + + Name = GetName(code); + } + + private string GetName(OpCodeEnum code) + { + return "Unknown Opcode"; + } + + public override string ToString() + { + return Name; + } + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs b/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs new file mode 100644 index 0000000000..9090d57ee8 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs @@ -0,0 +1,20 @@ +using System; + +namespace ACPILib.AML +{ + [Flags] + public enum OpCodeClass : byte + { + Execute = 0x00, + Create = 0x01, + Argument = 0x02, + NamedObject = 0x03, + Control = 0x04, + ASCII = 0x05, + Prefix = 0x06, + Internal = 0x07, + ReturnValue = 0x08, + MethodCall = 0x09, + ClassUnknown = 0x0A, + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs b/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs new file mode 100644 index 0000000000..9d5e22c903 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs @@ -0,0 +1,154 @@ +namespace ACPILib.AML +{ + public enum OpCodeEnum : ushort + { + Unknown = 0xFFFF, + + Zero = 0x00, + One = 0x01, + Alias = 0x06, + Name = 0x08, + Byte = 0x0a, + Word = 0x0b, + DWord = 0x0c, + String = 0x0d, + QWord = 0x0e, + Scope = 0x10, + Buffer = 0x11, + Package = 0x12, + VariablePackage = 0x13, + Method = 0x14, + External = 0x15, + DualNamePrefix = 0x2e, + MultiNamePrefix = 0x2f, + ExtendedPrefix = 0x5b, + RootPrefix = 0x5c, + ParentPrefix = 0x5e, + FirstLocal = 0x60, + Local0 = 0x60, + Local1 = 0x61, + Local2 = 0x62, + Local3 = 0x63, + Local4 = 0x64, + Local5 = 0x65, + Local6 = 0x66, + Local7 = 0x67, + FirstArg = 0x68, + Arg0 = 0x68, + Arg1 = 0x69, + Arg2 = 0x6a, + Arg3 = 0x6b, + Arg4 = 0x6c, + Arg5 = 0x6d, + Arg6 = 0x6e, + Store = 0x70, + ReferenceOf = 0x71, + Add = 0x72, + Concatenate = 0x73, + Subtract = 0x74, + Increment = 0x75, + Decrement = 0x76, + Multiply = 0x77, + Divide = 0x78, + ShiftLeft = 0x79, + ShiftRight = 0x7a, + BitAnd = 0x7b, + BitNand = 0x7c, + BitOr = 0x7d, + BitNor = 0x7e, + BitXor = 0x7f, + BitNot = 0x80, + FindSetLeftBit = 0x81, + FindSetRightBit = 0x82, + DereferenceOf = 0x83, + ConcatenateTemplate = 0x84, + Mod = 0x85, + Notify = 0x86, + SizeOf = 0x87, + Index = 0x88, + Match = 0x89, + CreateDWordField = 0x8a, + CreateWordField = 0x8b, + CreateByteField = 0x8c, + CreateBitField = 0x8d, + ObjectType = 0x8e, + CreateQWordField = 0x8f, + LogicalAnd = 0x90, + LogicalOr = 0x91, + LogicalNot = 0x92, + LogicalEqual = 0x93, + LogicalGreater = 0x94, + LogicalLess = 0x95, + ToBuffer = 0x96, + ToDecimalString = 0x97, + ToHexString = 0x98, + ToInteger = 0x99, + ToString = 0x9c, + CopyObject = 0x9d, + Mid = 0x9e, + Continue = 0x9f, + If = 0xa0, + Else = 0xa1, + While = 0xa2, + NoOp = 0xa3, + Return = 0xa4, + Break = 0xa5, + Comment = 0xa9, + Breakpoint = 0xcc, + Ones = 0xff, + + LogicalGreaterEqual = 0x9295, + LogicalLessEqual = 0x9294, + LogicalNotEqual = 0x9293, + + ExtendedOpcode = 0x5b00, //Prefix + + Mutex = 0x5b01, + Event = 0x5b02, + ShiftRightBit = 0x5b10, + ShiftLeftBit = 0x5b11, + ConditionalReferenceOf = 0x5b12, + CreateField = 0x5b13, + LoadTable = 0x5b1f, + Load = 0x5b20, + Stall = 0x5b21, + Sleep = 0x5b22, + Acquire = 0x5b23, + Signal = 0x5b24, + Wait = 0x5b25, + Reset = 0x5b26, + Release = 0x5b27, + FromBCD = 0x5b28, + ToBCD = 0x5b29, + Unload = 0x5b2a, + Revision = 0x5b30, + Debug = 0x5b31, + Fatal = 0x5b32, + Timer = 0x5b33, + Region = 0x5b80, + Field = 0x5b81, + Device = 0x5b82, + Processor = 0x5b83, + PowerResource = 0x5b84, + ThermalZone = 0x5b85, + IndexField = 0x5b86, + BankField = 0x5b87, + DataRegion = 0x5b88, + + FieldOffset = 0x00, + FieldAccess = 0x01, + FieldConnection = 0x02, + FieldExternalAccess = 0x03, + + NamePath = 0x002d, + NamedField = 0x0030, + ReservedField = 0x0031, + AccessField = 0x0032, + ByteList = 0x0033, + MethodCall = 0x0035, + ReturnValue = 0x0036, + EvalSubtree = 0x0037, + Connection = 0x0038, + ExternalAccessField = 0x0039, + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs b/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs new file mode 100644 index 0000000000..7948c1a77f --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs @@ -0,0 +1,40 @@ +using System; + +namespace ACPILib.AML +{ + [Flags] + public enum OpCodeFlags : ushort + { + Logical = 0x0001, + LogicalNumeric = 0x0002, + Math = 0x0004, + Create = 0x0008, + Field = 0x0010, + Defer = 0x0020, + Named = 0x0040, + NSNode = 0x0080, + NSOpCode = 0x0100, + NSObject = 0x0200, + HasReturnValue = 0x0400, + HasTarget = 0x0800, + HasArguments = 0x1000, + Constant = 0x2000, + NoOperandResolve = 0x4000, + } + + class OpCodeExtendedFlags + { + public static OpCodeFlags AML_FLAGS_EXEC_0A_0T_1R = OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_1A_0T_0R = OpCodeFlags.HasArguments; + public static OpCodeFlags AML_FLAGS_EXEC_1A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_1A_1T_0R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget; + public static OpCodeFlags AML_FLAGS_EXEC_1A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_2A_0T_0R = OpCodeFlags.HasArguments; + public static OpCodeFlags AML_FLAGS_EXEC_2A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_2A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_2A_2T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_3A_0T_0R = OpCodeFlags.HasArguments; + public static OpCodeFlags AML_FLAGS_EXEC_3A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; + public static OpCodeFlags AML_FLAGS_EXEC_6A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs new file mode 100644 index 0000000000..556b5da818 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs @@ -0,0 +1,244 @@ +namespace ACPILib.AML +{ + public class OpCodeTable + { + public const byte Unkn = 0x6B; + public const byte Text = 0x6C; + public const byte Prfx = 0x6D; + + public static byte[] ShortOpCodeIndexes = + { +/* 0 1 2 3 4 5 6 7 */ +/* 8 9 A B C D E F */ +/* 0x00 */ 0x00, 0x01, Unkn, Unkn, Unkn, Unkn, 0x02, Unkn, +/* 0x08 */ 0x03, Unkn, 0x04, 0x05, 0x06, 0x07, 0x6E, Unkn, +/* 0x10 */ 0x08, 0x09, 0x0a, 0x6F, 0x0b, 0x81, Unkn, Unkn, +/* 0x18 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x20 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x28 */ Unkn, Unkn, Unkn, Unkn, Unkn, 0x63, Prfx, Prfx, +/* 0x30 */ 0x67, 0x66, 0x68, 0x65, 0x69, 0x64, 0x6A, 0x7D, +/* 0x38 */ 0x7F, 0x80, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x40 */ Unkn, Text, Text, Text, Text, Text, Text, Text, +/* 0x48 */ Text, Text, Text, Text, Text, Text, Text, Text, +/* 0x50 */ Text, Text, Text, Text, Text, Text, Text, Text, +/* 0x58 */ Text, Text, Text, Unkn, Prfx, Unkn, Prfx, Text, +/* 0x60 */ 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, +/* 0x68 */ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, Unkn, +/* 0x70 */ 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, +/* 0x78 */ 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, +/* 0x80 */ 0x2b, 0x2c, 0x2d, 0x2e, 0x70, 0x71, 0x2f, 0x30, +/* 0x88 */ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x72, +/* 0x90 */ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x73, 0x74, +/* 0x98 */ 0x75, 0x76, Unkn, Unkn, 0x77, 0x78, 0x79, 0x7A, +/* 0xA0 */ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x60, 0x61, +/* 0xA8 */ 0x62, 0x82, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xB0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xB8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xC0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xC8 */ Unkn, Unkn, Unkn, Unkn, 0x44, Unkn, Unkn, Unkn, +/* 0xD0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xD8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xE0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xE8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xF0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0xF8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, 0x45, + }; + + public static byte[] LongOpCodeIndexes = + { +/* 0 1 2 3 4 5 6 7 */ +/* 8 9 A B C D E F */ +/* 0x00 */ Unkn, 0x46, 0x47, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x08 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x10 */ Unkn, Unkn, 0x48, 0x49, Unkn, Unkn, Unkn, Unkn, +/* 0x18 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, 0x7B, +/* 0x20 */ 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, +/* 0x28 */ 0x52, 0x53, 0x54, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x30 */ 0x55, 0x56, 0x57, 0x7e, Unkn, Unkn, Unkn, Unkn, +/* 0x38 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x40 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x48 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x50 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x58 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x60 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x68 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x70 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x78 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, +/* 0x80 */ 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, +/* 0x88 */ 0x7C, + }; + + public static OpCode[] OpCodes = new OpCode[] +{ +/* Index Name Parser Args Interpreter Args ObjectType Class Type Flags */ +/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 1C */ new OpCode(OpCodeEnum.ReferenceOf, ParseArgs.ARGP_REF_OF_OP, InterpreterArgs.ARGI_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), +/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), +/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2E */ new OpCode(OpCodeEnum.DereferenceOf, ParseArgs.ARGP_DEREF_OF_OP, InterpreterArgs.ARGI_DEREF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), +/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), +/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), +/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), +/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 38 */ new OpCode(OpCodeEnum.LogicalAnd, ParseArgs.ARGP_LAND_OP, InterpreterArgs.ARGI_LAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), +/* 39 */ new OpCode(OpCodeEnum.LogicalOr, ParseArgs.ARGP_LOR_OP, InterpreterArgs.ARGI_LOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), +/* 3A */ new OpCode(OpCodeEnum.LogicalNot, ParseArgs.ARGP_LNOT_OP, InterpreterArgs.ARGI_LNOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 3B */ new OpCode(OpCodeEnum.LogicalEqual, ParseArgs.ARGP_LEQUAL_OP, InterpreterArgs.ARGI_LEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), +/* 3C */ new OpCode(OpCodeEnum.LogicalGreater, ParseArgs.ARGP_LGREATER_OP, InterpreterArgs.ARGI_LGREATER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), +/* 3D */ new OpCode(OpCodeEnum.LogicalLess, ParseArgs.ARGP_LLESS_OP, InterpreterArgs.ARGI_LLESS_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), +/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), + +/* Prefixed opcodes (Two-byte opcodes with a prefix op) */ + +/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 48 */ new OpCode(OpCodeEnum.ConditionalReferenceOf, ParseArgs.ARGP_COND_REF_OF_OP, InterpreterArgs.ARGI_COND_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), +/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), +/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), +/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), + +/* Internal opcodes that map to invalid AML opcodes */ + +/* 60 */ new OpCode(OpCodeEnum.LogicalNotEqual, ParseArgs.ARGP_LNOTEQUAL_OP, InterpreterArgs.ARGI_LNOTEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), +/* 61 */ new OpCode(OpCodeEnum.LogicalLessEqual, ParseArgs.ARGP_LLESSEQUAL_OP, InterpreterArgs.ARGI_LLESSEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), +/* 62 */ new OpCode(OpCodeEnum.LogicalGreaterEqual, ParseArgs.ARGP_LGREATEREQUAL_OP, InterpreterArgs.ARGI_LGREATEREQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), +/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), +/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), +/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), +/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), +/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), + +/* ACPI 2.0 opcodes */ + +/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 6F */ new OpCode(OpCodeEnum.Package, /* Var */ ParseArgs.ARGP_VAR_PACKAGE_OP, InterpreterArgs.ARGI_VAR_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer), +/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), +/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), +/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), + +/* ACPI 3.0 opcodes */ + +/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), + +/* ACPI 5.0 opcodes */ + +/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), + +/* ACPI 6.0 opcodes */ + +/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) +}; + + public static OpCode GetOpcode(ushort opCodeValue) + { + OpCode opCode = null; + + if ((opCodeValue & 0xFF00) == 0x0) + { + //Simple (8-bit) opcode + opCode = OpCodes[ShortOpCodeIndexes[(byte)opCodeValue]]; + } + + if (((opCodeValue & 0xFF00) == 0x5b00) && (((byte)opCodeValue) <= 0x88)) + { + //Extended (16-bit) opcode + opCode = OpCodes[LongOpCodeIndexes[(byte)opCodeValue]]; + } + + return opCode; + } + } +} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeType.cs b/source/Cosmos.Core/ACPI/AML/OpCodeType.cs new file mode 100644 index 0000000000..b784279bc8 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/OpCodeType.cs @@ -0,0 +1,39 @@ +using System; + +namespace ACPILib.AML +{ + public enum OpCodeType : byte + { + Execute_0A_0T_1R = 0x00, + Execute_1A_0T_0R = 0x01, + Execute_1A_0T_1R = 0x02, + Execute_1A_1T_0R = 0x03, + Execute_1A_1T_1R = 0x04, + Execute_2A_0T_0R = 0x05, + Execute_2A_0T_1R = 0x06, + Execute_2A_1T_1R = 0x07, + Execute_2A_2T_1R = 0x08, + Execute_3A_0T_0R = 0x09, + Execute_3A_1T_1R = 0x0A, + Execute_6A_0T_1R = 0x0B, + + Literal = 0x0C, + Constant = 0x0D, + MethodArgument = 0x0E, + LocalVariable = 0x0F, + DataTerm = 0x10, + + MethodCall = 0x11, + + CreateField = 0x12, + CreateObject = 0x13, + Control = 0x14, + NamedNoObject = 0x15, + NamedField = 0x16, + NamedSimple = 0x17, + NamedComplex = 0x18, + Return = 0x19, + Undefined = 0x1A, + Bogus = 0x1B, + } +} diff --git a/source/Cosmos.Core/ACPI/AML/ParseArgs.cs b/source/Cosmos.Core/ACPI/AML/ParseArgs.cs new file mode 100644 index 0000000000..81a0fb4c05 --- /dev/null +++ b/source/Cosmos.Core/ACPI/AML/ParseArgs.cs @@ -0,0 +1,162 @@ +using System; + +namespace ACPILib.AML +{ + [Flags] + public enum ParseArgFlags : byte + { + None = 0x0, + ByteData = 0x01, + ByteList = 0x02, + CharList = 0x03, + DataObject = 0x04, + DataObjectList = 0x05, + DWordData = 0x06, + FieldList = 0x07, + Name = 0x08, + NameString = 0x09, + ObjectList = 0x0A, + PackageLength = 0x0B, + SuperName = 0x0C, + Target = 0x0D, + TermArg = 0x0E, + TermList = 0x0F, + WordData = 0x10, + QWordData = 0x11, + SimpleName = 0x12, + NameOrReference = 0x13, + Max = 0x13, + Comment = 0x14, + } + + class ParseArgs + { + public static ParseArgFlags[] ARGP_ACCESSFIELD_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_ACQUIRE_OP = { ParseArgFlags.SuperName, ParseArgFlags.WordData }; + public static ParseArgFlags[] ARGP_ADD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_ALIAS_OP = { ParseArgFlags.NameString, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_ARG0 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG1 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG2 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG3 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG4 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG5 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ARG6 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_BANK_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.NameString, ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; + public static ParseArgFlags[] ARGP_BIT_AND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BIT_NAND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BIT_NOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BIT_NOT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BIT_OR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BIT_XOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_BREAK_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_BREAK_POINT_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_BUFFER_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.ByteList }; + public static ParseArgFlags[] ARGP_BYTE_OP = { ParseArgFlags.ByteData }; + public static ParseArgFlags[] ARGP_BYTELIST_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_COMMENT_OP = { ParseArgFlags.ByteData, ParseArgFlags.Comment }; + public static ParseArgFlags[] ARGP_CONCAT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_CONCAT_RES_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_COND_REF_OF_OP = { ParseArgFlags.SimpleName, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_CONNECTFIELD_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_CONTINUE_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_COPY_OP = { ParseArgFlags.TermArg, ParseArgFlags.SimpleName }; + public static ParseArgFlags[] ARGP_CREATE_BIT_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_CREATE_BYTE_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_CREATE_DWORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_CREATE_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_CREATE_QWORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_CREATE_WORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_DATA_REGION_OP = { ParseArgFlags.Name, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_DEBUG_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_DECREMENT_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_DEREF_OF_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_DEVICE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ObjectList }; + public static ParseArgFlags[] ARGP_DIVIDE_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_DWORD_OP = { ParseArgFlags.DWordData }; + public static ParseArgFlags[] ARGP_ELSE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermList }; + public static ParseArgFlags[] ARGP_EVENT_OP = { ParseArgFlags.Name }; + public static ParseArgFlags[] ARGP_EXTERNAL_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.ByteData }; + public static ParseArgFlags[] ARGP_FATAL_OP = { ParseArgFlags.ByteData, ParseArgFlags.DWordData, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; + public static ParseArgFlags[] ARGP_FIND_SET_LEFT_BIT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_FIND_SET_RIGHT_BIT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_FROM_BCD_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_IF_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.TermList }; + public static ParseArgFlags[] ARGP_INCREMENT_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_INDEX_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.NameString, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; + public static ParseArgFlags[] ARGP_INDEX_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_LAND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LGREATER_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LGREATEREQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LLESS_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LLESSEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LNOT_OP = { ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LNOTEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LOAD_OP = { ParseArgFlags.NameString, ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_LOAD_TABLE_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_LOCAL0 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL1 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL2 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL3 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL4 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL5 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL6 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOCAL7 = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_LOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_MATCH_OP = { ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_METHOD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.TermList }; + public static ParseArgFlags[] ARGP_METHODCALL_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_MID_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_MOD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_MULTIPLY_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_MUTEX_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData }; + public static ParseArgFlags[] ARGP_NAME_OP = { ParseArgFlags.Name, ParseArgFlags.DataObject }; + public static ParseArgFlags[] ARGP_NAMEDFIELD_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_NAMEPATH_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_NOOP_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_NOTIFY_OP = { ParseArgFlags.SuperName, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_OBJECT_TYPE_OP = { ParseArgFlags.SimpleName }; + public static ParseArgFlags[] ARGP_ONE_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_ONES_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_PACKAGE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.ByteData, ParseArgFlags.DataObjectList }; + public static ParseArgFlags[] ARGP_POWER_RES_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.WordData, ParseArgFlags.ObjectList }; + public static ParseArgFlags[] ARGP_PROCESSOR_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.DWordData, ParseArgFlags.ByteData, ParseArgFlags.ObjectList }; + public static ParseArgFlags[] ARGP_QWORD_OP = { ParseArgFlags.QWordData }; + public static ParseArgFlags[] ARGP_REF_OF_OP = { ParseArgFlags.SimpleName }; + public static ParseArgFlags[] ARGP_REGION_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_RELEASE_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_RESERVEDFIELD_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_RESET_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_RETURN_OP = { ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_REVISION_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_SCOPE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.TermList }; + public static ParseArgFlags[] ARGP_SERIALFIELD_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_SHIFT_LEFT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_SHIFT_RIGHT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_SIGNAL_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_SIZE_OF_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_SLEEP_OP = { ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_STALL_OP = { ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_STATICSTRING_OP = { ParseArgFlags.NameString }; + public static ParseArgFlags[] ARGP_STORE_OP = { ParseArgFlags.TermArg, ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_STRING_OP = { ParseArgFlags.CharList }; + public static ParseArgFlags[] ARGP_SUBTRACT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_THERMAL_ZONE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ObjectList }; + public static ParseArgFlags[] ARGP_TIMER_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARGP_TO_BCD_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_TO_BUFFER_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_TO_DEC_STR_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_TO_HEX_STR_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_TO_INTEGER_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_TO_STRING_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; + public static ParseArgFlags[] ARGP_UNLOAD_OP = { ParseArgFlags.SuperName }; + public static ParseArgFlags[] ARGP_VAR_PACKAGE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.DataObjectList }; + public static ParseArgFlags[] ARGP_WAIT_OP = { ParseArgFlags.SuperName, ParseArgFlags.TermArg }; + public static ParseArgFlags[] ARGP_WHILE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.TermList }; + public static ParseArgFlags[] ARGP_WORD_OP = { ParseArgFlags.WordData }; + public static ParseArgFlags[] ARGP_ZERO_OP = { ParseArgFlags.None }; + public static ParseArgFlags[] ARG_NONE = { ParseArgFlags.None }; + } +} diff --git a/source/Cosmos.Core/ACPI/Parser/AMLOp.cs b/source/Cosmos.Core/ACPI/Parser/AMLOp.cs new file mode 100644 index 0000000000..b5418cdd48 --- /dev/null +++ b/source/Cosmos.Core/ACPI/Parser/AMLOp.cs @@ -0,0 +1,71 @@ +using ACPILib.AML; +using System.Collections.Generic; + +namespace ACPILib.Parser +{ + public class AMLOp + { + public AMLOp Parent; + + public OpCode OpCode; + + public string Name; + + public int Start; + public int Length; + public int End + { + get { return (Start + Length); } + } + + public object Value; + + public List Nodes = new List(); + + public AMLOp(AMLOp parent) + { + Parent = parent; + } + + public AMLOp(OpCode op, AMLOp parent) + { + OpCode = op; + Parent = parent; + } + + public override string ToString() + { + return OpCode.ToString(); + } + + public AMLOp FindScope() + { + AMLOp check = Parent; + while (check != null) + { + if (check.OpCode != null && check.OpCode.Code == OpCodeEnum.Scope) + return check; + + check = check.Parent; + } + + return null; + } + + public AMLOp FindMethod(string name) + { + if (OpCode != null && OpCode.Code == OpCodeEnum.Method && Name == name) + return this; + + foreach(AMLOp node in Nodes) + { + AMLOp method = node.FindMethod(name); + + if (method != null) + return method; + } + + return null; + } + } +} diff --git a/source/Cosmos.Core/ACPI/Parser/Parser.cs b/source/Cosmos.Core/ACPI/Parser/Parser.cs new file mode 100644 index 0000000000..298cdec437 --- /dev/null +++ b/source/Cosmos.Core/ACPI/Parser/Parser.cs @@ -0,0 +1,472 @@ +using ACPILib.AML; +using System; +using System.IO; +using System.Text; + +namespace ACPILib.Parser +{ + public class Parser + { + private Stream _source; + + public Parser(Stream source) + { + _source = source; + } + + #region Stream reading tools + private byte PeekByte() + { + byte val = (byte)_source.ReadByte(); + _source.Seek(-1, SeekOrigin.Current); + + return val; + } + + private byte[] PeekBytes(int number) + { + byte[] buffer = new byte[number]; + int moved = _source.Read(buffer, 0, number); + + _source.Seek(-moved, SeekOrigin.Current); + + return buffer; + } + + private byte[] ReadBytes(int number) + { + byte[] buffer = new byte[number]; + _source.Read(buffer, 0, number); + + return buffer; + } + #endregion + + #region AML reading tools + private OpCode ReadOpcode() + { + ushort opCodeValue = (ushort)_source.ReadByte(); + if (opCodeValue == 0x5B) //Extended op prefix + { + opCodeValue = (ushort)((opCodeValue << 8) | (byte)_source.ReadByte()); + } + + return OpCodeTable.GetOpcode(opCodeValue); + } + + private ushort PeekOpcode() + { + ushort opCodeValue = (ushort)_source.ReadByte(); + if (opCodeValue == 0x5B) //Extended op prefix + { + opCodeValue = (ushort)((opCodeValue << 8) | (byte)_source.ReadByte()); + + _source.Seek(-2, SeekOrigin.Current); + } + else + { + _source.Seek(-1, SeekOrigin.Current); + } + + return opCodeValue; + } + + private AMLOp ReadAmlOp(AMLOp parent) + { + AMLOp op = new AMLOp(parent); + + op.Start = (int)_source.Position; + op.OpCode = ReadOpcode(); + + return op; + } + + private int ReadPackageLength() + { + int length = 0; + + byte b0 = (byte)_source.ReadByte(); + + int byteCount = (b0 >> 6); + + byte firstMask = (byte)(byteCount > 0 ? 0x0F : 0x3F); + + for (int b = 0; b < byteCount; b++) + { + length |= ((byte)_source.ReadByte() << ((byteCount << 3) - 4)); + } + + length |= (b0 & firstMask); + + return length; + } + + private string ReadNameString() + { + string name = string.Empty; + + int start = (int)_source.Position; + int end = (int)_source.Position; + + while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) + { + start++; + _source.Seek(start, SeekOrigin.Begin); + } + + end = start; + + //Find the size of the segment + _source.Seek(start, SeekOrigin.Begin); + int length = 0; + switch (PeekByte()) + { + case 0x0: //Null name + end++; + start = end; + break; + case Definitions.DualNamePrefix: + //Two name segments + start = end = (int)_source.Position + 1; + end += (2 * Definitions.NameSize); + + length = end - start; + break; + case Definitions.MultiNamePrefix: + //Multiple name segments, 4 chars each + _source.Seek(start + 1, SeekOrigin.Begin); + byte count = PeekByte(); + + start = end = (int)_source.Position + 1; + end += (count * Definitions.NameSize); + + length = end - start; + break; + default: + //Single segment + length = Definitions.NameSize; + end += length; + break; + } + + _source.Seek(start, SeekOrigin.Begin); + for (int x = 0; x < length; x++) + { + byte readByte = (byte)_source.ReadByte(); + if (readByte == 0x0) + continue; + + name += (char)readByte; + + if ((x + 1) % 4 == 0 && x + 1 < length) + name += "."; + } + + _source.Seek(end, SeekOrigin.Begin); + + return name; + } + + private string ReadNamePath() + { + return ReadNameString(); //Is this the same as the path? + } + + private AMLOp ReadField(AMLOp parent) + { + OpCodeEnum type = (OpCodeEnum)PeekByte(); + + AMLOp amlOp = null; + switch (type) + { + case OpCodeEnum.FieldOffset: + amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ReservedField), parent); + _source.Seek(1, SeekOrigin.Current); + + amlOp.Value = ReadPackageLength(); //Read the value as a PkgLength + break; + case OpCodeEnum.FieldAccess: + case OpCodeEnum.FieldExternalAccess: + amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)((type == OpCodeEnum.FieldAccess) ? OpCodeEnum.AccessField : OpCodeEnum.ByteList)), parent); + _source.Seek(1, SeekOrigin.Current); + + int accessType = (byte)_source.ReadByte(); + int accessAttribute = (byte)_source.ReadByte(); + + amlOp.Value = (int)(accessType | (accessAttribute << 8)); + + if (type == OpCodeEnum.FieldExternalAccess) //This one has a 3rd byte + { + amlOp.Value = (int)amlOp.Value | (_source.ReadByte() << 16); + } + break; + case OpCodeEnum.FieldConnection: + amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Connection), parent); + _source.Seek(1, SeekOrigin.Current); + + if (PeekByte() == (byte)OpCodeEnum.Buffer) + { + _source.Seek(1, SeekOrigin.Current); + + int end = (int)_source.Position + ReadPackageLength(); + + while (_source.Position < end) + { + AMLOp arg = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ByteList), parent); + + OpCodeEnum actualOpCode = (OpCodeEnum)(byte)_source.ReadByte(); + int bufferLength = 0; + switch (actualOpCode) + { + case OpCodeEnum.Byte: + bufferLength = (byte)_source.ReadByte(); + break; + case OpCodeEnum.Word: + bufferLength = BitConverter.ToInt16(ReadBytes(2), 0); + break; + case OpCodeEnum.DWord: + bufferLength = BitConverter.ToInt32(ReadBytes(4), 0); + break; + } + + arg.Value = ReadBytes(bufferLength); + + amlOp.Nodes.Add(arg); + } + } + else + { + AMLOp arg = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), parent); + arg.Value = ReadNameString(); + + amlOp.Nodes.Add(arg); + } + break; + default: + amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamedField), parent); + + amlOp.Name = Encoding.ASCII.GetString(ReadBytes(4)); + + amlOp.Value = ReadPackageLength(); //Read the value as a PkgLength + break; + } + + return amlOp; + } + + private AMLOp ReadTermArg(AMLOp parent) + { + byte[] peek4 = PeekBytes(4); + + //Check if all of the chars are letters + bool probalbyString = true; + for(int x = 0; x < peek4.Length; x++) + { + if (!char.IsDigit((char)peek4[x]) && !char.IsUpper((char)peek4[x])) + { + probalbyString = false; + break; + } + } + + if (probalbyString) //No idea what I'm doing here + { + AMLOp str = new AMLOp(OpCodeTable.GetOpcode(0x41), parent); + str.Value = ReadNameString(); + + return str; + } + + return ReadAmlOp(parent); + } + #endregion + + #region AML parsing + public AMLOp Parse() + { + AMLOp root = new AMLOp(null); + root.Name = "Root"; + + while (_source.Position < _source.Length) + { + AMLOp op = ReadAmlOp(null); + + root.Nodes.Add(op); + + ParseOp(op, false); + } + + return root; + } + + private void ParseOp(AMLOp op, bool isMethodBody) + { + if (op.OpCode == null) + return; + + for (int x = 0; x < op.OpCode.ParseArgs.Length; x++) + { + switch (op.OpCode.ParseArgs[x]) + { + //None + case ParseArgFlags.None: + break; + + //Simple values + case ParseArgFlags.Name: + case ParseArgFlags.NameString: + op.Name = ReadNameString(); + break; + case ParseArgFlags.ByteData: + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Byte), op) + { + Value = (byte)_source.ReadByte() + }); + break; + case ParseArgFlags.WordData: + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Word), op) + { + Value = BitConverter.ToInt16(ReadBytes(2), 0) + }); + break; + case ParseArgFlags.DWordData: + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.DWord), op) + { + Value = BitConverter.ToInt32(ReadBytes(4), 0) + }); + break; + case ParseArgFlags.QWordData: + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.QWord), op) + { + Value = BitConverter.ToInt64(ReadBytes(8), 0) + }); + break; + case ParseArgFlags.CharList: + //Null terminated string + string value = ""; + + byte read; + while ((read = (byte)_source.ReadByte()) != 0x0) + { + value += (char)read; + } + + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.String), op) + { + Value = value + }); + break; + case ParseArgFlags.ByteList: + int length = op.End - (int)_source.Position + 1; + if (length < 0) + { + throw new ArgumentOutOfRangeException(); + } + + op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ByteList), op) + { + Value = ReadBytes(length) + }); + break; + + //Complex values + case ParseArgFlags.PackageLength: + op.Length = ReadPackageLength(); + break; + case ParseArgFlags.ObjectList: + case ParseArgFlags.DataObjectList: + case ParseArgFlags.TermList: + if (op.OpCode.Code == OpCodeEnum.Method) + { + //Methods are too buggy, skip them + + _source.Seek(op.End + 1, SeekOrigin.Begin); + break; + } + + while (_source.Position < op.End) + { + AMLOp term = ReadTermArg(op); + + op.Nodes.Add(term); + + ParseOp(term, (op.OpCode.Code == OpCodeEnum.Method)); + } + break; + case ParseArgFlags.DataObject: + case ParseArgFlags.TermArg: + + AMLOp arg = ReadTermArg(op); + + if (isMethodBody || op.OpCode.Code == OpCodeEnum.Method) + { + if (arg.Value is string) + { + AMLOp scope = arg.FindScope(); + if (scope != null) + { + AMLOp method = scope.FindMethod((string)arg.Value); + + if (method != null) + { + AMLOp call = new ACPILib.Parser.AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.MethodCall), op); + call.Value = arg.Value; + arg = call; + } + } + } + } + + op.Nodes.Add(arg); + ParseOp(arg, isMethodBody); + + break; + case ParseArgFlags.FieldList: + while (_source.Position < op.End) + { + op.Nodes.Add(ReadField(op)); + } + break; + case ParseArgFlags.SimpleName: + case ParseArgFlags.NameOrReference: + ushort subOp = PeekOpcode(); + if (subOp == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp) || Definitions.IsLeadingChar((byte)subOp)) + { + AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); + op.Nodes.Add(namePath); + + namePath.Value = ReadNamePath(); + } + else + { + AMLOp term = ReadAmlOp(op); + op.Nodes.Add(term); + ParseOp(term, isMethodBody); + } + break; + case ParseArgFlags.Target: + case ParseArgFlags.SuperName: + ushort subOp2 = PeekOpcode(); + if (subOp2 == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp2) || Definitions.IsLeadingChar((byte)subOp2)) + { + AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); + op.Nodes.Add(namePath); + + namePath.Value = ReadNamePath(); + } + else + { + AMLOp term = ReadAmlOp(op); + op.Nodes.Add(term); + ParseOp(term, isMethodBody); + } + break; + + default: + throw new NotImplementedException(); + } + } + } + #endregion + } +} diff --git a/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs b/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs new file mode 100644 index 0000000000..e5cc7dc544 --- /dev/null +++ b/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs @@ -0,0 +1,29 @@ +using ACPILib.AML; +using System.Collections.Generic; + +namespace ACPILib.Parser2 +{ + public class ParseNode + { + public OpCode Op; + public string Name; + + public long Start; + public long DataStart; + public long Length; + + public long End + { + get { return Start + Length + Op.CodeByteSize; } + } + + public object ConstantValue; + public List Arguments = new List(); + public List Nodes = new List(); + + public override string ToString() + { + return Op.ToString(); + } + } +} diff --git a/source/Cosmos.Core/ACPI/Parser2/Parser.cs b/source/Cosmos.Core/ACPI/Parser2/Parser.cs new file mode 100644 index 0000000000..a6b6296c9e --- /dev/null +++ b/source/Cosmos.Core/ACPI/Parser2/Parser.cs @@ -0,0 +1,395 @@ +using ACPILib.AML; +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace ACPILib.Parser2 +{ + public class Parser + { + private Stream _source; + + public Parser(Stream s) + { + _source = s; + } + + public ParseNode Parse() + { + return PreParse(); + + return null; + } + + private ParseNode PreParse() + { + ParseNode root = new ParseNode() + { + Name = "\\" + }; + + while (_source.Position < _source.Length) + { + ParseNode op = ParseFullOpCodeNode(); + + root.Nodes.Add(op); + } + + return root; + } + + private ParseNode ParseFullOpCodeNode() + { + //Read the opcode + ParseNode op = ReadOpCode(); + OpCode info = op.Op; + + _source.Seek(op.DataStart, SeekOrigin.Begin); + + //Parse opcode arguments + if (info.ParseArgs.Length > 0) + { + bool parseArguments = false; + + switch (info.Code) + { + case OpCodeEnum.Byte: + case OpCodeEnum.Word: + case OpCodeEnum.DWord: + case OpCodeEnum.QWord: + case OpCodeEnum.String: + op.ConstantValue = ParseSimpleArgument(info.ParseArgs[0]); + break; + + case OpCodeEnum.NamePath: + op.Arguments.Add(ReadNameString()); + break; + + default: + parseArguments = true; + break; + } + + if (parseArguments) //If the opcode is not a constant + { + for (int x = 0; x < info.ParseArgs.Length; x++) + { + switch (info.ParseArgs[x]) + { + case ParseArgFlags.None: + break; + + case ParseArgFlags.ByteData: + case ParseArgFlags.WordData: + case ParseArgFlags.DWordData: + case ParseArgFlags.CharList: + case ParseArgFlags.Name: + case ParseArgFlags.NameString: + { + object arg = ParseSimpleArgument(info.ParseArgs[x]); + if (arg != null) + { + op.Arguments.Add(arg); + } + } + break; + + case ParseArgFlags.DataObject: + case ParseArgFlags.TermArg: + { + ParseNode arg = ParseFullOpCodeNode(); + + op.Arguments.Add(arg); + } + break; + + case ParseArgFlags.PackageLength: + op.Arguments.Add(op.Length = ReadPackageLength()); + break; + + case ParseArgFlags.FieldList: + while(_source.Position < op.End) + { + op.Arguments.Add(ReadField()); + } + break; + + case ParseArgFlags.ByteList: + if (_source.Position < op.End) + { + op.ConstantValue = ReadBytes((int)(op.End - _source.Position)); + } + break; + + case ParseArgFlags.DataObjectList: + case ParseArgFlags.TermList: + case ParseArgFlags.ObjectList: + + if (op.Op.Code == OpCodeEnum.Method) + _source.Seek(op.End, SeekOrigin.Begin); + else + { + while (_source.Position < op.End) + { + ParseNode child = ParseFullOpCodeNode(); + + op.Nodes.Add(child); + } + } + + break; + + default: + throw new Exception("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); + } + } + } + } + + //Parse the opcode + if ((info.Flags & OpCodeFlags.Named) == OpCodeFlags.Named) + { + for (int x = 0; x < info.ParseArgs.Length; x++) + { + if (info.ParseArgs[x] == ParseArgFlags.Name) + { + op.Name = (string)op.Arguments[x]; + break; + } + } + } + + return op; + } + + private ParseNode ReadField() + { + OpCodeEnum opCode; + switch ((OpCodeEnum)PeekByte()) + { + case OpCodeEnum.FieldOffset: + + opCode = OpCodeEnum.ReservedField; ; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldAccess: + + opCode = OpCodeEnum.AccessField; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldConnection: + + opCode = OpCodeEnum.Connection; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldExternalAccess: + + opCode = OpCodeEnum.ExternalAccessField; + _source.Seek(1, SeekOrigin.Current); + break; + + default: + opCode = OpCodeEnum.NamedField; + break; + } + + ParseNode node = new ParseNode() + { + Op = OpCodeTable.GetOpcode((ushort)opCode) + }; + + switch (opCode) + { + case OpCodeEnum.NamedField: + node.Name = Read4ByteName(); + node.ConstantValue = ReadPackageLength(); + break; + case OpCodeEnum.ReservedField: + node.ConstantValue = ReadPackageLength(); + break; + case OpCodeEnum.AccessField: + node.ConstantValue = (ReadByte() | ((uint)ReadByte() << 8)); + break; + case OpCodeEnum.ExternalAccessField: + node.ConstantValue = (ReadByte() | ((uint)ReadByte() << 8) | ((uint)ReadByte() << 16)); + break; + + default: + throw new Exception("psargs.c / line 703"); + } + + return node; + } + + private int ReadPackageLength() + { + int length = 0; + + byte b0 = (byte)_source.ReadByte(); + + int byteCount = (b0 >> 6); + + byte firstMask = (byte)(byteCount > 0 ? 0x0F : 0x3F); + + for (int b = 0; b < byteCount; b++) + { + length |= ((byte)_source.ReadByte() << ((byteCount << 3) - 4)); + } + + length |= (b0 & firstMask); + + return length; + } + + private object ParseSimpleArgument(ParseArgFlags arg) + { + switch (arg) + { + case ParseArgFlags.ByteData: + return (byte)_source.ReadByte(); + case ParseArgFlags.WordData: + return BitConverter.ToInt16(ReadBytes(2), 0); + case ParseArgFlags.DWordData: + return BitConverter.ToInt32(ReadBytes(4), 0); + case ParseArgFlags.QWordData: + return BitConverter.ToInt64(ReadBytes(8), 0); + case ParseArgFlags.CharList: //Nullterminated string + string str = string.Empty; + + byte read; + while ((read = (byte)_source.ReadByte()) != 0) + str += (char)read; + + return str; + case ParseArgFlags.Name: + case ParseArgFlags.NameString: + return ReadNameString(); + } + + return null; + } + + private string ReadNameString() + { + //Read past prefix chars + while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) + { + _source.Seek(1, SeekOrigin.Current); + } + + int segments = 0; + switch(ReadByte()) + { + case 0: //Null string + return string.Empty; + + case Definitions.DualNamePrefix: + segments = 2; + break; + case Definitions.MultiNamePrefix: + segments = ReadByte(); + break; + + default: + segments = 1; + + _source.Seek(-1, SeekOrigin.Current); + break; + } + + string name = string.Empty; + + for (int seg = 0; seg < segments; seg++) + { + string nameSeg = Read4ByteName(); + + name += nameSeg; + + if (seg < segments - 1) + name += "."; + } + + return name; + } + + private ParseNode ReadOpCode() + { + long pos = _source.Position; + + ushort op = PeekOpcode(); + OpCode info = OpCodeTable.GetOpcode(op); + + switch (info.Class) + { + case OpCodeClass.ASCII: + case OpCodeClass.Prefix: + info = OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath); + pos -= 1; //The op code byte is the data itself + break; + case OpCodeClass.ClassUnknown: + throw new Exception("Unknown AML opcode: 0x" + op.ToString("X2")); + default: + _source.Seek(info.CodeByteSize, SeekOrigin.Current); + break; + } + + return new ParseNode() + { + Op = info, + Start = pos, + DataStart = pos + info.CodeByteSize + }; + } + + private string Read4ByteName() + { + byte[] dt = new byte[4]; + _source.Read(dt, 0, 4); + + return Encoding.ASCII.GetString(dt); + } + + private byte[] ReadBytes(int num) + { + byte[] temp = new byte[num]; + _source.Read(temp, 0, num); + + return temp; + } + + private byte PeekByte() + { + byte read = (byte)_source.ReadByte(); + + _source.Seek(-1, SeekOrigin.Current); + + return read; + } + + private byte ReadByte() + { + return (byte)_source.ReadByte(); + } + + private ushort PeekOpcode() + { + ushort code = (ushort)_source.ReadByte(); + if(code == Definitions.ExtendedOpCodePrefix) + { + code = (ushort)((code << 8) | (ushort)_source.ReadByte()); + + _source.Seek(-2, SeekOrigin.Current); + } + else + { + _source.Seek(-1, SeekOrigin.Current); + } + + return code; + } + } +} diff --git a/source/Cosmos.Core/MemoryBlock.cs b/source/Cosmos.Core/MemoryBlock.cs index 210ebc0e4a..294ce4a173 100644 --- a/source/Cosmos.Core/MemoryBlock.cs +++ b/source/Cosmos.Core/MemoryBlock.cs @@ -486,6 +486,33 @@ public unsafe byte this[uint aByteOffset] (*(byte*)(Base + aByteOffset)) = value; } } + + /// + /// Convert part for the memory block to array. + /// + /// A starting position of the data at the source memory block. + /// A index to be the staring index at the destination array. + /// Number of bytes to get. + /// uint array. + public unsafe byte[] ToArray(int aStart, int aIndex, int aCount) + { + byte* xDest = (byte*)(Base + aStart); + byte[] array = new byte[aCount]; + fixed (byte* aArrayPtr = array) + { + MemoryOperations.Copy(aArrayPtr + aIndex, xDest, aCount); + } + return array; + } + + /// + /// Convert the memory block to array. + /// + /// uint array. + public byte[] ToArray() + { + return ToArray(0, 0, (int)Size); + } } /// From 96c12915077957efd9ea8cfde26d3b21ac0e8e45 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Tue, 14 Jun 2022 01:12:42 +0200 Subject: [PATCH 23/35] Add plug for InitOrdinalCasingPage + Parse AML + Get Opcode name (reflection doesn't work) --- source/Cosmos.Core/ACPI/ACPI.cs | 81 +-- source/Cosmos.Core/ACPI/AML/OpCode.cs | 573 +++++++++++++++++- source/Cosmos.Core/ACPI/Parser2/Parser.cs | 56 +- .../Interop/GlobalizationImpl.cs | 4 + 4 files changed, 632 insertions(+), 82 deletions(-) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index 99de73c9e5..b0293d0b76 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -573,79 +573,6 @@ private static void ReadHeader(BinaryReader _reader) Global.mDebugger.Send("\tCreatorRevision: " + _reader.ReadUInt32().ToString()); } - private static string ValueToString(object val) - { - if (val == null) - return "null"; - - if (val is string) - return "\"" + val.ToString() + "\""; - - if (val is byte) - return "0x" + ((byte)val).ToString("X2"); - - if (val.GetType().IsArray) - { - Array ar = (Array)val; - - string rt = ""; - - for (int x = 0; x < ar.Length; x++) - rt += ValueToString(ar.GetValue(x)) + (x < ar.Length - 1 ? ", " : string.Empty); - - return rt; - } - - if (val is ParseNode) - { - ParseNode node = (ParseNode)val; - - if (node.ConstantValue != null) - return ValueToString(node.ConstantValue); - } - - return val.ToString(); - } - - private static void PopulateNode(ParseNode op, int depth) - { - Global.mDebugger.Send("=========== DEPTH " + depth + " ==========="); - - if (!string.IsNullOrEmpty(op.Name)) - Global.mDebugger.Send(op.Name); - - if (op.Op != null) - { - Global.mDebugger.Send("OpCode = " + op.Op.ToString()); - Global.mDebugger.Send("Start = " + op.Start.ToString()); - Global.mDebugger.Send("Length = " + op.Length.ToString()); - Global.mDebugger.Send("End = " + op.End.ToString()); - if (op.ConstantValue != null) - { - Global.mDebugger.Send("Value = " + ValueToString(op.ConstantValue)); - } - } - - if (op.Arguments.Count > 0) - { - for (int x = 0; x < op.Op.ParseArgs.Length; x++) - { - if (op.Op.ParseArgs[x] == ParseArgFlags.DataObjectList || op.Op.ParseArgs[x] == ParseArgFlags.TermList || op.Op.ParseArgs[x] == ParseArgFlags.ObjectList) - continue; - - Global.mDebugger.Send(ValueToString(op.Arguments[x]) + " (" + op.Op.ParseArgs[x].ToString() + ")"); - } - } - - if (op.Nodes.Count > 0) - { - foreach (ParseNode ch in op.Nodes) - { - PopulateNode(ch, depth + 1); - } - } - } - private static void ParseDT(AcpiHeader* hdr) { var signature = Encoding.ASCII.GetString(hdr->Signature, 4); @@ -685,9 +612,13 @@ private static void ParseDT(AcpiHeader* hdr) Stream stream = new MemoryStream(dsdtBlock.ToArray()); - //var root = new Parser(stream).Parse(); + Global.mDebugger.Send("Create parser..."); + + var root = new Parser(stream); + + Global.mDebugger.Send("Parse first node..."); - //PopulateNode(root, 0); + var node = root.Parse(); } } else if (signature == "APIC") diff --git a/source/Cosmos.Core/ACPI/AML/OpCode.cs b/source/Cosmos.Core/ACPI/AML/OpCode.cs index 6f3076aabd..04efa408f9 100644 --- a/source/Cosmos.Core/ACPI/AML/OpCode.cs +++ b/source/Cosmos.Core/ACPI/AML/OpCode.cs @@ -61,7 +61,578 @@ public OpCode(OpCodeEnum code, ParseArgFlags[] parseArgs, InterpreterArgFlags[] private string GetName(OpCodeEnum code) { - return "Unknown Opcode"; + string name = "ERROR OPCODE NOT DETECTED"; + + if (code == OpCodeEnum.Unknown) + { + name = "Unknown"; + } + else if (code == OpCodeEnum.Zero) + { + name = "Zero"; + } + else if (code == OpCodeEnum.One) + { + name = "One"; + } + else if (code == OpCodeEnum.Alias) + { + name = "Alias"; + } + else if (code == OpCodeEnum.Name) + { + name = "Name"; + } + else if (code == OpCodeEnum.Byte) + { + name = "Byte"; + } + else if (code == OpCodeEnum.Word) + { + name = "Word"; + } + else if (code == OpCodeEnum.DWord) + { + name = "DWord"; + } + else if (code == OpCodeEnum.String) + { + name = "String"; + } + else if (code == OpCodeEnum.QWord) + { + name = "QWord"; + } + else if (code == OpCodeEnum.Scope) + { + name = "Scope"; + } + else if (code == OpCodeEnum.Buffer) + { + name = "Buffer"; + } + else if (code == OpCodeEnum.Package) + { + name = "Package"; + } + else if (code == OpCodeEnum.VariablePackage) + { + name = "VariablePackage"; + } + else if (code == OpCodeEnum.Method) + { + name = "Method"; + } + else if (code == OpCodeEnum.External) + { + name = "External"; + } + else if (code == OpCodeEnum.DualNamePrefix) + { + name = "DualNamePrefix"; + } + else if (code == OpCodeEnum.MultiNamePrefix) + { + name = "MultiNamePrefix"; + } + else if (code == OpCodeEnum.ExtendedPrefix) + { + name = "ExtendedPrefix"; + } + else if (code == OpCodeEnum.RootPrefix) + { + name = "RootPrefix"; + } + else if (code == OpCodeEnum.ParentPrefix) + { + name = "ParentPrefix"; + } + else if (code == OpCodeEnum.FirstLocal) + { + name = "FirstLocal"; + } + else if (code == OpCodeEnum.Local0) + { + name = "Local0"; + } + else if (code == OpCodeEnum.Local1) + { + name = "Local1"; + } + else if (code == OpCodeEnum.Local2) + { + name = "Local2"; + } + else if (code == OpCodeEnum.Local3) + { + name = "Local3"; + } + else if (code == OpCodeEnum.Local4) + { + name = "Local4"; + } + else if (code == OpCodeEnum.Local5) + { + name = "Local5"; + } + else if (code == OpCodeEnum.Local6) + { + name = "Local6"; + } + else if (code == OpCodeEnum.Local7) + { + name = "Local7"; + } + else if (code == OpCodeEnum.FirstArg) + { + name = "FirstArg"; + } + else if (code == OpCodeEnum.Arg0) + { + name = "Arg0"; + } + else if (code == OpCodeEnum.Arg1) + { + name = "Arg1"; + } + else if (code == OpCodeEnum.Arg2) + { + name = "Arg2"; + } + else if (code == OpCodeEnum.Arg3) + { + name = "Arg3"; + } + else if (code == OpCodeEnum.Arg4) + { + name = "Arg4"; + } + else if (code == OpCodeEnum.Arg5) + { + name = "Arg5"; + } + else if (code == OpCodeEnum.Arg6) + { + name = "Arg6"; + } + else if (code == OpCodeEnum.Store) + { + name = "Store"; + } + else if (code == OpCodeEnum.ReferenceOf) + { + name = "ReferenceOf"; + } + else if (code == OpCodeEnum.Add) + { + name = "Add"; + } + else if (code == OpCodeEnum.Concatenate) + { + name = "Concatenate"; + } + else if (code == OpCodeEnum.Subtract) + { + name = "Subtract"; + } + else if (code == OpCodeEnum.Increment) + { + name = "Increment"; + } + else if (code == OpCodeEnum.Decrement) + { + name = "Decrement"; + } + else if (code == OpCodeEnum.Multiply) + { + name = "Multiply"; + } + else if (code == OpCodeEnum.Divide) + { + name = "Divide"; + } + else if (code == OpCodeEnum.ShiftLeft) + { + name = "ShiftLeft"; + } + else if (code == OpCodeEnum.ShiftRight) + { + name = "ShiftRight"; + } + else if (code == OpCodeEnum.BitAnd) + { + name = "BitAnd"; + } + else if (code == OpCodeEnum.BitNand) + { + name = "BitNand"; + } + else if (code == OpCodeEnum.BitOr) + { + name = "BitOr"; + } + else if (code == OpCodeEnum.BitNor) + { + name = "BitNor"; + } + else if (code == OpCodeEnum.BitXor) + { + name = "BitXor"; + } + else if (code == OpCodeEnum.BitNot) + { + name = "BitNot"; + } + else if (code == OpCodeEnum.FindSetLeftBit) + { + name = "FindSetLeftBit"; + } + else if (code == OpCodeEnum.FindSetRightBit) + { + name = "FindSetRightBit"; + } + else if (code == OpCodeEnum.DereferenceOf) + { + name = "DereferenceOf"; + } + else if (code == OpCodeEnum.ConcatenateTemplate) + { + name = "ConcatenateTemplate"; + } + else if (code == OpCodeEnum.Mod) + { + name = "Mod"; + } + else if (code == OpCodeEnum.Notify) + { + name = "Notify"; + } + else if (code == OpCodeEnum.SizeOf) + { + name = "SizeOf"; + } + else if (code == OpCodeEnum.Index) + { + name = "Index"; + } + else if (code == OpCodeEnum.Match) + { + name = "Match"; + } + else if (code == OpCodeEnum.CreateDWordField) + { + name = "CreateDWordField"; + } + else if (code == OpCodeEnum.CreateWordField) + { + name = "CreateWordField"; + } + else if (code == OpCodeEnum.CreateByteField) + { + name = "CreateByteField"; + } + else if (code == OpCodeEnum.CreateBitField) + { + name = "CreateBitField"; + } + else if (code == OpCodeEnum.ObjectType) + { + name = "ObjectType"; + } + else if (code == OpCodeEnum.CreateQWordField) + { + name = "CreateQWordField"; + } + else if (code == OpCodeEnum.LogicalAnd) + { + name = "LogicalAnd"; + } + else if (code == OpCodeEnum.LogicalOr) + { + name = "LogicalOr"; + } + else if (code == OpCodeEnum.LogicalNot) + { + name = "LogicalNot"; + } + else if (code == OpCodeEnum.LogicalEqual) + { + name = "LogicalEqual"; + } + else if (code == OpCodeEnum.LogicalGreater) + { + name = "LogicalGreater"; + } + else if (code == OpCodeEnum.LogicalLess) + { + name = "LogicalLess"; + } + else if (code == OpCodeEnum.ToBuffer) + { + name = "ToBuffer"; + } + else if (code == OpCodeEnum.ToDecimalString) + { + name = "ToDecimalString"; + } + else if (code == OpCodeEnum.ToHexString) + { + name = "ToHexString"; + } + else if (code == OpCodeEnum.ToInteger) + { + name = "ToInteger"; + } + else if (code == OpCodeEnum.ToString) + { + name = "ToString"; + } + else if (code == OpCodeEnum.CopyObject) + { + name = "CopyObject"; + } + else if (code == OpCodeEnum.Mid) + { + name = "Mid"; + } + else if (code == OpCodeEnum.Continue) + { + name = "Continue"; + } + else if (code == OpCodeEnum.If) + { + name = "If"; + } + else if (code == OpCodeEnum.Else) + { + name = "Else"; + } + else if (code == OpCodeEnum.While) + { + name = "While"; + } + else if (code == OpCodeEnum.NoOp) + { + name = "NoOp"; + } + else if (code == OpCodeEnum.Return) + { + name = "Return"; + } + else if (code == OpCodeEnum.Break) + { + name = "Break"; + } + else if (code == OpCodeEnum.Comment) + { + name = "Comment"; + } + else if (code == OpCodeEnum.Breakpoint) + { + name = "Breakpoint"; + } + else if (code == OpCodeEnum.Ones) + { + name = "Ones"; + } + else if (code == OpCodeEnum.LogicalGreaterEqual) + { + name = "LogicalGreaterEqual"; + } + else if (code == OpCodeEnum.LogicalLessEqual) + { + name = "LogicalLessEqual"; + } + else if (code == OpCodeEnum.LogicalNotEqual) + { + name = "LogicalNotEqual"; + } + else if (code == OpCodeEnum.ExtendedOpcode) + { + name = "ExtendedOpcode"; + } + else if (code == OpCodeEnum.Mutex) + { + name = "Mutex"; + } + else if (code == OpCodeEnum.Event) + { + name = "Event"; + } + else if (code == OpCodeEnum.ShiftRightBit) + { + name = "ShiftRightBit"; + } + else if (code == OpCodeEnum.ShiftLeftBit) + { + name = "ShiftLeftBit"; + } + else if (code == OpCodeEnum.ConditionalReferenceOf) + { + name = "ConditionalReferenceOf"; + } + else if (code == OpCodeEnum.CreateField) + { + name = "CreateField"; + } + else if (code == OpCodeEnum.LoadTable) + { + name = "LoadTable"; + } + else if (code == OpCodeEnum.Load) + { + name = "Load"; + } + else if (code == OpCodeEnum.Stall) + { + name = "Stall"; + } + else if (code == OpCodeEnum.Sleep) + { + name = "Sleep"; + } + else if (code == OpCodeEnum.Acquire) + { + name = "Acquire"; + } + else if (code == OpCodeEnum.Signal) + { + name = "Signal"; + } + else if (code == OpCodeEnum.Wait) + { + name = "Wait"; + } + else if (code == OpCodeEnum.Reset) + { + name = "Reset"; + } + else if (code == OpCodeEnum.Release) + { + name = "Release"; + } + else if (code == OpCodeEnum.FromBCD) + { + name = "FromBCD"; + } + else if (code == OpCodeEnum.ToBCD) + { + name = "ToBCD"; + } + else if (code == OpCodeEnum.Unload) + { + name = "Unload"; + } + else if (code == OpCodeEnum.Revision) + { + name = "Revision"; + } + else if (code == OpCodeEnum.Debug) + { + name = "Debug"; + } + else if (code == OpCodeEnum.Fatal) + { + name = "Fatal"; + } + else if (code == OpCodeEnum.Timer) + { + name = "Timer"; + } + else if (code == OpCodeEnum.Region) + { + name = "Region"; + } + else if (code == OpCodeEnum.Field) + { + name = "Field"; + } + else if (code == OpCodeEnum.Device) + { + name = "Device"; + } + else if (code == OpCodeEnum.Processor) + { + name = "Processor"; + } + else if (code == OpCodeEnum.PowerResource) + { + name = "PowerResource"; + } + else if (code == OpCodeEnum.ThermalZone) + { + name = "ThermalZone"; + } + else if (code == OpCodeEnum.IndexField) + { + name = "IndexField"; + } + else if (code == OpCodeEnum.BankField) + { + name = "BankField"; + } + else if (code == OpCodeEnum.DataRegion) + { + name = "DataRegion"; + } + else if (code == OpCodeEnum.FieldOffset) + { + name = "FieldOffset"; + } + else if (code == OpCodeEnum.FieldAccess) + { + name = "FieldAccess"; + } + else if (code == OpCodeEnum.FieldConnection) + { + name = "FieldConnection"; + } + else if (code == OpCodeEnum.FieldExternalAccess) + { + name = "FieldExternalAccess"; + } + else if (code == OpCodeEnum.NamePath) + { + name = "NamePath"; + } + else if (code == OpCodeEnum.NamedField) + { + name = "NamedField"; + } + else if (code == OpCodeEnum.ReservedField) + { + name = "ReservedField"; + } + else if (code == OpCodeEnum.AccessField) + { + name = "AccessField"; + } + else if (code == OpCodeEnum.ByteList) + { + name = "ByteList"; + } + else if (code == OpCodeEnum.MethodCall) + { + name = "MethodCall"; + } + else if (code == OpCodeEnum.ReturnValue) + { + name = "ReturnValue"; + } + else if (code == OpCodeEnum.EvalSubtree) + { + name = "EvalSubtree"; + } + else if (code == OpCodeEnum.Connection) + { + name = "Connection"; + } + else if (code == OpCodeEnum.ExternalAccessField) + { + name = "ExternalAccessField"; + } + + return name; } public override string ToString() diff --git a/source/Cosmos.Core/ACPI/Parser2/Parser.cs b/source/Cosmos.Core/ACPI/Parser2/Parser.cs index a6b6296c9e..9fd854c5ae 100644 --- a/source/Cosmos.Core/ACPI/Parser2/Parser.cs +++ b/source/Cosmos.Core/ACPI/Parser2/Parser.cs @@ -1,4 +1,5 @@ using ACPILib.AML; +using Cosmos.Core; using System; using System.Collections.Generic; using System.IO; @@ -18,8 +19,6 @@ public Parser(Stream s) public ParseNode Parse() { return PreParse(); - - return null; } private ParseNode PreParse() @@ -141,7 +140,8 @@ private ParseNode ParseFullOpCodeNode() break; default: - throw new Exception("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); + Global.mDebugger.Send("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); + break; } } } @@ -160,10 +160,53 @@ private ParseNode ParseFullOpCodeNode() } } - return op; + Global.mDebugger.Send("OpCode = " + op.Op.ToString()); + Global.mDebugger.Send("Start = " + op.Start.ToString()); + Global.mDebugger.Send("Length = " + op.Length.ToString()); + Global.mDebugger.Send("End = " + op.End.ToString()); + if (op.ConstantValue != null) + { + Global.mDebugger.Send("Value = " + ValueToString(op.ConstantValue)); + } + + return op; } - private ParseNode ReadField() + private static string ValueToString(object val) + { + if (val == null) + return "null"; + + if (val is string) + return "\"" + val.ToString() + "\""; + + if (val is byte) + return "0x" + ((byte)val).ToString("X2"); + + if (val.GetType().IsArray) + { + Array ar = (Array)val; + + string rt = ""; + + for (int x = 0; x < ar.Length; x++) + rt += ValueToString(ar.GetValue(x)) + (x < ar.Length - 1 ? ", " : string.Empty); + + return rt; + } + + if (val is ParseNode) + { + ParseNode node = (ParseNode)val; + + if (node.ConstantValue != null) + return ValueToString(node.ConstantValue); + } + + return val.ToString(); + } + + private ParseNode ReadField() { OpCodeEnum opCode; switch ((OpCodeEnum)PeekByte()) @@ -331,7 +374,8 @@ private ParseNode ReadOpCode() pos -= 1; //The op code byte is the data itself break; case OpCodeClass.ClassUnknown: - throw new Exception("Unknown AML opcode: 0x" + op.ToString("X2")); + Global.mDebugger.Send("Unknown AML opcode: 0x" + op.ToString("X")); + break; default: _source.Seek(info.CodeByteSize, SeekOrigin.Current); break; diff --git a/source/Cosmos.Core_Plugs/Interop/GlobalizationImpl.cs b/source/Cosmos.Core_Plugs/Interop/GlobalizationImpl.cs index 5b3e72ba67..5bd1aa9b7d 100644 --- a/source/Cosmos.Core_Plugs/Interop/GlobalizationImpl.cs +++ b/source/Cosmos.Core_Plugs/Interop/GlobalizationImpl.cs @@ -33,6 +33,10 @@ public static void InitOrdinalCasingPage() { throw new NotImplementedException(); } + public static unsafe void InitOrdinalCasingPage(int pageNumber, char* pTarget) + { + throw new NotImplementedException(); + } public static void InitICUFunctions(IntPtr aPtr1, IntPtr aPtr2, string aString1, string aString2) { From 0f73e241cb2e62eea613332936849d3fc4e24ce4 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Wed, 15 Jun 2022 04:40:28 +0200 Subject: [PATCH 24/35] Parse IRQ Routing Tables using AML + Hardparse S5 --- source/Cosmos.Core/ACPI/ACPI.cs | 140 ++++++++++- source/Cosmos.Core/ACPI/AML/OpCode.cs | 2 +- source/Cosmos.Core/ACPI/AML/OpCodeTable.cs | 236 +++++++++--------- source/Cosmos.Core/ACPI/Parser/AMLOp.cs | 2 +- source/Cosmos.Core/ACPI/Parser/Parser.cs | 2 +- .../ACPI/Parser2/{Parser.cs => Parser2.cs} | 76 ++---- 6 files changed, 274 insertions(+), 184 deletions(-) rename source/Cosmos.Core/ACPI/Parser2/{Parser.cs => Parser2.cs} (80%) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index b0293d0b76..42042b38ba 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -402,6 +402,8 @@ struct ApicInterruptOverride /// public static FADTPtr* FADT; + public static uint DSDTLenght = 0; + /// /// Check ACPI header. /// @@ -573,11 +575,81 @@ private static void ReadHeader(BinaryReader _reader) Global.mDebugger.Send("\tCreatorRevision: " + _reader.ReadUInt32().ToString()); } + private static void ParseS5() + { + byte* S5Addr = (byte*)FADT->Dsdt; + + while (0 < DSDTLenght--) + { + if (Compare("_S5_", S5Addr) == 0) + { + break; + } + S5Addr++; + } + + if (DSDTLenght > 0) + { + if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) + { + S5Addr += 5; + S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; + if (*S5Addr == 0x0A) + { + S5Addr++; + } + SLP_TYPa = (short)(*(S5Addr) << 10); + S5Addr++; + if (*S5Addr == 0x0A) + { + S5Addr++; + } + SLP_TYPb = (short)(*(S5Addr) << 10); + + Console.WriteLine("SLP_TYPa=" + SLP_TYPa); + Console.WriteLine("SLP_TYPb=" + SLP_TYPb); + } + } + } + + private static void ParsePRT() + { + byte* S5Addr = (byte*)FADT->Dsdt; + + while (0 < DSDTLenght--) + { + if (Compare("_PRT", S5Addr) == 0) + { + break; + } + S5Addr++; + } + + if (DSDTLenght > 0) + { + var dsdtBlock = new MemoryBlock08((uint)S5Addr, SdtLength); + + Stream stream = new MemoryStream(dsdtBlock.ToArray()); + + Console.WriteLine("Create parser..."); + + var root = new Parser(stream); + + Console.WriteLine("Parsing ACPI DST _PRT Method..."); + + var node = root.Parse(); + + Console.WriteLine("Parsed! Trying to list IRQ Routing Table..."); + + PopulateNode(node); + } + } + private static void ParseDT(AcpiHeader* hdr) { var signature = Encoding.ASCII.GetString(hdr->Signature, 4); - Global.mDebugger.Send(signature + " detected"); + Console.WriteLine(signature + " detected"); if (signature == "FACP") { @@ -608,17 +680,13 @@ private static void ParseDT(AcpiHeader* hdr) ReadHeader(_reader); - var dsdtBlock = new MemoryBlock08(dsdtAddress, SdtLength); - - Stream stream = new MemoryStream(dsdtBlock.ToArray()); - - Global.mDebugger.Send("Create parser..."); + Console.WriteLine("Parsing S5..."); - var root = new Parser(stream); + ParseS5(); - Global.mDebugger.Send("Parse first node..."); + Console.WriteLine("Parsing PRT..."); - var node = root.Parse(); + ParsePRT(); } } else if (signature == "APIC") @@ -665,6 +733,60 @@ private static void ParseDT(AcpiHeader* hdr) } } + private static void PopulateNode(ParseNode op) + { + //Recursive function does a null reference exception trick the matrice with a Stack and iterative function + var sthack = new Stack(); + + sthack.Push(op); + + while (sthack.Count != 0) + { + ParseNode current = sthack.Pop(); + + if (current.Arguments.Count > 0) + { + SearchPackage(current); + } + + if (current != null) + { + for (int i = current.Nodes.Count - 1; i >= 0; i--) + { + sthack.Push(current.Nodes[i]); + } + } + } + } + + private static void SearchPackage(ParseNode op) + { + for (int x = 0; x < op.Op.ParseArgs.Length; x++) + { + if (op.Op.ParseArgs[x] == ParseArgFlags.DataObjectList || op.Op.ParseArgs[x] == ParseArgFlags.TermList || op.Op.ParseArgs[x] == ParseArgFlags.ObjectList) + continue; + + if (op.Arguments[x].ToString() == "Package") + { + var arg = (ParseNode)op.Arguments[x]; + + Console.WriteLine("FOUND PACKAGES"); + + for (int y = 0; y < arg.Nodes.Count; y++) + { + Console.WriteLine("FOUND PACKAGE " + y); + + List package = arg.Nodes[y].Nodes; + + Console.WriteLine("Address=0x" + ((int)package[0].ConstantValue).ToString("X")); + Console.WriteLine("Pin=" + (byte)package[1].ConstantValue); + Console.WriteLine("Source=" + (byte)package[2].ConstantValue); + Console.WriteLine("Source Index=" + (byte)package[3].ConstantValue); + } + } + } + } + /// /// Enable ACPI. /// diff --git a/source/Cosmos.Core/ACPI/AML/OpCode.cs b/source/Cosmos.Core/ACPI/AML/OpCode.cs index 04efa408f9..2657d5c548 100644 --- a/source/Cosmos.Core/ACPI/AML/OpCode.cs +++ b/source/Cosmos.Core/ACPI/AML/OpCode.cs @@ -635,7 +635,7 @@ private string GetName(OpCodeEnum code) return name; } - public override string ToString() + public override string ToString() { return Name; } diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs index 556b5da818..655c8e7681 100644 --- a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs +++ b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs @@ -71,155 +71,155 @@ public class OpCodeTable public static OpCode[] OpCodes = new OpCode[] { /* Index Name Parser Args Interpreter Args ObjectType Class Type Flags */ -/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), /* 1C */ new OpCode(OpCodeEnum.ReferenceOf, ParseArgs.ARGP_REF_OF_OP, InterpreterArgs.ARGI_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), -/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), +/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), /* 2E */ new OpCode(OpCodeEnum.DereferenceOf, ParseArgs.ARGP_DEREF_OF_OP, InterpreterArgs.ARGI_DEREF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), -/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), -/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), -/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), -/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), +/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), +/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), +/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), /* 38 */ new OpCode(OpCodeEnum.LogicalAnd, ParseArgs.ARGP_LAND_OP, InterpreterArgs.ARGI_LAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), /* 39 */ new OpCode(OpCodeEnum.LogicalOr, ParseArgs.ARGP_LOR_OP, InterpreterArgs.ARGI_LOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), /* 3A */ new OpCode(OpCodeEnum.LogicalNot, ParseArgs.ARGP_LNOT_OP, InterpreterArgs.ARGI_LNOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), /* 3B */ new OpCode(OpCodeEnum.LogicalEqual, ParseArgs.ARGP_LEQUAL_OP, InterpreterArgs.ARGI_LEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), /* 3C */ new OpCode(OpCodeEnum.LogicalGreater, ParseArgs.ARGP_LGREATER_OP, InterpreterArgs.ARGI_LGREATER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), /* 3D */ new OpCode(OpCodeEnum.LogicalLess, ParseArgs.ARGP_LLESS_OP, InterpreterArgs.ARGI_LLESS_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), -/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), /* Prefixed opcodes (Two-byte opcodes with a prefix op) */ -/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), /* 48 */ new OpCode(OpCodeEnum.ConditionalReferenceOf, ParseArgs.ARGP_COND_REF_OF_OP, InterpreterArgs.ARGI_COND_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), -/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), -/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), -/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), +/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), +/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), +/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), +/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), /* Internal opcodes that map to invalid AML opcodes */ /* 60 */ new OpCode(OpCodeEnum.LogicalNotEqual, ParseArgs.ARGP_LNOTEQUAL_OP, InterpreterArgs.ARGI_LNOTEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), /* 61 */ new OpCode(OpCodeEnum.LogicalLessEqual, ParseArgs.ARGP_LLESSEQUAL_OP, InterpreterArgs.ARGI_LLESSEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), /* 62 */ new OpCode(OpCodeEnum.LogicalGreaterEqual, ParseArgs.ARGP_LGREATEREQUAL_OP, InterpreterArgs.ARGI_LGREATEREQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), -/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), -/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), -/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), -/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), -/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), -/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), +/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), +/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), +/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), +/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), /* ACPI 2.0 opcodes */ -/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), /* 6F */ new OpCode(OpCodeEnum.Package, /* Var */ ParseArgs.ARGP_VAR_PACKAGE_OP, InterpreterArgs.ARGI_VAR_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer), -/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), -/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), -/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), +/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), +/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), +/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), /* ACPI 3.0 opcodes */ -/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), +/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), /* ACPI 5.0 opcodes */ -/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), /* ACPI 6.0 opcodes */ -/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) +/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) }; public static OpCode GetOpcode(ushort opCodeValue) diff --git a/source/Cosmos.Core/ACPI/Parser/AMLOp.cs b/source/Cosmos.Core/ACPI/Parser/AMLOp.cs index b5418cdd48..394709db51 100644 --- a/source/Cosmos.Core/ACPI/Parser/AMLOp.cs +++ b/source/Cosmos.Core/ACPI/Parser/AMLOp.cs @@ -57,7 +57,7 @@ public AMLOp FindMethod(string name) if (OpCode != null && OpCode.Code == OpCodeEnum.Method && Name == name) return this; - foreach(AMLOp node in Nodes) + foreach (AMLOp node in Nodes) { AMLOp method = node.FindMethod(name); diff --git a/source/Cosmos.Core/ACPI/Parser/Parser.cs b/source/Cosmos.Core/ACPI/Parser/Parser.cs index 298cdec437..d103b151e4 100644 --- a/source/Cosmos.Core/ACPI/Parser/Parser.cs +++ b/source/Cosmos.Core/ACPI/Parser/Parser.cs @@ -260,7 +260,7 @@ private AMLOp ReadTermArg(AMLOp parent) //Check if all of the chars are letters bool probalbyString = true; - for(int x = 0; x < peek4.Length; x++) + for (int x = 0; x < peek4.Length; x++) { if (!char.IsDigit((char)peek4[x]) && !char.IsUpper((char)peek4[x])) { diff --git a/source/Cosmos.Core/ACPI/Parser2/Parser.cs b/source/Cosmos.Core/ACPI/Parser2/Parser2.cs similarity index 80% rename from source/Cosmos.Core/ACPI/Parser2/Parser.cs rename to source/Cosmos.Core/ACPI/Parser2/Parser2.cs index 9fd854c5ae..28b77795fb 100644 --- a/source/Cosmos.Core/ACPI/Parser2/Parser.cs +++ b/source/Cosmos.Core/ACPI/Parser2/Parser2.cs @@ -1,5 +1,4 @@ using ACPILib.AML; -using Cosmos.Core; using System; using System.Collections.Generic; using System.IO; @@ -11,6 +10,8 @@ public class Parser { private Stream _source; + public bool stop = false; + public Parser(Stream s) { _source = s; @@ -21,9 +22,11 @@ public ParseNode Parse() return PreParse(); } + ParseNode root; + private ParseNode PreParse() { - ParseNode root = new ParseNode() + root = new ParseNode() { Name = "\\" }; @@ -33,6 +36,11 @@ private ParseNode PreParse() ParseNode op = ParseFullOpCodeNode(); root.Nodes.Add(op); + + if (stop == true) + { + return root; + } } return root; @@ -108,7 +116,7 @@ private ParseNode ParseFullOpCodeNode() break; case ParseArgFlags.FieldList: - while(_source.Position < op.End) + while (_source.Position < op.End) { op.Arguments.Add(ReadField()); } @@ -140,8 +148,7 @@ private ParseNode ParseFullOpCodeNode() break; default: - Global.mDebugger.Send("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); - break; + throw new Exception("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); } } } @@ -160,53 +167,15 @@ private ParseNode ParseFullOpCodeNode() } } - Global.mDebugger.Send("OpCode = " + op.Op.ToString()); - Global.mDebugger.Send("Start = " + op.Start.ToString()); - Global.mDebugger.Send("Length = " + op.Length.ToString()); - Global.mDebugger.Send("End = " + op.End.ToString()); - if (op.ConstantValue != null) - { - Global.mDebugger.Send("Value = " + ValueToString(op.ConstantValue)); - } + if (op.Op.ToString() == "Return") + { + stop = true; + } - return op; + return op; } - private static string ValueToString(object val) - { - if (val == null) - return "null"; - - if (val is string) - return "\"" + val.ToString() + "\""; - - if (val is byte) - return "0x" + ((byte)val).ToString("X2"); - - if (val.GetType().IsArray) - { - Array ar = (Array)val; - - string rt = ""; - - for (int x = 0; x < ar.Length; x++) - rt += ValueToString(ar.GetValue(x)) + (x < ar.Length - 1 ? ", " : string.Empty); - - return rt; - } - - if (val is ParseNode) - { - ParseNode node = (ParseNode)val; - - if (node.ConstantValue != null) - return ValueToString(node.ConstantValue); - } - - return val.ToString(); - } - - private ParseNode ReadField() + private ParseNode ReadField() { OpCodeEnum opCode; switch ((OpCodeEnum)PeekByte()) @@ -325,7 +294,7 @@ private string ReadNameString() } int segments = 0; - switch(ReadByte()) + switch (ReadByte()) { case 0: //Null string return string.Empty; @@ -374,8 +343,7 @@ private ParseNode ReadOpCode() pos -= 1; //The op code byte is the data itself break; case OpCodeClass.ClassUnknown: - Global.mDebugger.Send("Unknown AML opcode: 0x" + op.ToString("X")); - break; + throw new Exception("Unknown AML opcode: 0x" + op.ToString("X2")); default: _source.Seek(info.CodeByteSize, SeekOrigin.Current); break; @@ -387,7 +355,7 @@ private ParseNode ReadOpCode() Start = pos, DataStart = pos + info.CodeByteSize }; - } + } private string Read4ByteName() { @@ -422,7 +390,7 @@ private byte ReadByte() private ushort PeekOpcode() { ushort code = (ushort)_source.ReadByte(); - if(code == Definitions.ExtendedOpCodePrefix) + if (code == Definitions.ExtendedOpCodePrefix) { code = (ushort)((code << 8) | (ushort)_source.ReadByte()); From 410fa5e6e79ffbb78493f2962e40f4aaafea7cb0 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Wed, 15 Jun 2022 05:24:54 +0200 Subject: [PATCH 25/35] Put IRQ routing in list --- source/Cosmos.Core/ACPI/ACPI.cs | 69 +++++++++++++------ .../Drivers/PCI/Network/AMDPCNetII.cs | 17 +++++ source/Cosmos.HAL2/PCIDevice.cs | 2 +- 3 files changed, 67 insertions(+), 21 deletions(-) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index 42042b38ba..67090c96ea 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -9,6 +9,32 @@ namespace Cosmos.Core { + /// + /// PCI IRQ Routing information. + /// + public class IrqRouting + { + /// + /// The address of the PCI device. + /// + public uint Address; + + /// + /// The PCI pin number of the device. + /// + public byte Pin; + + /// + /// Source. + /// + public byte Source; + + /// + /// Source Index. + /// + public byte SourceIndex; + } + /// /// ACPI (Advanced Configuration and Power Interface) class. /// @@ -404,6 +430,11 @@ struct ApicInterruptOverride public static uint DSDTLenght = 0; + /// + /// PCI IRQ Routing Table. + /// + public static List IrqRoutingTable; + /// /// Check ACPI header. /// @@ -519,6 +550,7 @@ public static void Reboot() private static bool Init() { IOAPIC = null; + IrqRoutingTable = new List(); var rsdp = RSDPAddress(); var ptr = (byte*)rsdp; @@ -606,8 +638,8 @@ private static void ParseS5() } SLP_TYPb = (short)(*(S5Addr) << 10); - Console.WriteLine("SLP_TYPa=" + SLP_TYPa); - Console.WriteLine("SLP_TYPb=" + SLP_TYPb); + Global.mDebugger.Send("SLP_TYPa=" + SLP_TYPa); + Global.mDebugger.Send("SLP_TYPb=" + SLP_TYPb); } } } @@ -631,15 +663,15 @@ private static void ParsePRT() Stream stream = new MemoryStream(dsdtBlock.ToArray()); - Console.WriteLine("Create parser..."); + Global.mDebugger.Send("Create parser..."); var root = new Parser(stream); - Console.WriteLine("Parsing ACPI DST _PRT Method..."); + Global.mDebugger.Send("Parsing ACPI DST _PRT Method..."); var node = root.Parse(); - Console.WriteLine("Parsed! Trying to list IRQ Routing Table..."); + Global.mDebugger.Send("Parsed! Trying to list IRQ Routing Table..."); PopulateNode(node); } @@ -649,7 +681,7 @@ private static void ParseDT(AcpiHeader* hdr) { var signature = Encoding.ASCII.GetString(hdr->Signature, 4); - Console.WriteLine(signature + " detected"); + Global.mDebugger.Send(signature + " detected"); if (signature == "FACP") { @@ -680,11 +712,11 @@ private static void ParseDT(AcpiHeader* hdr) ReadHeader(_reader); - Console.WriteLine("Parsing S5..."); + Global.mDebugger.Send("Parsing _S5..."); ParseS5(); - Console.WriteLine("Parsing PRT..."); + Global.mDebugger.Send("Parsing _PRT..."); ParsePRT(); } @@ -705,13 +737,11 @@ private static void ParseDT(AcpiHeader* hdr) if (type == ApicType.LocalAPIC) { - Global.mDebugger.Send("Parse local APIC"); var pic = (ApicLocalApic*)p; Global.mDebugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); } else if (type == ApicType.IOAPIC) { - Global.mDebugger.Send("Parse IO APIC"); var ioapic = (ApicIOApic*)p; if (IOAPIC == null) { @@ -721,8 +751,6 @@ private static void ParseDT(AcpiHeader* hdr) } else if (type == ApicType.InterruptOverride) { - Global.mDebugger.Send("Parse Interrupt Override APIC"); - var ovr = (ApicInterruptOverride*)p; Global.mDebugger.Send("Found APIC Interrupt Override (Bus: " + ((ulong)ovr->Bus).ToString() + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:0x" + ((ulong)ovr->Interrupt).ToString("X") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); @@ -770,18 +798,19 @@ private static void SearchPackage(ParseNode op) { var arg = (ParseNode)op.Arguments[x]; - Console.WriteLine("FOUND PACKAGES"); - for (int y = 0; y < arg.Nodes.Count; y++) { - Console.WriteLine("FOUND PACKAGE " + y); - List package = arg.Nodes[y].Nodes; - Console.WriteLine("Address=0x" + ((int)package[0].ConstantValue).ToString("X")); - Console.WriteLine("Pin=" + (byte)package[1].ConstantValue); - Console.WriteLine("Source=" + (byte)package[2].ConstantValue); - Console.WriteLine("Source Index=" + (byte)package[3].ConstantValue); + var irqRouting = new IrqRouting() + { + Address = (uint)((int)package[0].ConstantValue), + Pin = (byte)package[1].ConstantValue, + Source = (byte)package[2].ConstantValue, + SourceIndex = (byte)package[3].ConstantValue + }; + + IrqRoutingTable.Add(irqRouting); } } } diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index 043502cc16..52a15fcc05 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -96,6 +96,23 @@ public AMDPCNetII(PCIDevice device) mTransmitBuffer = new Queue(); mRecvBuffer = new Queue(); + var deviceAddress = PCIDevice.GetAddressBase(device.bus, device.slot, device.function); + + Global.mDebugger.Send("PCI Device Address=0x" + deviceAddress.ToString("X")); + + foreach (var irqRouting in ACPI.IrqRoutingTable) + { + Global.mDebugger.Send("Address=0x" + irqRouting.Address.ToString("X")); + Global.mDebugger.Send("Pin=" + irqRouting.Pin); + Global.mDebugger.Send("Source=" + irqRouting.Source); + Global.mDebugger.Send("Source Index=" + irqRouting.SourceIndex); + + if (irqRouting.Address == deviceAddress) + { + Global.mDebugger.Send("DEVICE MATCH!"); + } + } + INTs.SetIrqHandler(device.InterruptLine, HandleNetworkInterrupt); } diff --git a/source/Cosmos.HAL2/PCIDevice.cs b/source/Cosmos.HAL2/PCIDevice.cs index 651e594f74..4d6853e804 100644 --- a/source/Cosmos.HAL2/PCIDevice.cs +++ b/source/Cosmos.HAL2/PCIDevice.cs @@ -301,7 +301,7 @@ protected void WriteRegister32(byte aRegister, uint value) /// A slot. /// A function. /// UInt32 value. - protected static uint GetAddressBase(uint aBus, uint aSlot, uint aFunction) + public static uint GetAddressBase(uint aBus, uint aSlot, uint aFunction) { return 0x80000000 | (aBus << 16) | ((aSlot & 0x1F) << 11) | ((aFunction & 0x07) << 8); } From ba8b53ffcf9d8dfda80d4d6e6630d7c7e3977528 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Wed, 15 Jun 2022 15:15:16 +0200 Subject: [PATCH 26/35] Add multi CPU detection + Comment AMDPCNETII IRQ Init I still can't find the AMD PCNET II IRQ routing from the routing table.... Is ACPI bad configured? Or IO APIC? --- source/Cosmos.Core/ACPI/ACPI.cs | 22 ++++++++++++++-- .../Drivers/PCI/Network/AMDPCNetII.cs | 25 +++++++++++++------ 2 files changed, 37 insertions(+), 10 deletions(-) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index 67090c96ea..215f180086 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -435,6 +435,11 @@ struct ApicInterruptOverride /// public static List IrqRoutingTable; + /// + /// PCI IRQ Routing Table. + /// + public static List LocalApicCpus; + /// /// Check ACPI header. /// @@ -551,6 +556,8 @@ private static bool Init() { IOAPIC = null; IrqRoutingTable = new List(); + LocalApicCpus = new List(); + var rsdp = RSDPAddress(); var ptr = (byte*)rsdp; @@ -569,6 +576,11 @@ private static bool Init() ParseDT((AcpiHeader*)address); } + if (LocalApicCpus.Count > 0) + { + Global.mDebugger.Send("Found " + LocalApicCpus.Count + " CPUs via MADT."); + } + return true; } @@ -738,7 +750,13 @@ private static void ParseDT(AcpiHeader* hdr) if (type == ApicType.LocalAPIC) { var pic = (ApicLocalApic*)p; - Global.mDebugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); + + if (((pic->Flags & 1) ^ ((pic->Flags >> 1) & 1)) != 0) + { + LocalApicCpus.Add(pic->ApicId); + + Global.mDebugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); + } } else if (type == ApicType.IOAPIC) { @@ -804,7 +822,7 @@ private static void SearchPackage(ParseNode op) var irqRouting = new IrqRouting() { - Address = (uint)((int)package[0].ConstantValue), + Address = (uint)package[0].ConstantValue, Pin = (byte)package[1].ConstantValue, Source = (byte)package[2].ConstantValue, SourceIndex = (byte)package[3].ConstantValue diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index 52a15fcc05..3d4ad9c4dc 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -96,28 +96,37 @@ public AMDPCNetII(PCIDevice device) mTransmitBuffer = new Queue(); mRecvBuffer = new Queue(); - var deviceAddress = PCIDevice.GetAddressBase(device.bus, device.slot, device.function); + //INTs.SetIntHandler((byte)(0x20 + device.InterruptLine), HandleNetworkInterrupt); + //IOAPIC.SetEntry(19, (byte)(0x20 + device.InterruptLine)); - Global.mDebugger.Send("PCI Device Address=0x" + deviceAddress.ToString("X")); + /*Global.mDebugger.Send("device slot=" + device.slot); + Global.mDebugger.Send("device function=" + device.function); foreach (var irqRouting in ACPI.IrqRoutingTable) { - Global.mDebugger.Send("Address=0x" + irqRouting.Address.ToString("X")); + byte slot = (byte)((irqRouting.Address >> 16) & 0xFFFF); + byte function = (byte)(irqRouting.Address & 0xFFFF); + + Global.mDebugger.Send("slot=" + slot); + Global.mDebugger.Send("function=" + function); + Global.mDebugger.Send("Address=0x" + (irqRouting.Address).ToString("X")); Global.mDebugger.Send("Pin=" + irqRouting.Pin); Global.mDebugger.Send("Source=" + irqRouting.Source); Global.mDebugger.Send("Source Index=" + irqRouting.SourceIndex); - if (irqRouting.Address == deviceAddress) + if (device.slot == slot && device.function == function) { - Global.mDebugger.Send("DEVICE MATCH!"); - } - } + Global.mDebugger.Send("DEVICE FOUND SETTING CUSTOM IRQ " + irqRouting.SourceIndex); - INTs.SetIrqHandler(device.InterruptLine, HandleNetworkInterrupt); + + } + }*/ } protected void HandleNetworkInterrupt(ref INTs.IRQContext aContext) { + Global.mDebugger.Send("Network IRQ!"); + uint cur_status = StatusRegister; if ((cur_status & 0x100) != 0) From fce9907aa0af1908b924683235a36049d751af79 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 19 Jun 2022 18:49:09 +0200 Subject: [PATCH 27/35] "Fix" IRQ routing for PCI devices --- .../Drivers/PCI/Network/AMDPCNetII.cs | 32 ++++--------------- .../Drivers/PCI/Network/RTL8139.cs | 10 +++++- 2 files changed, 16 insertions(+), 26 deletions(-) diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index 3d4ad9c4dc..f82e370afb 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -96,37 +96,19 @@ public AMDPCNetII(PCIDevice device) mTransmitBuffer = new Queue(); mRecvBuffer = new Queue(); - //INTs.SetIntHandler((byte)(0x20 + device.InterruptLine), HandleNetworkInterrupt); - //IOAPIC.SetEntry(19, (byte)(0x20 + device.InterruptLine)); + INTs.SetIntHandler((byte)(0x20 + device.InterruptLine), HandleNetworkInterrupt); - /*Global.mDebugger.Send("device slot=" + device.slot); - Global.mDebugger.Send("device function=" + device.function); - - foreach (var irqRouting in ACPI.IrqRoutingTable) + //Route IRQ for all IO/APIC PCI IRQ (I16-I20) + //We will have to fix this if we use multiple PCI devices that requires interrupts + //TODO: Use ACPI to find IRQ route + for (byte i = 0; i < 4; i++) { - byte slot = (byte)((irqRouting.Address >> 16) & 0xFFFF); - byte function = (byte)(irqRouting.Address & 0xFFFF); - - Global.mDebugger.Send("slot=" + slot); - Global.mDebugger.Send("function=" + function); - Global.mDebugger.Send("Address=0x" + (irqRouting.Address).ToString("X")); - Global.mDebugger.Send("Pin=" + irqRouting.Pin); - Global.mDebugger.Send("Source=" + irqRouting.Source); - Global.mDebugger.Send("Source Index=" + irqRouting.SourceIndex); - - if (device.slot == slot && device.function == function) - { - Global.mDebugger.Send("DEVICE FOUND SETTING CUSTOM IRQ " + irqRouting.SourceIndex); - - - } - }*/ + IOAPIC.SetEntry((byte)(16 + i), (ulong)(0x20 + device.InterruptLine)); + } } protected void HandleNetworkInterrupt(ref INTs.IRQContext aContext) { - Global.mDebugger.Send("Network IRQ!"); - uint cur_status = StatusRegister; if ((cur_status & 0x100) != 0) diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/RTL8139.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/RTL8139.cs index 499915c67d..68d7295d36 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/RTL8139.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/RTL8139.cs @@ -31,7 +31,15 @@ public RTL8139(PCIDevice device) // We are handling this device pciCard.Claimed = true; // Setup interrupt handling - INTs.SetIrqHandler(device.InterruptLine, HandleNetworkInterrupt); + INTs.SetIntHandler((byte)(0x20 + device.InterruptLine), HandleNetworkInterrupt); + + //Route IRQ for all IO/APIC PCI IRQ (I16-I20) + //We will have to fix this if we use multiple PCI devices that requires interrupts + //TODO: Use ACPI to find IRQ route + for (byte i = 0; i < 4; i++) + { + IOAPIC.SetEntry((byte)(16 + i), (ulong)(0x20 + device.InterruptLine)); + } // Get IO Address from PCI Bus // Enable the card pciCard.EnableDevice(); From 0dadc0b223f0a0de9df6de7b30807ec700d74ba4 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 19 Jun 2022 18:57:04 +0200 Subject: [PATCH 28/35] Update comment --- source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs index f82e370afb..21866892d9 100644 --- a/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/PCI/Network/AMDPCNetII.cs @@ -98,9 +98,14 @@ public AMDPCNetII(PCIDevice device) INTs.SetIntHandler((byte)(0x20 + device.InterruptLine), HandleNetworkInterrupt); - //Route IRQ for all IO/APIC PCI IRQ (I16-I20) - //We will have to fix this if we use multiple PCI devices that requires interrupts - //TODO: Use ACPI to find IRQ route + /*** + Route IRQ for all IO/APIC PCI IRQ (I16-I20) + + We will have to fix this if we use multiple PCI devices that requires interrupts + It will causes interrupts conflicts + + TODO: Use ACPI to find right IRQ route + ***/ for (byte i = 0; i < 4; i++) { IOAPIC.SetEntry((byte)(16 + i), (ulong)(0x20 + device.InterruptLine)); From 78d9068cb5d229001dfb03c181e11930e6a18981 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 19 Jun 2022 19:46:24 +0200 Subject: [PATCH 29/35] Update ACPILib with last @MishaTY changes --- source/Cosmos.Core/ACPI/ACPI.cs | 6 +- source/Cosmos.Core/ACPI/AML/Definitions.cs | 2 +- source/Cosmos.Core/ACPI/AML/OpCode.cs | 2 +- source/Cosmos.Core/ACPI/AML/OpCodeTable.cs | 236 ++--- source/Cosmos.Core/ACPI/Interupter/EisaId.cs | 26 + .../ACPI/Interupter/StackObject.cs | 69 ++ source/Cosmos.Core/ACPI/Parser/Parser.cs | 2 +- source/Cosmos.Core/ACPI/Parser2/ParseNode.cs | 7 +- source/Cosmos.Core/ACPI/Parser2/Parser2.cs | 929 ++++++++++-------- 9 files changed, 755 insertions(+), 524 deletions(-) create mode 100644 source/Cosmos.Core/ACPI/Interupter/EisaId.cs create mode 100644 source/Cosmos.Core/ACPI/Interupter/StackObject.cs diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index 215f180086..ffe7acee63 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -814,8 +814,11 @@ private static void SearchPackage(ParseNode op) if (op.Arguments[x].ToString() == "Package") { - var arg = (ParseNode)op.Arguments[x]; + Global.mDebugger.Send("Package found!"); + //var arg = (ParseNode)op.Arguments[x]; + + /* for (int y = 0; y < arg.Nodes.Count; y++) { List package = arg.Nodes[y].Nodes; @@ -830,6 +833,7 @@ private static void SearchPackage(ParseNode op) IrqRoutingTable.Add(irqRouting); } + */ } } } diff --git a/source/Cosmos.Core/ACPI/AML/Definitions.cs b/source/Cosmos.Core/ACPI/AML/Definitions.cs index 4f22eb393f..b6008abbf9 100644 --- a/source/Cosmos.Core/ACPI/AML/Definitions.cs +++ b/source/Cosmos.Core/ACPI/AML/Definitions.cs @@ -1,4 +1,4 @@ -namespace ACPILib.AML +namespace ACPILibs.AML { public class Definitions { diff --git a/source/Cosmos.Core/ACPI/AML/OpCode.cs b/source/Cosmos.Core/ACPI/AML/OpCode.cs index 2657d5c548..04efa408f9 100644 --- a/source/Cosmos.Core/ACPI/AML/OpCode.cs +++ b/source/Cosmos.Core/ACPI/AML/OpCode.cs @@ -635,7 +635,7 @@ private string GetName(OpCodeEnum code) return name; } - public override string ToString() + public override string ToString() { return Name; } diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs index 655c8e7681..556b5da818 100644 --- a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs +++ b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs @@ -71,155 +71,155 @@ public class OpCodeTable public static OpCode[] OpCodes = new OpCode[] { /* Index Name Parser Args Interpreter Args ObjectType Class Type Flags */ -/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), +/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), +/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), +/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), /* 1C */ new OpCode(OpCodeEnum.ReferenceOf, ParseArgs.ARGP_REF_OF_OP, InterpreterArgs.ARGI_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), -/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), +/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), +/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), +/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), /* 2E */ new OpCode(OpCodeEnum.DereferenceOf, ParseArgs.ARGP_DEREF_OF_OP, InterpreterArgs.ARGI_DEREF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), -/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), -/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), -/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), -/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), +/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), +/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), +/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), +/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), /* 38 */ new OpCode(OpCodeEnum.LogicalAnd, ParseArgs.ARGP_LAND_OP, InterpreterArgs.ARGI_LAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), /* 39 */ new OpCode(OpCodeEnum.LogicalOr, ParseArgs.ARGP_LOR_OP, InterpreterArgs.ARGI_LOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), /* 3A */ new OpCode(OpCodeEnum.LogicalNot, ParseArgs.ARGP_LNOT_OP, InterpreterArgs.ARGI_LNOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), /* 3B */ new OpCode(OpCodeEnum.LogicalEqual, ParseArgs.ARGP_LEQUAL_OP, InterpreterArgs.ARGI_LEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), /* 3C */ new OpCode(OpCodeEnum.LogicalGreater, ParseArgs.ARGP_LGREATER_OP, InterpreterArgs.ARGI_LGREATER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), /* 3D */ new OpCode(OpCodeEnum.LogicalLess, ParseArgs.ARGP_LLESS_OP, InterpreterArgs.ARGI_LLESS_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), -/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), +/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), +/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), /* Prefixed opcodes (Two-byte opcodes with a prefix op) */ -/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), /* 48 */ new OpCode(OpCodeEnum.ConditionalReferenceOf, ParseArgs.ARGP_COND_REF_OF_OP, InterpreterArgs.ARGI_COND_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), -/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), -/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), -/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), +/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), +/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), +/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), +/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), +/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), +/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), +/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), +/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), /* Internal opcodes that map to invalid AML opcodes */ /* 60 */ new OpCode(OpCodeEnum.LogicalNotEqual, ParseArgs.ARGP_LNOTEQUAL_OP, InterpreterArgs.ARGI_LNOTEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), /* 61 */ new OpCode(OpCodeEnum.LogicalLessEqual, ParseArgs.ARGP_LLESSEQUAL_OP, InterpreterArgs.ARGI_LLESSEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), /* 62 */ new OpCode(OpCodeEnum.LogicalGreaterEqual, ParseArgs.ARGP_LGREATEREQUAL_OP, InterpreterArgs.ARGI_LGREATEREQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), -/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), -/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), -/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), -/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), -/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), -/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), +/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), +/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), +/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), +/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), +/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), /* ACPI 2.0 opcodes */ -/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), +/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), /* 6F */ new OpCode(OpCodeEnum.Package, /* Var */ ParseArgs.ARGP_VAR_PACKAGE_OP, InterpreterArgs.ARGI_VAR_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer), -/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), -/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), -/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), +/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), +/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), +/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), +/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), +/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), +/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), +/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), +/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), +/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), /* ACPI 3.0 opcodes */ -/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), +/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), /* ACPI 5.0 opcodes */ -/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), +/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), +/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), /* ACPI 6.0 opcodes */ -/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) +/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), +/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) }; public static OpCode GetOpcode(ushort opCodeValue) diff --git a/source/Cosmos.Core/ACPI/Interupter/EisaId.cs b/source/Cosmos.Core/ACPI/Interupter/EisaId.cs new file mode 100644 index 0000000000..969a41f5a5 --- /dev/null +++ b/source/Cosmos.Core/ACPI/Interupter/EisaId.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ACPIAML.Interupter +{ + public class EisaId + { + public static string ToText(long ID) + { + var vendor = ID & 0xFFFF; + var device = ID >> 16; + var device1 = device & 0xFF; + var device2 = device >> 8; + var vendor_rev = ((vendor & 0xFF) << 8) | vendor >> 8; + var vendor1 = ((vendor_rev >> 10)&0x1f)+64; + var vendor2 = ((vendor_rev >> 5)&0x1f)+64; + var vendor3= ((vendor_rev >> 0)&0x1f)+64; + + string vendorStr = new(new char[] { (char)vendor1 , (char)vendor2 , (char)vendor3 }); + return vendorStr + device1.ToString("X2") + device2.ToString("X2"); + } + } +} diff --git a/source/Cosmos.Core/ACPI/Interupter/StackObject.cs b/source/Cosmos.Core/ACPI/Interupter/StackObject.cs new file mode 100644 index 0000000000..076177bc95 --- /dev/null +++ b/source/Cosmos.Core/ACPI/Interupter/StackObject.cs @@ -0,0 +1,69 @@ +using ACPILib.Parser2; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace ACPIAML.Interupter +{ + public class StackObject + { + private StackObject() + { + + } + + public object? Value; + public StackObjectType Type; + + public static StackObject Create(string s) + { + return new() { Type = StackObjectType.String, Value = s }; + } + public static StackObject Create(ParseNode s) + { + return new() { Type = StackObjectType.ParseNode, Value = s }; + } + public static StackObject Create(byte s) + { + return new() { Type = StackObjectType.Byte, Value = s }; + } + public static StackObject Create(short s) + { + return new() { Type = StackObjectType.Word, Value = s }; + } + public static StackObject Create(int s) + { + return new() { Type = StackObjectType.DWord, Value = s }; + } + public static StackObject Create(long s) + { + return new() { Type = StackObjectType.QWord, Value = s }; + } + public static StackObject Create(byte[] s) + { + return new() { Type = StackObjectType.ByteArray, Value = s }; + } + } + public enum StackObjectType + { + Null, + ParseNode, + String, + Byte, + ByteArray, + /// + /// short + /// + Word, + /// + /// int + /// + DWord, + /// + /// long + /// + QWord, + } +} diff --git a/source/Cosmos.Core/ACPI/Parser/Parser.cs b/source/Cosmos.Core/ACPI/Parser/Parser.cs index d103b151e4..862ab711d4 100644 --- a/source/Cosmos.Core/ACPI/Parser/Parser.cs +++ b/source/Cosmos.Core/ACPI/Parser/Parser.cs @@ -463,7 +463,7 @@ private void ParseOp(AMLOp op, bool isMethodBody) break; default: - throw new NotImplementedException(); + throw new NotImplementedException("Unknown opcode"); } } } diff --git a/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs b/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs index e5cc7dc544..baec302b49 100644 --- a/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs +++ b/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs @@ -1,4 +1,5 @@ -using ACPILib.AML; +using ACPIAML.Interupter; +using ACPILib.AML; using System.Collections.Generic; namespace ACPILib.Parser2 @@ -17,8 +18,8 @@ public long End get { return Start + Length + Op.CodeByteSize; } } - public object ConstantValue; - public List Arguments = new List(); + public StackObject? ConstantValue; + public List Arguments = new List(); public List Nodes = new List(); public override string ToString() diff --git a/source/Cosmos.Core/ACPI/Parser2/Parser2.cs b/source/Cosmos.Core/ACPI/Parser2/Parser2.cs index 28b77795fb..38a2667dd5 100644 --- a/source/Cosmos.Core/ACPI/Parser2/Parser2.cs +++ b/source/Cosmos.Core/ACPI/Parser2/Parser2.cs @@ -1,4 +1,5 @@ -using ACPILib.AML; +using ACPIAML.Interupter; +using ACPILib.AML; using System; using System.Collections.Generic; using System.IO; @@ -6,402 +7,532 @@ namespace ACPILib.Parser2 { - public class Parser - { - private Stream _source; - - public bool stop = false; - - public Parser(Stream s) - { - _source = s; - } - - public ParseNode Parse() - { - return PreParse(); - } - - ParseNode root; - - private ParseNode PreParse() - { - root = new ParseNode() - { - Name = "\\" - }; - - while (_source.Position < _source.Length) - { - ParseNode op = ParseFullOpCodeNode(); - - root.Nodes.Add(op); - - if (stop == true) - { - return root; - } - } - - return root; - } - - private ParseNode ParseFullOpCodeNode() - { - //Read the opcode - ParseNode op = ReadOpCode(); - OpCode info = op.Op; - - _source.Seek(op.DataStart, SeekOrigin.Begin); - - //Parse opcode arguments - if (info.ParseArgs.Length > 0) - { - bool parseArguments = false; - - switch (info.Code) - { - case OpCodeEnum.Byte: - case OpCodeEnum.Word: - case OpCodeEnum.DWord: - case OpCodeEnum.QWord: - case OpCodeEnum.String: - op.ConstantValue = ParseSimpleArgument(info.ParseArgs[0]); - break; - - case OpCodeEnum.NamePath: - op.Arguments.Add(ReadNameString()); - break; - - default: - parseArguments = true; - break; - } - - if (parseArguments) //If the opcode is not a constant - { - for (int x = 0; x < info.ParseArgs.Length; x++) - { - switch (info.ParseArgs[x]) - { - case ParseArgFlags.None: - break; - - case ParseArgFlags.ByteData: - case ParseArgFlags.WordData: - case ParseArgFlags.DWordData: - case ParseArgFlags.CharList: - case ParseArgFlags.Name: - case ParseArgFlags.NameString: - { - object arg = ParseSimpleArgument(info.ParseArgs[x]); - if (arg != null) - { - op.Arguments.Add(arg); - } - } - break; - - case ParseArgFlags.DataObject: - case ParseArgFlags.TermArg: - { - ParseNode arg = ParseFullOpCodeNode(); - - op.Arguments.Add(arg); - } - break; - - case ParseArgFlags.PackageLength: - op.Arguments.Add(op.Length = ReadPackageLength()); - break; - - case ParseArgFlags.FieldList: - while (_source.Position < op.End) - { - op.Arguments.Add(ReadField()); - } - break; - - case ParseArgFlags.ByteList: - if (_source.Position < op.End) - { - op.ConstantValue = ReadBytes((int)(op.End - _source.Position)); - } - break; - - case ParseArgFlags.DataObjectList: - case ParseArgFlags.TermList: - case ParseArgFlags.ObjectList: - - if (op.Op.Code == OpCodeEnum.Method) - _source.Seek(op.End, SeekOrigin.Begin); - else - { - while (_source.Position < op.End) - { - ParseNode child = ParseFullOpCodeNode(); - - op.Nodes.Add(child); - } - } - - break; - - default: - throw new Exception("psargs.c / line 913 - Unknown arg: " + op.Op.ParseArgs[x].ToString()); - } - } - } - } - - //Parse the opcode - if ((info.Flags & OpCodeFlags.Named) == OpCodeFlags.Named) - { - for (int x = 0; x < info.ParseArgs.Length; x++) - { - if (info.ParseArgs[x] == ParseArgFlags.Name) - { - op.Name = (string)op.Arguments[x]; - break; - } - } - } - - if (op.Op.ToString() == "Return") - { - stop = true; - } - - return op; - } - - private ParseNode ReadField() - { - OpCodeEnum opCode; - switch ((OpCodeEnum)PeekByte()) - { - case OpCodeEnum.FieldOffset: - - opCode = OpCodeEnum.ReservedField; ; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldAccess: - - opCode = OpCodeEnum.AccessField; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldConnection: - - opCode = OpCodeEnum.Connection; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldExternalAccess: - - opCode = OpCodeEnum.ExternalAccessField; - _source.Seek(1, SeekOrigin.Current); - break; - - default: - opCode = OpCodeEnum.NamedField; - break; - } - - ParseNode node = new ParseNode() - { - Op = OpCodeTable.GetOpcode((ushort)opCode) - }; - - switch (opCode) - { - case OpCodeEnum.NamedField: - node.Name = Read4ByteName(); - node.ConstantValue = ReadPackageLength(); - break; - case OpCodeEnum.ReservedField: - node.ConstantValue = ReadPackageLength(); - break; - case OpCodeEnum.AccessField: - node.ConstantValue = (ReadByte() | ((uint)ReadByte() << 8)); - break; - case OpCodeEnum.ExternalAccessField: - node.ConstantValue = (ReadByte() | ((uint)ReadByte() << 8) | ((uint)ReadByte() << 16)); - break; - - default: - throw new Exception("psargs.c / line 703"); - } - - return node; - } - - private int ReadPackageLength() - { - int length = 0; - - byte b0 = (byte)_source.ReadByte(); - - int byteCount = (b0 >> 6); - - byte firstMask = (byte)(byteCount > 0 ? 0x0F : 0x3F); - - for (int b = 0; b < byteCount; b++) - { - length |= ((byte)_source.ReadByte() << ((byteCount << 3) - 4)); - } - - length |= (b0 & firstMask); - - return length; - } - - private object ParseSimpleArgument(ParseArgFlags arg) - { - switch (arg) - { - case ParseArgFlags.ByteData: - return (byte)_source.ReadByte(); - case ParseArgFlags.WordData: - return BitConverter.ToInt16(ReadBytes(2), 0); - case ParseArgFlags.DWordData: - return BitConverter.ToInt32(ReadBytes(4), 0); - case ParseArgFlags.QWordData: - return BitConverter.ToInt64(ReadBytes(8), 0); - case ParseArgFlags.CharList: //Nullterminated string - string str = string.Empty; - - byte read; - while ((read = (byte)_source.ReadByte()) != 0) - str += (char)read; - - return str; - case ParseArgFlags.Name: - case ParseArgFlags.NameString: - return ReadNameString(); - } - - return null; - } - - private string ReadNameString() - { - //Read past prefix chars - while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) - { - _source.Seek(1, SeekOrigin.Current); - } - - int segments = 0; - switch (ReadByte()) - { - case 0: //Null string - return string.Empty; - - case Definitions.DualNamePrefix: - segments = 2; - break; - case Definitions.MultiNamePrefix: - segments = ReadByte(); - break; - - default: - segments = 1; - - _source.Seek(-1, SeekOrigin.Current); - break; - } - - string name = string.Empty; - - for (int seg = 0; seg < segments; seg++) - { - string nameSeg = Read4ByteName(); - - name += nameSeg; - - if (seg < segments - 1) - name += "."; - } - - return name; - } - - private ParseNode ReadOpCode() - { - long pos = _source.Position; - - ushort op = PeekOpcode(); - OpCode info = OpCodeTable.GetOpcode(op); - - switch (info.Class) - { - case OpCodeClass.ASCII: - case OpCodeClass.Prefix: - info = OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath); - pos -= 1; //The op code byte is the data itself - break; - case OpCodeClass.ClassUnknown: - throw new Exception("Unknown AML opcode: 0x" + op.ToString("X2")); - default: - _source.Seek(info.CodeByteSize, SeekOrigin.Current); - break; - } - - return new ParseNode() - { - Op = info, - Start = pos, - DataStart = pos + info.CodeByteSize - }; - } - - private string Read4ByteName() - { - byte[] dt = new byte[4]; - _source.Read(dt, 0, 4); - - return Encoding.ASCII.GetString(dt); - } - - private byte[] ReadBytes(int num) - { - byte[] temp = new byte[num]; - _source.Read(temp, 0, num); - - return temp; - } - - private byte PeekByte() - { - byte read = (byte)_source.ReadByte(); - - _source.Seek(-1, SeekOrigin.Current); - - return read; - } - - private byte ReadByte() - { - return (byte)_source.ReadByte(); - } - - private ushort PeekOpcode() - { - ushort code = (ushort)_source.ReadByte(); - if (code == Definitions.ExtendedOpCodePrefix) - { - code = (ushort)((code << 8) | (ushort)_source.ReadByte()); - - _source.Seek(-2, SeekOrigin.Current); - } - else - { - _source.Seek(-1, SeekOrigin.Current); - } - - return code; - } - } + public class Parser + { + private Stream _source; + + public Parser(Stream s) + { + _source = s; + } + + public ParseNode Parse() + { + return PreParse(); + } + + private ParseNode PreParse() + { + ParseNode root = new ParseNode() + { + Name = "\\" + }; + + while (_source.Position < _source.Length) + { + ParseNode op = ParseFullOpCodeNode(); + root.Nodes.Add(op); + } + + return root; + } + + private ParseNode ParseFullOpCodeNode() + { + //Read the opcode + ParseNode op = ReadOpCode(); + OpCode info = op.Op; + + _source.Seek(op.DataStart, SeekOrigin.Begin); + long methodBodyAddr = 0; + + //Parse opcode arguments + if (info.ParseArgs.Length > 0) + { + bool parseArguments = false; + + switch (info.Code) + { + case OpCodeEnum.Byte: + case OpCodeEnum.Word: + case OpCodeEnum.DWord: + case OpCodeEnum.QWord: + case OpCodeEnum.String: + op.ConstantValue = ParseSimpleArgument(info.ParseArgs[0]); + break; + + case OpCodeEnum.NamePath: + op.Arguments.Add(StackObject.Create(ReadNameString())); + break; + + default: + parseArguments = true; + break; + } + + if (parseArguments) //If the opcode is not a constant + { + for (int x = 0; x < info.ParseArgs.Length; x++) + { + switch (info.ParseArgs[x]) + { + case ParseArgFlags.None: + break; + + case ParseArgFlags.ByteData: + case ParseArgFlags.WordData: + case ParseArgFlags.DWordData: + case ParseArgFlags.CharList: + case ParseArgFlags.Name: + case ParseArgFlags.NameString: + { + var arg = ParseSimpleArgument(info.ParseArgs[x]); + if (arg != null) + { + op.Arguments.Add(arg); + } + } + break; + case ParseArgFlags.DataObject: + case ParseArgFlags.TermArg: + { + //HACK: todo make this properly + methodBodyAddr = _source.Position; + var arg = ParseFullOpCodeNode(); //parsenode + + op.Arguments.Add(StackObject.Create(arg)); + } + break; + + case ParseArgFlags.PackageLength: + var xx = op.Length = ReadPackageLength(); + op.Arguments.Add(StackObject.Create(xx)); + break; + + case ParseArgFlags.FieldList: + while (_source.Position < op.End) + { + op.Arguments.Add(StackObject.Create(ReadField())); + } + break; + + case ParseArgFlags.ByteList: + if (_source.Position < op.End) + { + op.ConstantValue = StackObject.Create(ReadBytes((int)(op.End - _source.Position))); + } + break; + + case ParseArgFlags.DataObjectList: + case ParseArgFlags.TermList: + case ParseArgFlags.ObjectList: + var startPosition = _source.Position; + if (op.Arguments[1].Type == StackObjectType.String) + { + if ((string)op.Arguments[1].Value == "CPUS") + { + ; + } + } + while (_source.Position < op.End) + { + ParseNode child = ParseFullOpCodeNode(); + + op.Nodes.Add(child); + } + + break; + + case ParseArgFlags.Target: + case ParseArgFlags.SuperName: + ushort subOp2 = PeekUShort(); + if (subOp2 == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp2) || Definitions.IsLeadingChar((byte)subOp2)) + { + //AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); + // var xxx = ParseFullOpCodeNode(); + //xxx.Name =; + var str = ReadNameString(); + op.Arguments.Add(StackObject.Create(str)); + + + } + else + { + _source.Seek(op.DataStart, SeekOrigin.Begin); + var xxx = ParseFullOpCodeNode(); + op.Nodes.Add(xxx); + ; + } + break; + + default: + Console.WriteLine("psargs.c / line 913 - Unknown arg: " + info.ParseArgs[x]); + break; + } + } + } + } + + //Parse the opcode + if ((info.Flags & OpCodeFlags.Named) == OpCodeFlags.Named) + { + for (int x = 0; x < info.ParseArgs.Length; x++) + { + if (info.ParseArgs[x] == ParseArgFlags.Name) + { + op.Name = (string)op.Arguments[x].Value; + break; + } + } + } + + if (op.Op.Name == "Scope") + { + var orgPosition = op.DataStart; + while (_source.Position < orgPosition + op.Length) + { + ParseNode op2 = ParseFullOpCodeNode(); + op.Nodes.Add(op2); + } + } + //else if (op.Op.Name == "Method") + //{ + // //We add one because we expect a DualNamePrefix (0x2E) + // _source.Seek(methodBodyAddr, SeekOrigin.Begin); + + // ////Read until function name string ends + // //while(_source.ReadByte() != 0) + // //{ + + // //} + + // var codeEnd = op.DataStart + op.Length; + + // while (_source.Position < codeEnd) + // { + // ParseNode op2 = ParseFullOpCodeNode(); + // op.Nodes.Add(op2); + // } + //} + + return op; + } + + private ParseNode ReadField() + { + OpCodeEnum opCode; + switch ((OpCodeEnum)PeekByte()) + { + case OpCodeEnum.FieldOffset: + + opCode = OpCodeEnum.ReservedField; ; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldAccess: + + opCode = OpCodeEnum.AccessField; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldConnection: + + opCode = OpCodeEnum.Connection; + _source.Seek(1, SeekOrigin.Current); + break; + + case OpCodeEnum.FieldExternalAccess: + + opCode = OpCodeEnum.ExternalAccessField; + _source.Seek(1, SeekOrigin.Current); + break; + + default: + opCode = OpCodeEnum.NamedField; + break; + } + + ParseNode node = new ParseNode() + { + Op = OpCodeTable.GetOpcode((ushort)opCode) + }; + + switch (opCode) + { + case OpCodeEnum.NamedField: + node.Name = Read4ByteName(); + node.ConstantValue = StackObject.Create(ReadPackageLength()); + break; + case OpCodeEnum.ReservedField: + node.ConstantValue = StackObject.Create(ReadPackageLength()); + break; + case OpCodeEnum.AccessField: + node.ConstantValue = StackObject.Create((ReadByte() | ((uint)ReadByte() << 8))); + break; + case OpCodeEnum.ExternalAccessField: + node.ConstantValue = StackObject.Create((ReadByte() | ((uint)ReadByte() << 8) | ((uint)ReadByte() << 16))); + break; + + default: + throw new Exception("psargs.c / line 703"); + } + + return node; + } + + private int ReadPackageLength() + { + int length; + + byte b0 = (byte)ReadByte(); + + byte sz = (byte)((b0 >> 6) & 3); + + if (sz == 0) + { + //out = (size_t)(code[*pc] & 0x3F); + //(*pc)++; + //return 0; + + length = b0 & 0x3F; + } + else if (sz == 1) + { + // *out = (size_t)(code[*pc] & 0x0F) | (size_t)(code[*pc + 1] << 4); + + length = ((b0 & 0x0F) | ReadByte() << 4); + } + else if (sz == 2) + { + length = ((b0 & 0x0F) | ReadByte() << 4) | (ReadByte() << 12); + } + else if (sz == 3) + { + length = ((b0 & 0x0F) | ReadByte() << 4) | (ReadByte() << 12) | (ReadByte() << 20); + } + else + { + throw new NotImplementedException(); + } + + return length; + } + + private StackObject ParseSimpleArgument(ParseArgFlags arg) + { + switch (arg) + { + case ParseArgFlags.ByteData: + return StackObject.Create((byte)ReadByte()); + case ParseArgFlags.WordData: + return StackObject.Create(BitConverter.ToInt16(ReadBytes(2), 0)); + case ParseArgFlags.DWordData: + return StackObject.Create(BitConverter.ToInt32(ReadBytes(4), 0)); + case ParseArgFlags.QWordData: + return StackObject.Create(BitConverter.ToInt64(ReadBytes(8), 0)); + case ParseArgFlags.CharList: //Nullterminated string + string str = string.Empty; + + byte read; + while ((read = (byte)ReadByte()) != 0) + str += (char)read; + + return StackObject.Create(str); + case ParseArgFlags.Name: + case ParseArgFlags.NameString: + return StackObject.Create(ReadNameString()); + } + + return null; + } + private string ReadNameString() + { + var x = _source.Position; + var b = (char)ReadByte(); + bool is_absolute = false; + if (b == '\\') + { + is_absolute = true; + } + else + { + bool xx = false; + while ((char)PeekByte() == '^') + { + xx = true; + _source.Position++; + } + if (xx) + { + b = (char)PeekByte(); + } + } + + int segmentNumber = 0; + bool UseBChar = false; + //var b2 = (char)ReadByte(); + string o = ""; + if (b == '\0') + { + segmentNumber = 0; + } + else if (b == 0x2E) + { + //dual prefix + segmentNumber = 2; + } + else if (b == 0x2F) + { + //dual prefix + segmentNumber = ReadByte(); + } + else + { + segmentNumber = 1; //default? + o += b.ToString(); + UseBChar = true; + } + var len = segmentNumber * 4; + if (UseBChar) + len -= 1; + for (int i = 0; i < len; i++) + { + o += ((char)ReadByte()).ToString(); + } + + foreach (var item in o) + { + if (!char.IsAscii(item)) + throw new Exception("Check failed: Char is not ASCII"); + } + return o; + ////Read past prefix chars + //while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) + //{ + // _source.Seek(1, SeekOrigin.Current); + //} + + //int segments = 0; + //var b = ReadByte(); + //switch (b) + //{ + // case 0: //Null string + // return string.Empty; + + // case Definitions.DualNamePrefix: + // segments = 2; + // break; + // case Definitions.MultiNamePrefix: + // segments = ReadByte(); + // break; + + // default: + // segments = 1; + + // _source.Seek(-1, SeekOrigin.Current); + // break; + //} + + //string name = string.Empty; + + //for (int seg = 0; seg < segments; seg++) + //{ + // string nameSeg = Read4ByteName(); + + // name += nameSeg; + + // if (seg < segments - 1) + // name += "."; + //} + + //return name; + } + + private ParseNode ReadOpCode() + { + long pos = _source.Position; + + ushort op = ReadUShort(); + OpCode? info = OpCodeTable.GetOpcode(op); + switch (info.Class) + { + case OpCodeClass.ASCII: + case OpCodeClass.Prefix: + info = OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath); + pos -= 1; //The op code byte is the data itself + break; + case OpCodeClass.ClassUnknown: + Console.WriteLine("Unknown AML opcode: 0x" + op.ToString("X") + " at " + _source.Position); + break; + default: + _source.Seek(info.CodeByteSize, SeekOrigin.Current); + break; + } + + return new ParseNode() + { + Op = info, + Start = pos, + DataStart = pos + info.CodeByteSize + }; + } + + private string Read4ByteName() + { + byte[] dt = new byte[4]; + _source.Read(dt, 0, 4); + + return Encoding.ASCII.GetString(dt); + } + + private byte[] ReadBytes(int num) + { + byte[] temp = new byte[num]; + _source.Read(temp, 0, num); + + return temp; + } + + private byte PeekByte() + { + byte read = (byte)_source.ReadByte(); + + _source.Seek(-1, SeekOrigin.Current); + + return read; + } + + private ushort PeekUShort() + { + ushort code = (ushort)_source.ReadByte(); + if (code == Definitions.ExtendedOpCodePrefix) + { + code = (ushort)((code << 8) | (ushort)_source.ReadByte()); + + _source.Seek(-2, SeekOrigin.Current); + } + else + { + _source.Seek(-1, SeekOrigin.Current); + } + + return code; + } + + private byte ReadByte() + { + return (byte)_source.ReadByte(); + } + + private ushort ReadUShort() + { + ushort code = (ushort)_source.ReadByte(); + if (code == Definitions.ExtendedOpCodePrefix) + { + code = (ushort)((code << 8) | (ushort)_source.ReadByte()); + } + + return code; + } + } } From 5e613bcddd6292f2267a86a60788d2d74bed645f Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Sun, 19 Jun 2022 20:12:20 +0200 Subject: [PATCH 30/35] Remove AML parser for now --- source/Cosmos.Core/ACPI/ACPI.cs | 32 +- source/Cosmos.Core/ACPI/AML/Definitions.cs | 22 - .../Cosmos.Core/ACPI/AML/InterpreterArgs.cs | 163 ----- source/Cosmos.Core/ACPI/AML/ObjectType.cs | 49 -- source/Cosmos.Core/ACPI/AML/OpCode.cs | 643 ------------------ source/Cosmos.Core/ACPI/AML/OpCodeClass.cs | 20 - source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs | 154 ----- source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs | 40 -- source/Cosmos.Core/ACPI/AML/OpCodeTable.cs | 244 ------- source/Cosmos.Core/ACPI/AML/OpCodeType.cs | 39 -- source/Cosmos.Core/ACPI/AML/ParseArgs.cs | 162 ----- source/Cosmos.Core/ACPI/Interupter/EisaId.cs | 26 - .../ACPI/Interupter/StackObject.cs | 69 -- source/Cosmos.Core/ACPI/Parser/AMLOp.cs | 71 -- source/Cosmos.Core/ACPI/Parser/Parser.cs | 472 ------------- source/Cosmos.Core/ACPI/Parser2/ParseNode.cs | 30 - source/Cosmos.Core/ACPI/Parser2/Parser2.cs | 538 --------------- 17 files changed, 12 insertions(+), 2762 deletions(-) delete mode 100644 source/Cosmos.Core/ACPI/AML/Definitions.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/ObjectType.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCode.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeClass.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeTable.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/OpCodeType.cs delete mode 100644 source/Cosmos.Core/ACPI/AML/ParseArgs.cs delete mode 100644 source/Cosmos.Core/ACPI/Interupter/EisaId.cs delete mode 100644 source/Cosmos.Core/ACPI/Interupter/StackObject.cs delete mode 100644 source/Cosmos.Core/ACPI/Parser/AMLOp.cs delete mode 100644 source/Cosmos.Core/ACPI/Parser/Parser.cs delete mode 100644 source/Cosmos.Core/ACPI/Parser2/ParseNode.cs delete mode 100644 source/Cosmos.Core/ACPI/Parser2/Parser2.cs diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index ffe7acee63..bd5359d6a7 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -658,20 +658,10 @@ private static void ParseS5() private static void ParsePRT() { - byte* S5Addr = (byte*)FADT->Dsdt; - - while (0 < DSDTLenght--) - { - if (Compare("_PRT", S5Addr) == 0) - { - break; - } - S5Addr++; - } - + /* if (DSDTLenght > 0) { - var dsdtBlock = new MemoryBlock08((uint)S5Addr, SdtLength); + var dsdtBlock = new MemoryBlock08(FADT->Dsdt + (uint)sizeof(AcpiHeader), SdtLength - (uint)sizeof(AcpiHeader)); Stream stream = new MemoryStream(dsdtBlock.ToArray()); @@ -679,14 +669,14 @@ private static void ParsePRT() var root = new Parser(stream); - Global.mDebugger.Send("Parsing ACPI DST _PRT Method..."); + Global.mDebugger.Send("Parse first node..."); var node = root.Parse(); - - Global.mDebugger.Send("Parsed! Trying to list IRQ Routing Table..."); - - PopulateNode(node); - } + foreach (var item in node.Nodes) + { + Global.mDebugger.Send("Node: " + item.Name); + } + }*/ } private static void ParseDT(AcpiHeader* hdr) @@ -779,6 +769,7 @@ private static void ParseDT(AcpiHeader* hdr) } } + /* private static void PopulateNode(ParseNode op) { //Recursive function does a null reference exception trick the matrice with a Stack and iterative function @@ -805,6 +796,7 @@ private static void PopulateNode(ParseNode op) } } + private static void SearchPackage(ParseNode op) { for (int x = 0; x < op.Op.ParseArgs.Length; x++) @@ -833,10 +825,10 @@ private static void SearchPackage(ParseNode op) IrqRoutingTable.Add(irqRouting); } - */ + } } - } + }*/ /// /// Enable ACPI. diff --git a/source/Cosmos.Core/ACPI/AML/Definitions.cs b/source/Cosmos.Core/ACPI/AML/Definitions.cs deleted file mode 100644 index b6008abbf9..0000000000 --- a/source/Cosmos.Core/ACPI/AML/Definitions.cs +++ /dev/null @@ -1,22 +0,0 @@ -namespace ACPILibs.AML -{ - public class Definitions - { - public const int NameSize = 4; - - public const byte ExtendedOpCodePrefix = 0x5B; - - public const byte DualNamePrefix = (byte)OpCodeEnum.DualNamePrefix; - public const byte MultiNamePrefix = (byte)OpCodeEnum.MultiNamePrefix; - - public static bool IsNameRootPrefixOrParentPrefix(byte b) - { - return (b == 0x5C || b == 0x5E); - } - - public static bool IsLeadingChar(byte b) - { - return (b == '_' || (b >= 'A' && b <= 'Z')); - } - } -} diff --git a/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs b/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs deleted file mode 100644 index dac9a8185a..0000000000 --- a/source/Cosmos.Core/ACPI/AML/InterpreterArgs.cs +++ /dev/null @@ -1,163 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - [Flags] - public enum InterpreterArgFlags : uint - { - None = 0x0, - AnyType = 0x01, - Package = 0x02, - Event = 0x03, - Mutex = 0x04, - DDBHandle = 0x05, - Integer = 0x06, - String = 0x07, - Buffer = 0x08, - BufferOrString = 0x09, - ComputeData = 0x0A, - ObjectReference = 0x0C, - DeviceReference = 0x0D, - TargetReference = 0x0F, - SimpleTarget = 0x10, - DataObject = 0x13, - ComplexObject = 0x14, - ReferenceOrString = 0x15, - RegionOrBuffer = 0x16, - DataReferenceObject = 0x17, - InvalidOpCode = 0xFFFFFFFF, - Reference = 0xB, - StoreTarget = 0xE, - } - - class InterpreterArgs - { - public static InterpreterArgFlags[] ARGI_ACCESSFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_ACQUIRE_OP = { InterpreterArgFlags.Mutex, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_ADD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_ALIAS_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_ARG0 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG1 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG2 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG3 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG4 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG5 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ARG6 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_BANK_FIELD_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_BIT_AND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BIT_NAND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BIT_NOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BIT_NOT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BIT_OR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BIT_XOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_BREAK_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_BREAK_POINT_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_BUFFER_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_BYTE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_BYTELIST_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_COMMENT_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_CONCAT_OP = { InterpreterArgFlags.AnyType, InterpreterArgFlags.AnyType, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_CONCAT_RES_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Buffer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_COND_REF_OF_OP = { InterpreterArgFlags.ObjectReference, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_CONNECTFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_CONTINUE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_COPY_OP = { InterpreterArgFlags.AnyType, InterpreterArgFlags.SimpleTarget }; - public static InterpreterArgFlags[] ARGI_CREATE_BIT_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_CREATE_BYTE_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_CREATE_DWORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_CREATE_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_CREATE_QWORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_CREATE_WORD_FIELD_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.Reference }; - public static InterpreterArgFlags[] ARGI_DATA_REGION_OP = { InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String }; - public static InterpreterArgFlags[] ARGI_DEBUG_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_DECREMENT_OP = { InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_DEREF_OF_OP = { InterpreterArgFlags.ReferenceOrString }; - public static InterpreterArgFlags[] ARGI_DEVICE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_DIVIDE_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_DWORD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_ELSE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_EVENT_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_EXTERNAL_OP = { InterpreterArgFlags.String, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_FATAL_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_FIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_FIND_SET_LEFT_BIT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_FIND_SET_RIGHT_BIT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_FROM_BCD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_IF_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_INCREMENT_OP = { InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_INDEX_FIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_INDEX_OP = { InterpreterArgFlags.ComplexObject, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_LAND_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_LEQUAL_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; - public static InterpreterArgFlags[] ARGI_LGREATER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; - public static InterpreterArgFlags[] ARGI_LGREATEREQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_LLESS_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.ComputeData }; - public static InterpreterArgFlags[] ARGI_LLESSEQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_LNOT_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_LNOTEQUAL_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_LOAD_OP = { InterpreterArgFlags.RegionOrBuffer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_LOAD_TABLE_OP = { InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.String, InterpreterArgFlags.AnyType }; - public static InterpreterArgFlags[] ARGI_LOCAL0 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL1 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL2 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL3 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL4 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL5 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL6 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOCAL7 = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_LOR_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_MATCH_OP = { InterpreterArgFlags.Package, InterpreterArgFlags.Integer, InterpreterArgFlags.ComputeData, InterpreterArgFlags.Integer, InterpreterArgFlags.ComputeData, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_METHOD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_METHODCALL_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_MID_OP = { InterpreterArgFlags.BufferOrString, InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_MOD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_MULTIPLY_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_MUTEX_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_NAME_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_NAMEDFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_NAMEPATH_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_NOOP_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_NOTIFY_OP = { InterpreterArgFlags.DeviceReference, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_OBJECT_TYPE_OP = { InterpreterArgFlags.AnyType }; - public static InterpreterArgFlags[] ARGI_ONE_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_ONES_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_PACKAGE_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_POWER_RES_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_PROCESSOR_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_QWORD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_REF_OF_OP = { InterpreterArgFlags.ObjectReference }; - public static InterpreterArgFlags[] ARGI_REGION_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_RELEASE_OP = { InterpreterArgFlags.Mutex }; - public static InterpreterArgFlags[] ARGI_RESERVEDFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_RESET_OP = { InterpreterArgFlags.Event }; - public static InterpreterArgFlags[] ARGI_RETURN_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_REVISION_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_SCOPE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_SERIALFIELD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_SHIFT_LEFT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_SHIFT_RIGHT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_SIGNAL_OP = { InterpreterArgFlags.Event }; - public static InterpreterArgFlags[] ARGI_SIZE_OF_OP = { InterpreterArgFlags.DataObject }; - public static InterpreterArgFlags[] ARGI_SLEEP_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_STALL_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_STATICSTRING_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_STORE_OP = { InterpreterArgFlags.DataReferenceObject, InterpreterArgFlags.StoreTarget }; - public static InterpreterArgFlags[] ARGI_STRING_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_SUBTRACT_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_THERMAL_ZONE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_TIMER_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARGI_TO_BCD_OP = { InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_TO_BUFFER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_TO_DEC_STR_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_TO_HEX_STR_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_TO_INTEGER_OP = { InterpreterArgFlags.ComputeData, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_TO_STRING_OP = { InterpreterArgFlags.Buffer, InterpreterArgFlags.Integer, InterpreterArgFlags.TargetReference }; - public static InterpreterArgFlags[] ARGI_UNLOAD_OP = { InterpreterArgFlags.DDBHandle }; - public static InterpreterArgFlags[] ARGI_VAR_PACKAGE_OP = { InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_WAIT_OP = { InterpreterArgFlags.Event, InterpreterArgFlags.Integer }; - public static InterpreterArgFlags[] ARGI_WHILE_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_WORD_OP = { InterpreterArgFlags.InvalidOpCode }; - public static InterpreterArgFlags[] ARGI_ZERO_OP = { InterpreterArgFlags.None }; - public static InterpreterArgFlags[] ARG_NONE = { InterpreterArgFlags.None }; - } -} diff --git a/source/Cosmos.Core/ACPI/AML/ObjectType.cs b/source/Cosmos.Core/ACPI/AML/ObjectType.cs deleted file mode 100644 index 1dbbb98504..0000000000 --- a/source/Cosmos.Core/ACPI/AML/ObjectType.cs +++ /dev/null @@ -1,49 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - [Flags] - public enum ObjectTypeEnum : uint - { - Any = 0x00, - Integer = 0x01, - String = 0x02, - Buffer = 0x03, - Package = 0x04, - FieldUnit = 0x05, - Device = 0x06, - Event = 0x07, - Method = 0x08, - Mutex = 0x09, - Region = 0x0A, - Power = 0x0B, - Processor = 0x0C, - Thermal = 0x0D, - BufferField = 0x0E, - DDBHandle = 0x0F, - DebugObject = 0x10, - ExternalMax = 0x10, - - LocalRegionFIeld = 0x11, - LocalBankField = 0x12, - LocalIndexField = 0x13, - LocalReference = 0x14, - LocalAlias = 0x15, - LocalMethodAlias = 0x16, - LocalNotify = 0x17, - LocalAddressHandler = 0x18, - LocalResource = 0x19, - LocalResourceField = 0x1A, - LocalScope = 0x1B, - - NsNodeMax = 0x1B, - - LocalExtra = 0x1C, - LocalData = 0x1D, - - LocalMax = 0x1D, - - Invalid = 0x1E, - NotFound = 0xFF, - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCode.cs b/source/Cosmos.Core/ACPI/AML/OpCode.cs deleted file mode 100644 index 04efa408f9..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCode.cs +++ /dev/null @@ -1,643 +0,0 @@ -//Based on the ACPICA source code (https://github.com/acpica/acpica) -using System; - -namespace ACPILib.AML -{ - public class OpCode - { - public string Name - { - get; - private set; - } - - public ushort CodeValue - { - get { return (ushort)Code; } - } - - public int CodeByteSize - { - get - { - if (CodeValue > 0x00FF) - return 2; - - return 1; - } - } - - public OpCodeEnum Code; - public ParseArgFlags[] ParseArgs; - public InterpreterArgFlags[] RuntimeArgs; - public ObjectTypeEnum ObjectType; - public OpCodeClass Class; - public OpCodeType Type; - public OpCodeFlags Flags; - - public OpCode(string name, ParseArgFlags[] parseArgs, InterpreterArgFlags[] rtArgs, ObjectTypeEnum objectType, OpCodeClass cls, OpCodeType type, OpCodeFlags flags) - { - Code = OpCodeEnum.Unknown; - Name = name; - ParseArgs = parseArgs; - RuntimeArgs = rtArgs; - ObjectType = objectType; - Class = cls; - Type = type; - } - - public OpCode(OpCodeEnum code, ParseArgFlags[] parseArgs, InterpreterArgFlags[] rtArgs, ObjectTypeEnum objectType, OpCodeClass cls, OpCodeType type, OpCodeFlags flags) - { - Code = code; - ParseArgs = parseArgs; - RuntimeArgs = rtArgs; - ObjectType = objectType; - Class = cls; - Type = type; - Flags = flags; - - Name = GetName(code); - } - - private string GetName(OpCodeEnum code) - { - string name = "ERROR OPCODE NOT DETECTED"; - - if (code == OpCodeEnum.Unknown) - { - name = "Unknown"; - } - else if (code == OpCodeEnum.Zero) - { - name = "Zero"; - } - else if (code == OpCodeEnum.One) - { - name = "One"; - } - else if (code == OpCodeEnum.Alias) - { - name = "Alias"; - } - else if (code == OpCodeEnum.Name) - { - name = "Name"; - } - else if (code == OpCodeEnum.Byte) - { - name = "Byte"; - } - else if (code == OpCodeEnum.Word) - { - name = "Word"; - } - else if (code == OpCodeEnum.DWord) - { - name = "DWord"; - } - else if (code == OpCodeEnum.String) - { - name = "String"; - } - else if (code == OpCodeEnum.QWord) - { - name = "QWord"; - } - else if (code == OpCodeEnum.Scope) - { - name = "Scope"; - } - else if (code == OpCodeEnum.Buffer) - { - name = "Buffer"; - } - else if (code == OpCodeEnum.Package) - { - name = "Package"; - } - else if (code == OpCodeEnum.VariablePackage) - { - name = "VariablePackage"; - } - else if (code == OpCodeEnum.Method) - { - name = "Method"; - } - else if (code == OpCodeEnum.External) - { - name = "External"; - } - else if (code == OpCodeEnum.DualNamePrefix) - { - name = "DualNamePrefix"; - } - else if (code == OpCodeEnum.MultiNamePrefix) - { - name = "MultiNamePrefix"; - } - else if (code == OpCodeEnum.ExtendedPrefix) - { - name = "ExtendedPrefix"; - } - else if (code == OpCodeEnum.RootPrefix) - { - name = "RootPrefix"; - } - else if (code == OpCodeEnum.ParentPrefix) - { - name = "ParentPrefix"; - } - else if (code == OpCodeEnum.FirstLocal) - { - name = "FirstLocal"; - } - else if (code == OpCodeEnum.Local0) - { - name = "Local0"; - } - else if (code == OpCodeEnum.Local1) - { - name = "Local1"; - } - else if (code == OpCodeEnum.Local2) - { - name = "Local2"; - } - else if (code == OpCodeEnum.Local3) - { - name = "Local3"; - } - else if (code == OpCodeEnum.Local4) - { - name = "Local4"; - } - else if (code == OpCodeEnum.Local5) - { - name = "Local5"; - } - else if (code == OpCodeEnum.Local6) - { - name = "Local6"; - } - else if (code == OpCodeEnum.Local7) - { - name = "Local7"; - } - else if (code == OpCodeEnum.FirstArg) - { - name = "FirstArg"; - } - else if (code == OpCodeEnum.Arg0) - { - name = "Arg0"; - } - else if (code == OpCodeEnum.Arg1) - { - name = "Arg1"; - } - else if (code == OpCodeEnum.Arg2) - { - name = "Arg2"; - } - else if (code == OpCodeEnum.Arg3) - { - name = "Arg3"; - } - else if (code == OpCodeEnum.Arg4) - { - name = "Arg4"; - } - else if (code == OpCodeEnum.Arg5) - { - name = "Arg5"; - } - else if (code == OpCodeEnum.Arg6) - { - name = "Arg6"; - } - else if (code == OpCodeEnum.Store) - { - name = "Store"; - } - else if (code == OpCodeEnum.ReferenceOf) - { - name = "ReferenceOf"; - } - else if (code == OpCodeEnum.Add) - { - name = "Add"; - } - else if (code == OpCodeEnum.Concatenate) - { - name = "Concatenate"; - } - else if (code == OpCodeEnum.Subtract) - { - name = "Subtract"; - } - else if (code == OpCodeEnum.Increment) - { - name = "Increment"; - } - else if (code == OpCodeEnum.Decrement) - { - name = "Decrement"; - } - else if (code == OpCodeEnum.Multiply) - { - name = "Multiply"; - } - else if (code == OpCodeEnum.Divide) - { - name = "Divide"; - } - else if (code == OpCodeEnum.ShiftLeft) - { - name = "ShiftLeft"; - } - else if (code == OpCodeEnum.ShiftRight) - { - name = "ShiftRight"; - } - else if (code == OpCodeEnum.BitAnd) - { - name = "BitAnd"; - } - else if (code == OpCodeEnum.BitNand) - { - name = "BitNand"; - } - else if (code == OpCodeEnum.BitOr) - { - name = "BitOr"; - } - else if (code == OpCodeEnum.BitNor) - { - name = "BitNor"; - } - else if (code == OpCodeEnum.BitXor) - { - name = "BitXor"; - } - else if (code == OpCodeEnum.BitNot) - { - name = "BitNot"; - } - else if (code == OpCodeEnum.FindSetLeftBit) - { - name = "FindSetLeftBit"; - } - else if (code == OpCodeEnum.FindSetRightBit) - { - name = "FindSetRightBit"; - } - else if (code == OpCodeEnum.DereferenceOf) - { - name = "DereferenceOf"; - } - else if (code == OpCodeEnum.ConcatenateTemplate) - { - name = "ConcatenateTemplate"; - } - else if (code == OpCodeEnum.Mod) - { - name = "Mod"; - } - else if (code == OpCodeEnum.Notify) - { - name = "Notify"; - } - else if (code == OpCodeEnum.SizeOf) - { - name = "SizeOf"; - } - else if (code == OpCodeEnum.Index) - { - name = "Index"; - } - else if (code == OpCodeEnum.Match) - { - name = "Match"; - } - else if (code == OpCodeEnum.CreateDWordField) - { - name = "CreateDWordField"; - } - else if (code == OpCodeEnum.CreateWordField) - { - name = "CreateWordField"; - } - else if (code == OpCodeEnum.CreateByteField) - { - name = "CreateByteField"; - } - else if (code == OpCodeEnum.CreateBitField) - { - name = "CreateBitField"; - } - else if (code == OpCodeEnum.ObjectType) - { - name = "ObjectType"; - } - else if (code == OpCodeEnum.CreateQWordField) - { - name = "CreateQWordField"; - } - else if (code == OpCodeEnum.LogicalAnd) - { - name = "LogicalAnd"; - } - else if (code == OpCodeEnum.LogicalOr) - { - name = "LogicalOr"; - } - else if (code == OpCodeEnum.LogicalNot) - { - name = "LogicalNot"; - } - else if (code == OpCodeEnum.LogicalEqual) - { - name = "LogicalEqual"; - } - else if (code == OpCodeEnum.LogicalGreater) - { - name = "LogicalGreater"; - } - else if (code == OpCodeEnum.LogicalLess) - { - name = "LogicalLess"; - } - else if (code == OpCodeEnum.ToBuffer) - { - name = "ToBuffer"; - } - else if (code == OpCodeEnum.ToDecimalString) - { - name = "ToDecimalString"; - } - else if (code == OpCodeEnum.ToHexString) - { - name = "ToHexString"; - } - else if (code == OpCodeEnum.ToInteger) - { - name = "ToInteger"; - } - else if (code == OpCodeEnum.ToString) - { - name = "ToString"; - } - else if (code == OpCodeEnum.CopyObject) - { - name = "CopyObject"; - } - else if (code == OpCodeEnum.Mid) - { - name = "Mid"; - } - else if (code == OpCodeEnum.Continue) - { - name = "Continue"; - } - else if (code == OpCodeEnum.If) - { - name = "If"; - } - else if (code == OpCodeEnum.Else) - { - name = "Else"; - } - else if (code == OpCodeEnum.While) - { - name = "While"; - } - else if (code == OpCodeEnum.NoOp) - { - name = "NoOp"; - } - else if (code == OpCodeEnum.Return) - { - name = "Return"; - } - else if (code == OpCodeEnum.Break) - { - name = "Break"; - } - else if (code == OpCodeEnum.Comment) - { - name = "Comment"; - } - else if (code == OpCodeEnum.Breakpoint) - { - name = "Breakpoint"; - } - else if (code == OpCodeEnum.Ones) - { - name = "Ones"; - } - else if (code == OpCodeEnum.LogicalGreaterEqual) - { - name = "LogicalGreaterEqual"; - } - else if (code == OpCodeEnum.LogicalLessEqual) - { - name = "LogicalLessEqual"; - } - else if (code == OpCodeEnum.LogicalNotEqual) - { - name = "LogicalNotEqual"; - } - else if (code == OpCodeEnum.ExtendedOpcode) - { - name = "ExtendedOpcode"; - } - else if (code == OpCodeEnum.Mutex) - { - name = "Mutex"; - } - else if (code == OpCodeEnum.Event) - { - name = "Event"; - } - else if (code == OpCodeEnum.ShiftRightBit) - { - name = "ShiftRightBit"; - } - else if (code == OpCodeEnum.ShiftLeftBit) - { - name = "ShiftLeftBit"; - } - else if (code == OpCodeEnum.ConditionalReferenceOf) - { - name = "ConditionalReferenceOf"; - } - else if (code == OpCodeEnum.CreateField) - { - name = "CreateField"; - } - else if (code == OpCodeEnum.LoadTable) - { - name = "LoadTable"; - } - else if (code == OpCodeEnum.Load) - { - name = "Load"; - } - else if (code == OpCodeEnum.Stall) - { - name = "Stall"; - } - else if (code == OpCodeEnum.Sleep) - { - name = "Sleep"; - } - else if (code == OpCodeEnum.Acquire) - { - name = "Acquire"; - } - else if (code == OpCodeEnum.Signal) - { - name = "Signal"; - } - else if (code == OpCodeEnum.Wait) - { - name = "Wait"; - } - else if (code == OpCodeEnum.Reset) - { - name = "Reset"; - } - else if (code == OpCodeEnum.Release) - { - name = "Release"; - } - else if (code == OpCodeEnum.FromBCD) - { - name = "FromBCD"; - } - else if (code == OpCodeEnum.ToBCD) - { - name = "ToBCD"; - } - else if (code == OpCodeEnum.Unload) - { - name = "Unload"; - } - else if (code == OpCodeEnum.Revision) - { - name = "Revision"; - } - else if (code == OpCodeEnum.Debug) - { - name = "Debug"; - } - else if (code == OpCodeEnum.Fatal) - { - name = "Fatal"; - } - else if (code == OpCodeEnum.Timer) - { - name = "Timer"; - } - else if (code == OpCodeEnum.Region) - { - name = "Region"; - } - else if (code == OpCodeEnum.Field) - { - name = "Field"; - } - else if (code == OpCodeEnum.Device) - { - name = "Device"; - } - else if (code == OpCodeEnum.Processor) - { - name = "Processor"; - } - else if (code == OpCodeEnum.PowerResource) - { - name = "PowerResource"; - } - else if (code == OpCodeEnum.ThermalZone) - { - name = "ThermalZone"; - } - else if (code == OpCodeEnum.IndexField) - { - name = "IndexField"; - } - else if (code == OpCodeEnum.BankField) - { - name = "BankField"; - } - else if (code == OpCodeEnum.DataRegion) - { - name = "DataRegion"; - } - else if (code == OpCodeEnum.FieldOffset) - { - name = "FieldOffset"; - } - else if (code == OpCodeEnum.FieldAccess) - { - name = "FieldAccess"; - } - else if (code == OpCodeEnum.FieldConnection) - { - name = "FieldConnection"; - } - else if (code == OpCodeEnum.FieldExternalAccess) - { - name = "FieldExternalAccess"; - } - else if (code == OpCodeEnum.NamePath) - { - name = "NamePath"; - } - else if (code == OpCodeEnum.NamedField) - { - name = "NamedField"; - } - else if (code == OpCodeEnum.ReservedField) - { - name = "ReservedField"; - } - else if (code == OpCodeEnum.AccessField) - { - name = "AccessField"; - } - else if (code == OpCodeEnum.ByteList) - { - name = "ByteList"; - } - else if (code == OpCodeEnum.MethodCall) - { - name = "MethodCall"; - } - else if (code == OpCodeEnum.ReturnValue) - { - name = "ReturnValue"; - } - else if (code == OpCodeEnum.EvalSubtree) - { - name = "EvalSubtree"; - } - else if (code == OpCodeEnum.Connection) - { - name = "Connection"; - } - else if (code == OpCodeEnum.ExternalAccessField) - { - name = "ExternalAccessField"; - } - - return name; - } - - public override string ToString() - { - return Name; - } - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs b/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs deleted file mode 100644 index 9090d57ee8..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCodeClass.cs +++ /dev/null @@ -1,20 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - [Flags] - public enum OpCodeClass : byte - { - Execute = 0x00, - Create = 0x01, - Argument = 0x02, - NamedObject = 0x03, - Control = 0x04, - ASCII = 0x05, - Prefix = 0x06, - Internal = 0x07, - ReturnValue = 0x08, - MethodCall = 0x09, - ClassUnknown = 0x0A, - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs b/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs deleted file mode 100644 index 9d5e22c903..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCodeEnum.cs +++ /dev/null @@ -1,154 +0,0 @@ -namespace ACPILib.AML -{ - public enum OpCodeEnum : ushort - { - Unknown = 0xFFFF, - - Zero = 0x00, - One = 0x01, - Alias = 0x06, - Name = 0x08, - Byte = 0x0a, - Word = 0x0b, - DWord = 0x0c, - String = 0x0d, - QWord = 0x0e, - Scope = 0x10, - Buffer = 0x11, - Package = 0x12, - VariablePackage = 0x13, - Method = 0x14, - External = 0x15, - DualNamePrefix = 0x2e, - MultiNamePrefix = 0x2f, - ExtendedPrefix = 0x5b, - RootPrefix = 0x5c, - ParentPrefix = 0x5e, - FirstLocal = 0x60, - Local0 = 0x60, - Local1 = 0x61, - Local2 = 0x62, - Local3 = 0x63, - Local4 = 0x64, - Local5 = 0x65, - Local6 = 0x66, - Local7 = 0x67, - FirstArg = 0x68, - Arg0 = 0x68, - Arg1 = 0x69, - Arg2 = 0x6a, - Arg3 = 0x6b, - Arg4 = 0x6c, - Arg5 = 0x6d, - Arg6 = 0x6e, - Store = 0x70, - ReferenceOf = 0x71, - Add = 0x72, - Concatenate = 0x73, - Subtract = 0x74, - Increment = 0x75, - Decrement = 0x76, - Multiply = 0x77, - Divide = 0x78, - ShiftLeft = 0x79, - ShiftRight = 0x7a, - BitAnd = 0x7b, - BitNand = 0x7c, - BitOr = 0x7d, - BitNor = 0x7e, - BitXor = 0x7f, - BitNot = 0x80, - FindSetLeftBit = 0x81, - FindSetRightBit = 0x82, - DereferenceOf = 0x83, - ConcatenateTemplate = 0x84, - Mod = 0x85, - Notify = 0x86, - SizeOf = 0x87, - Index = 0x88, - Match = 0x89, - CreateDWordField = 0x8a, - CreateWordField = 0x8b, - CreateByteField = 0x8c, - CreateBitField = 0x8d, - ObjectType = 0x8e, - CreateQWordField = 0x8f, - LogicalAnd = 0x90, - LogicalOr = 0x91, - LogicalNot = 0x92, - LogicalEqual = 0x93, - LogicalGreater = 0x94, - LogicalLess = 0x95, - ToBuffer = 0x96, - ToDecimalString = 0x97, - ToHexString = 0x98, - ToInteger = 0x99, - ToString = 0x9c, - CopyObject = 0x9d, - Mid = 0x9e, - Continue = 0x9f, - If = 0xa0, - Else = 0xa1, - While = 0xa2, - NoOp = 0xa3, - Return = 0xa4, - Break = 0xa5, - Comment = 0xa9, - Breakpoint = 0xcc, - Ones = 0xff, - - LogicalGreaterEqual = 0x9295, - LogicalLessEqual = 0x9294, - LogicalNotEqual = 0x9293, - - ExtendedOpcode = 0x5b00, //Prefix - - Mutex = 0x5b01, - Event = 0x5b02, - ShiftRightBit = 0x5b10, - ShiftLeftBit = 0x5b11, - ConditionalReferenceOf = 0x5b12, - CreateField = 0x5b13, - LoadTable = 0x5b1f, - Load = 0x5b20, - Stall = 0x5b21, - Sleep = 0x5b22, - Acquire = 0x5b23, - Signal = 0x5b24, - Wait = 0x5b25, - Reset = 0x5b26, - Release = 0x5b27, - FromBCD = 0x5b28, - ToBCD = 0x5b29, - Unload = 0x5b2a, - Revision = 0x5b30, - Debug = 0x5b31, - Fatal = 0x5b32, - Timer = 0x5b33, - Region = 0x5b80, - Field = 0x5b81, - Device = 0x5b82, - Processor = 0x5b83, - PowerResource = 0x5b84, - ThermalZone = 0x5b85, - IndexField = 0x5b86, - BankField = 0x5b87, - DataRegion = 0x5b88, - - FieldOffset = 0x00, - FieldAccess = 0x01, - FieldConnection = 0x02, - FieldExternalAccess = 0x03, - - NamePath = 0x002d, - NamedField = 0x0030, - ReservedField = 0x0031, - AccessField = 0x0032, - ByteList = 0x0033, - MethodCall = 0x0035, - ReturnValue = 0x0036, - EvalSubtree = 0x0037, - Connection = 0x0038, - ExternalAccessField = 0x0039, - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs b/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs deleted file mode 100644 index 7948c1a77f..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCodeFlags.cs +++ /dev/null @@ -1,40 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - [Flags] - public enum OpCodeFlags : ushort - { - Logical = 0x0001, - LogicalNumeric = 0x0002, - Math = 0x0004, - Create = 0x0008, - Field = 0x0010, - Defer = 0x0020, - Named = 0x0040, - NSNode = 0x0080, - NSOpCode = 0x0100, - NSObject = 0x0200, - HasReturnValue = 0x0400, - HasTarget = 0x0800, - HasArguments = 0x1000, - Constant = 0x2000, - NoOperandResolve = 0x4000, - } - - class OpCodeExtendedFlags - { - public static OpCodeFlags AML_FLAGS_EXEC_0A_0T_1R = OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_1A_0T_0R = OpCodeFlags.HasArguments; - public static OpCodeFlags AML_FLAGS_EXEC_1A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_1A_1T_0R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget; - public static OpCodeFlags AML_FLAGS_EXEC_1A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_2A_0T_0R = OpCodeFlags.HasArguments; - public static OpCodeFlags AML_FLAGS_EXEC_2A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_2A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_2A_2T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_3A_0T_0R = OpCodeFlags.HasArguments; - public static OpCodeFlags AML_FLAGS_EXEC_3A_1T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasTarget | OpCodeFlags.HasReturnValue; - public static OpCodeFlags AML_FLAGS_EXEC_6A_0T_1R = OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue; - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs b/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs deleted file mode 100644 index 556b5da818..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCodeTable.cs +++ /dev/null @@ -1,244 +0,0 @@ -namespace ACPILib.AML -{ - public class OpCodeTable - { - public const byte Unkn = 0x6B; - public const byte Text = 0x6C; - public const byte Prfx = 0x6D; - - public static byte[] ShortOpCodeIndexes = - { -/* 0 1 2 3 4 5 6 7 */ -/* 8 9 A B C D E F */ -/* 0x00 */ 0x00, 0x01, Unkn, Unkn, Unkn, Unkn, 0x02, Unkn, -/* 0x08 */ 0x03, Unkn, 0x04, 0x05, 0x06, 0x07, 0x6E, Unkn, -/* 0x10 */ 0x08, 0x09, 0x0a, 0x6F, 0x0b, 0x81, Unkn, Unkn, -/* 0x18 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x20 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x28 */ Unkn, Unkn, Unkn, Unkn, Unkn, 0x63, Prfx, Prfx, -/* 0x30 */ 0x67, 0x66, 0x68, 0x65, 0x69, 0x64, 0x6A, 0x7D, -/* 0x38 */ 0x7F, 0x80, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x40 */ Unkn, Text, Text, Text, Text, Text, Text, Text, -/* 0x48 */ Text, Text, Text, Text, Text, Text, Text, Text, -/* 0x50 */ Text, Text, Text, Text, Text, Text, Text, Text, -/* 0x58 */ Text, Text, Text, Unkn, Prfx, Unkn, Prfx, Text, -/* 0x60 */ 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, -/* 0x68 */ 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, Unkn, -/* 0x70 */ 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, -/* 0x78 */ 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, -/* 0x80 */ 0x2b, 0x2c, 0x2d, 0x2e, 0x70, 0x71, 0x2f, 0x30, -/* 0x88 */ 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x72, -/* 0x90 */ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x73, 0x74, -/* 0x98 */ 0x75, 0x76, Unkn, Unkn, 0x77, 0x78, 0x79, 0x7A, -/* 0xA0 */ 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x60, 0x61, -/* 0xA8 */ 0x62, 0x82, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xB0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xB8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xC0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xC8 */ Unkn, Unkn, Unkn, Unkn, 0x44, Unkn, Unkn, Unkn, -/* 0xD0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xD8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xE0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xE8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xF0 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0xF8 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, 0x45, - }; - - public static byte[] LongOpCodeIndexes = - { -/* 0 1 2 3 4 5 6 7 */ -/* 8 9 A B C D E F */ -/* 0x00 */ Unkn, 0x46, 0x47, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x08 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x10 */ Unkn, Unkn, 0x48, 0x49, Unkn, Unkn, Unkn, Unkn, -/* 0x18 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, 0x7B, -/* 0x20 */ 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, -/* 0x28 */ 0x52, 0x53, 0x54, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x30 */ 0x55, 0x56, 0x57, 0x7e, Unkn, Unkn, Unkn, Unkn, -/* 0x38 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x40 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x48 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x50 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x58 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x60 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x68 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x70 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x78 */ Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, Unkn, -/* 0x80 */ 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, -/* 0x88 */ 0x7C, - }; - - public static OpCode[] OpCodes = new OpCode[] -{ -/* Index Name Parser Args Interpreter Args ObjectType Class Type Flags */ -/* 00 */ new OpCode(OpCodeEnum.Zero, ParseArgs.ARGP_ZERO_OP, InterpreterArgs.ARGI_ZERO_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 01 */ new OpCode(OpCodeEnum.One, ParseArgs.ARGP_ONE_OP, InterpreterArgs.ARGI_ONE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), -/* 02 */ new OpCode(OpCodeEnum.Alias, ParseArgs.ARGP_ALIAS_OP, InterpreterArgs.ARGI_ALIAS_OP, ObjectTypeEnum.LocalAlias, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 03 */ new OpCode(OpCodeEnum.Name, ParseArgs.ARGP_NAME_OP, InterpreterArgs.ARGI_NAME_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 04 */ new OpCode(OpCodeEnum.Byte, ParseArgs.ARGP_BYTE_OP, InterpreterArgs.ARGI_BYTE_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 05 */ new OpCode(OpCodeEnum.Word, ParseArgs.ARGP_WORD_OP, InterpreterArgs.ARGI_WORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 06 */ new OpCode(OpCodeEnum.DWord, ParseArgs.ARGP_DWORD_OP, InterpreterArgs.ARGI_DWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 07 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STRING_OP, InterpreterArgs.ARGI_STRING_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 08 */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.LocalScope, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 09 */ new OpCode(OpCodeEnum.Buffer, ParseArgs.ARGP_BUFFER_OP, InterpreterArgs.ARGI_BUFFER_OP, ObjectTypeEnum.Buffer, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0A */ new OpCode(OpCodeEnum.Package, ParseArgs.ARGP_PACKAGE_OP, InterpreterArgs.ARGI_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer | OpCodeFlags.Constant), -/* 0B */ new OpCode(OpCodeEnum.Method, ParseArgs.ARGP_METHOD_OP, InterpreterArgs.ARGI_METHOD_OP, ObjectTypeEnum.Method, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 0C */ new OpCode(OpCodeEnum.Local0, ParseArgs.ARGP_LOCAL0, InterpreterArgs.ARGI_LOCAL0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0D */ new OpCode(OpCodeEnum.Local1, ParseArgs.ARGP_LOCAL1, InterpreterArgs.ARGI_LOCAL1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0E */ new OpCode(OpCodeEnum.Local2, ParseArgs.ARGP_LOCAL2, InterpreterArgs.ARGI_LOCAL2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 0F */ new OpCode(OpCodeEnum.Local3, ParseArgs.ARGP_LOCAL3, InterpreterArgs.ARGI_LOCAL3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 10 */ new OpCode(OpCodeEnum.Local4, ParseArgs.ARGP_LOCAL4, InterpreterArgs.ARGI_LOCAL4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 11 */ new OpCode(OpCodeEnum.Local5, ParseArgs.ARGP_LOCAL5, InterpreterArgs.ARGI_LOCAL5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 12 */ new OpCode(OpCodeEnum.Local6, ParseArgs.ARGP_LOCAL6, InterpreterArgs.ARGI_LOCAL6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 13 */ new OpCode(OpCodeEnum.Local7, ParseArgs.ARGP_LOCAL7, InterpreterArgs.ARGI_LOCAL7, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.LocalVariable, 0), -/* 14 */ new OpCode(OpCodeEnum.Arg0, ParseArgs.ARGP_ARG0, InterpreterArgs.ARGI_ARG0, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 15 */ new OpCode(OpCodeEnum.Arg1, ParseArgs.ARGP_ARG1, InterpreterArgs.ARGI_ARG1, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 16 */ new OpCode(OpCodeEnum.Arg2, ParseArgs.ARGP_ARG2, InterpreterArgs.ARGI_ARG2, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 17 */ new OpCode(OpCodeEnum.Arg3, ParseArgs.ARGP_ARG3, InterpreterArgs.ARGI_ARG3, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 18 */ new OpCode(OpCodeEnum.Arg4, ParseArgs.ARGP_ARG4, InterpreterArgs.ARGI_ARG4, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 19 */ new OpCode(OpCodeEnum.Arg5, ParseArgs.ARGP_ARG5, InterpreterArgs.ARGI_ARG5, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1A */ new OpCode(OpCodeEnum.Arg6, ParseArgs.ARGP_ARG6, InterpreterArgs.ARGI_ARG6, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.MethodArgument, 0), -/* 1B */ new OpCode(OpCodeEnum.Store, ParseArgs.ARGP_STORE_OP, InterpreterArgs.ARGI_STORE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 1C */ new OpCode(OpCodeEnum.ReferenceOf, ParseArgs.ARGP_REF_OF_OP, InterpreterArgs.ARGI_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 1D */ new OpCode(OpCodeEnum.Add, ParseArgs.ARGP_ADD_OP, InterpreterArgs.ARGI_ADD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 1E */ new OpCode(OpCodeEnum.Concatenate, ParseArgs.ARGP_CONCAT_OP, InterpreterArgs.ARGI_CONCAT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 1F */ new OpCode(OpCodeEnum.Subtract, ParseArgs.ARGP_SUBTRACT_OP, InterpreterArgs.ARGI_SUBTRACT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 20 */ new OpCode(OpCodeEnum.Increment, ParseArgs.ARGP_INCREMENT_OP, InterpreterArgs.ARGI_INCREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 21 */ new OpCode(OpCodeEnum.Decrement, ParseArgs.ARGP_DECREMENT_OP, InterpreterArgs.ARGI_DECREMENT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 22 */ new OpCode(OpCodeEnum.Multiply, ParseArgs.ARGP_MULTIPLY_OP, InterpreterArgs.ARGI_MULTIPLY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 23 */ new OpCode(OpCodeEnum.Divide, ParseArgs.ARGP_DIVIDE_OP, InterpreterArgs.ARGI_DIVIDE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_2T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_2T_1R | OpCodeFlags.Constant), -/* 24 */ new OpCode(OpCodeEnum.ShiftLeft, ParseArgs.ARGP_SHIFT_LEFT_OP, InterpreterArgs.ARGI_SHIFT_LEFT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 25 */ new OpCode(OpCodeEnum.ShiftRight, ParseArgs.ARGP_SHIFT_RIGHT_OP, InterpreterArgs.ARGI_SHIFT_RIGHT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 26 */ new OpCode(OpCodeEnum.BitAnd, ParseArgs.ARGP_BIT_AND_OP, InterpreterArgs.ARGI_BIT_AND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 27 */ new OpCode(OpCodeEnum.BitNand, ParseArgs.ARGP_BIT_NAND_OP, InterpreterArgs.ARGI_BIT_NAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 28 */ new OpCode(OpCodeEnum.BitOr, ParseArgs.ARGP_BIT_OR_OP, InterpreterArgs.ARGI_BIT_OR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 29 */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOR_OP, InterpreterArgs.ARGI_BIT_NOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2A */ new OpCode(OpCodeEnum.BitXor, ParseArgs.ARGP_BIT_XOR_OP, InterpreterArgs.ARGI_BIT_XOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Math | OpCodeFlags.Constant), -/* 2B */ new OpCode(OpCodeEnum.BitNor, ParseArgs.ARGP_BIT_NOT_OP, InterpreterArgs.ARGI_BIT_NOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2C */ new OpCode(OpCodeEnum.FindSetLeftBit, ParseArgs.ARGP_FIND_SET_LEFT_BIT_OP, InterpreterArgs.ARGI_FIND_SET_LEFT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2D */ new OpCode(OpCodeEnum.FindSetRightBit, ParseArgs.ARGP_FIND_SET_RIGHT_BIT_OP,InterpreterArgs.ARGI_FIND_SET_RIGHT_BIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 2E */ new OpCode(OpCodeEnum.DereferenceOf, ParseArgs.ARGP_DEREF_OF_OP, InterpreterArgs.ARGI_DEREF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R), -/* 2F */ new OpCode(OpCodeEnum.Notify, ParseArgs.ARGP_NOTIFY_OP, InterpreterArgs.ARGI_NOTIFY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_0R), -/* 30 */ new OpCode(OpCodeEnum.SizeOf, ParseArgs.ARGP_SIZE_OF_OP, InterpreterArgs.ARGI_SIZE_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), -/* 31 */ new OpCode(OpCodeEnum.Index, ParseArgs.ARGP_INDEX_OP, InterpreterArgs.ARGI_INDEX_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R), -/* 32 */ new OpCode(OpCodeEnum.Match, ParseArgs.ARGP_MATCH_OP, InterpreterArgs.ARGI_MATCH_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R | OpCodeFlags.Constant), -/* 33 */ new OpCode(OpCodeEnum.CreateDWordField, ParseArgs.ARGP_CREATE_DWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_DWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 34 */ new OpCode(OpCodeEnum.CreateWordField, ParseArgs.ARGP_CREATE_WORD_FIELD_OP, InterpreterArgs.ARGI_CREATE_WORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 35 */ new OpCode(OpCodeEnum.CreateByteField, ParseArgs.ARGP_CREATE_BYTE_FIELD_OP, InterpreterArgs.ARGI_CREATE_BYTE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 36 */ new OpCode(OpCodeEnum.CreateBitField, ParseArgs.ARGP_CREATE_BIT_FIELD_OP, InterpreterArgs.ARGI_CREATE_BIT_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 37 */ new OpCode(OpCodeEnum.ObjectType, ParseArgs.ARGP_OBJECT_TYPE_OP, InterpreterArgs.ARGI_OBJECT_TYPE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.NoOperandResolve), -/* 38 */ new OpCode(OpCodeEnum.LogicalAnd, ParseArgs.ARGP_LAND_OP, InterpreterArgs.ARGI_LAND_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), -/* 39 */ new OpCode(OpCodeEnum.LogicalOr, ParseArgs.ARGP_LOR_OP, InterpreterArgs.ARGI_LOR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.LogicalNumeric | OpCodeFlags.Constant), -/* 3A */ new OpCode(OpCodeEnum.LogicalNot, ParseArgs.ARGP_LNOT_OP, InterpreterArgs.ARGI_LNOT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_1R | OpCodeFlags.Constant), -/* 3B */ new OpCode(OpCodeEnum.LogicalEqual, ParseArgs.ARGP_LEQUAL_OP, InterpreterArgs.ARGI_LEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), -/* 3C */ new OpCode(OpCodeEnum.LogicalGreater, ParseArgs.ARGP_LGREATER_OP, InterpreterArgs.ARGI_LGREATER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), -/* 3D */ new OpCode(OpCodeEnum.LogicalLess, ParseArgs.ARGP_LLESS_OP, InterpreterArgs.ARGI_LLESS_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R | OpCodeFlags.Logical | OpCodeFlags.Constant), -/* 3E */ new OpCode(OpCodeEnum.If, ParseArgs.ARGP_IF_OP, InterpreterArgs.ARGI_IF_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 3F */ new OpCode(OpCodeEnum.Else, ParseArgs.ARGP_ELSE_OP, InterpreterArgs.ARGI_ELSE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 40 */ new OpCode(OpCodeEnum.While, ParseArgs.ARGP_WHILE_OP, InterpreterArgs.ARGI_WHILE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 41 */ new OpCode(OpCodeEnum.NoOp, ParseArgs.ARGP_NOOP_OP, InterpreterArgs.ARGI_NOOP_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 42 */ new OpCode(OpCodeEnum.Return, ParseArgs.ARGP_RETURN_OP, InterpreterArgs.ARGI_RETURN_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, OpCodeFlags.HasArguments), -/* 43 */ new OpCode(OpCodeEnum.Break, ParseArgs.ARGP_BREAK_OP, InterpreterArgs.ARGI_BREAK_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 44 */ new OpCode(OpCodeEnum.Breakpoint, ParseArgs.ARGP_BREAK_POINT_OP, InterpreterArgs.ARGI_BREAK_POINT_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 45 */ new OpCode(OpCodeEnum.Ones, ParseArgs.ARGP_ONES_OP, InterpreterArgs.ARGI_ONES_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, OpCodeFlags.Constant), - -/* Prefixed opcodes (Two-byte opcodes with a prefix op) */ - -/* 46 */ new OpCode(OpCodeEnum.Mutex, ParseArgs.ARGP_MUTEX_OP, InterpreterArgs.ARGI_MUTEX_OP, ObjectTypeEnum.Mutex, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 47 */ new OpCode(OpCodeEnum.Event, ParseArgs.ARGP_EVENT_OP, InterpreterArgs.ARGI_EVENT_OP, ObjectTypeEnum.Event, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), -/* 48 */ new OpCode(OpCodeEnum.ConditionalReferenceOf, ParseArgs.ARGP_COND_REF_OF_OP, InterpreterArgs.ARGI_COND_REF_OF_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 49 */ new OpCode(OpCodeEnum.CreateField, ParseArgs.ARGP_CREATE_FIELD_OP, InterpreterArgs.ARGI_CREATE_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Field | OpCodeFlags.Create), -/* 4A */ new OpCode(OpCodeEnum.Load, ParseArgs.ARGP_LOAD_OP, InterpreterArgs.ARGI_LOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_0R), -/* 4B */ new OpCode(OpCodeEnum.Stall, ParseArgs.ARGP_STALL_OP, InterpreterArgs.ARGI_STALL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4C */ new OpCode(OpCodeEnum.Sleep, ParseArgs.ARGP_SLEEP_OP, InterpreterArgs.ARGI_SLEEP_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4D */ new OpCode(OpCodeEnum.Acquire, ParseArgs.ARGP_ACQUIRE_OP, InterpreterArgs.ARGI_ACQUIRE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 4E */ new OpCode(OpCodeEnum.Signal, ParseArgs.ARGP_SIGNAL_OP, InterpreterArgs.ARGI_SIGNAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 4F */ new OpCode(OpCodeEnum.Wait, ParseArgs.ARGP_WAIT_OP, InterpreterArgs.ARGI_WAIT_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_0T_1R), -/* 50 */ new OpCode(OpCodeEnum.Reset, ParseArgs.ARGP_RESET_OP, InterpreterArgs.ARGI_RESET_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 51 */ new OpCode(OpCodeEnum.Release, ParseArgs.ARGP_RELEASE_OP, InterpreterArgs.ARGI_RELEASE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 52 */ new OpCode(OpCodeEnum.FromBCD, ParseArgs.ARGP_FROM_BCD_OP, InterpreterArgs.ARGI_FROM_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 53 */ new OpCode(OpCodeEnum.ToBCD, ParseArgs.ARGP_TO_BCD_OP, InterpreterArgs.ARGI_TO_BCD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 54 */ new OpCode(OpCodeEnum.Unload, ParseArgs.ARGP_UNLOAD_OP, InterpreterArgs.ARGI_UNLOAD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_0T_0R), -/* 55 */ new OpCode(OpCodeEnum.Revision, ParseArgs.ARGP_REVISION_OP, InterpreterArgs.ARGI_REVISION_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 56 */ new OpCode(OpCodeEnum.Debug, ParseArgs.ARGP_DEBUG_OP, InterpreterArgs.ARGI_DEBUG_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Constant, 0), -/* 57 */ new OpCode(OpCodeEnum.Fatal, ParseArgs.ARGP_FATAL_OP, InterpreterArgs.ARGI_FATAL_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_0T_0R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_0T_0R), -/* 58 */ new OpCode(OpCodeEnum.Region, ParseArgs.ARGP_REGION_OP, InterpreterArgs.ARGI_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 59 */ new OpCode(OpCodeEnum.Field, ParseArgs.ARGP_FIELD_OP, InterpreterArgs.ARGI_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5A */ new OpCode(OpCodeEnum.Device, ParseArgs.ARGP_DEVICE_OP, InterpreterArgs.ARGI_DEVICE_OP, ObjectTypeEnum.Device, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5B */ new OpCode(OpCodeEnum.Processor, ParseArgs.ARGP_PROCESSOR_OP, InterpreterArgs.ARGI_PROCESSOR_OP, ObjectTypeEnum.Processor, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5C */ new OpCode(OpCodeEnum.PowerResource, ParseArgs.ARGP_POWER_RES_OP, InterpreterArgs.ARGI_POWER_RES_OP, ObjectTypeEnum.Power, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5D */ new OpCode(OpCodeEnum.ThermalZone, ParseArgs.ARGP_THERMAL_ZONE_OP, InterpreterArgs.ARGI_THERMAL_ZONE_OP, ObjectTypeEnum.Thermal, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 5E */ new OpCode(OpCodeEnum.IndexField, ParseArgs.ARGP_INDEX_FIELD_OP, InterpreterArgs.ARGI_INDEX_FIELD_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field), -/* 5F */ new OpCode(OpCodeEnum.BankField, ParseArgs.ARGP_BANK_FIELD_OP, InterpreterArgs.ARGI_BANK_FIELD_OP, ObjectTypeEnum.LocalBankField, OpCodeClass.NamedObject, OpCodeType.NamedField, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.Field | OpCodeFlags.Defer), - -/* Internal opcodes that map to invalid AML opcodes */ - -/* 60 */ new OpCode(OpCodeEnum.LogicalNotEqual, ParseArgs.ARGP_LNOTEQUAL_OP, InterpreterArgs.ARGI_LNOTEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), -/* 61 */ new OpCode(OpCodeEnum.LogicalLessEqual, ParseArgs.ARGP_LLESSEQUAL_OP, InterpreterArgs.ARGI_LLESSEQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), -/* 62 */ new OpCode(OpCodeEnum.LogicalGreaterEqual, ParseArgs.ARGP_LGREATEREQUAL_OP, InterpreterArgs.ARGI_LGREATEREQUAL_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments | OpCodeFlags.Constant), -/* 63 */ new OpCode(OpCodeEnum.NamePath, ParseArgs.ARGP_NAMEPATH_OP, InterpreterArgs.ARGI_NAMEPATH_OP, ObjectTypeEnum.LocalReference, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.NSObject | OpCodeFlags.NSNode ), -/* 64 */ new OpCode(OpCodeEnum.MethodCall, ParseArgs.ARGP_METHODCALL_OP, InterpreterArgs.ARGI_METHODCALL_OP, ObjectTypeEnum.Method, OpCodeClass.MethodCall, OpCodeType.MethodCall, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode), -/* 65 */ new OpCode(OpCodeEnum.ByteList, ParseArgs.ARGP_BYTELIST_OP, InterpreterArgs.ARGI_BYTELIST_OP, ObjectTypeEnum.Any, OpCodeClass.Argument, OpCodeType.Literal, 0), -/* 66 */ new OpCode(OpCodeEnum.ReservedField, ParseArgs.ARGP_RESERVEDFIELD_OP, InterpreterArgs.ARGI_RESERVEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 67 */ new OpCode(OpCodeEnum.NamedField, ParseArgs.ARGP_NAMEDFIELD_OP, InterpreterArgs.ARGI_NAMEDFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named ), -/* 68 */ new OpCode(OpCodeEnum.AccessField, ParseArgs.ARGP_ACCESSFIELD_OP, InterpreterArgs.ARGI_ACCESSFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 69 */ new OpCode(OpCodeEnum.String, ParseArgs.ARGP_STATICSTRING_OP, InterpreterArgs.ARGI_STATICSTRING_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), -/* 6A */ new OpCode(OpCodeEnum.ReturnValue, ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ReturnValue, OpCodeType.Return, OpCodeFlags.HasArguments | OpCodeFlags.HasReturnValue), -/* 6B */ new OpCode("-UNKNOWN_OP-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Invalid, OpCodeClass.ClassUnknown, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6C */ new OpCode("-ASCII_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.ASCII, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 6D */ new OpCode("-PREFIX_ONLY-", ParseArgs.ARG_NONE, InterpreterArgs.ARG_NONE, ObjectTypeEnum.Any, OpCodeClass.Prefix, OpCodeType.Bogus, OpCodeFlags.HasArguments), - -/* ACPI 2.0 opcodes */ - -/* 6E */ new OpCode(OpCodeEnum.QWord, ParseArgs.ARGP_QWORD_OP, InterpreterArgs.ARGI_QWORD_OP, ObjectTypeEnum.Integer, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant), -/* 6F */ new OpCode(OpCodeEnum.Package, /* Var */ ParseArgs.ARGP_VAR_PACKAGE_OP, InterpreterArgs.ARGI_VAR_PACKAGE_OP, ObjectTypeEnum.Package, OpCodeClass.Create, OpCodeType.CreateObject, OpCodeFlags.HasArguments | OpCodeFlags.Defer), -/* 70 */ new OpCode(OpCodeEnum.ConcatenateTemplate, ParseArgs.ARGP_CONCAT_RES_OP, InterpreterArgs.ARGI_CONCAT_RES_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 71 */ new OpCode(OpCodeEnum.Mod, ParseArgs.ARGP_MOD_OP, InterpreterArgs.ARGI_MOD_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 72 */ new OpCode(OpCodeEnum.CreateQWordField, ParseArgs.ARGP_CREATE_QWORD_FIELD_OP,InterpreterArgs.ARGI_CREATE_QWORD_FIELD_OP, ObjectTypeEnum.BufferField, OpCodeClass.Create, OpCodeType.CreateField, OpCodeFlags. HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSNode | OpCodeFlags.Defer | OpCodeFlags.Create), -/* 73 */ new OpCode(OpCodeEnum.ToBuffer, ParseArgs.ARGP_TO_BUFFER_OP, InterpreterArgs.ARGI_TO_BUFFER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 74 */ new OpCode(OpCodeEnum.ToDecimalString, ParseArgs.ARGP_TO_DEC_STR_OP, InterpreterArgs.ARGI_TO_DEC_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 75 */ new OpCode(OpCodeEnum.ToHexString, ParseArgs.ARGP_TO_HEX_STR_OP, InterpreterArgs.ARGI_TO_HEX_STR_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 76 */ new OpCode(OpCodeEnum.ToInteger, ParseArgs.ARGP_TO_INTEGER_OP, InterpreterArgs.ARGI_TO_INTEGER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R | OpCodeFlags.Constant), -/* 77 */ new OpCode(OpCodeEnum.ToString, ParseArgs.ARGP_TO_STRING_OP, InterpreterArgs.ARGI_TO_STRING_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_2A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_2A_1T_1R | OpCodeFlags.Constant), -/* 78 */ new OpCode(OpCodeEnum.CopyObject, ParseArgs.ARGP_COPY_OP, InterpreterArgs.ARGI_COPY_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_1A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_1A_1T_1R), -/* 79 */ new OpCode(OpCodeEnum.Mid, ParseArgs.ARGP_MID_OP, InterpreterArgs.ARGI_MID_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_3A_1T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_3A_1T_1R | OpCodeFlags.Constant), -/* 7A */ new OpCode(OpCodeEnum.Continue, ParseArgs.ARGP_CONTINUE_OP, InterpreterArgs.ARGI_CONTINUE_OP, ObjectTypeEnum.Any, OpCodeClass.Control, OpCodeType.Control, 0), -/* 7B */ new OpCode(OpCodeEnum.LoadTable, ParseArgs.ARGP_LOAD_TABLE_OP, InterpreterArgs.ARGI_LOAD_TABLE_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_6A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_6A_0T_1R), -/* 7C */ new OpCode(OpCodeEnum.DataRegion, ParseArgs.ARGP_DATA_REGION_OP, InterpreterArgs.ARGI_DATA_REGION_OP, ObjectTypeEnum.Region, OpCodeClass.NamedObject, OpCodeType.NamedComplex, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named | OpCodeFlags.Defer), -/* 7D */ new OpCode(OpCodeEnum.Scope, ParseArgs.ARGP_SCOPE_OP, InterpreterArgs.ARGI_SCOPE_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedNoObject, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode), - -/* ACPI 3.0 opcodes */ - -/* 7E */ new OpCode(OpCodeEnum.Timer, ParseArgs.ARGP_TIMER_OP, InterpreterArgs.ARGI_TIMER_OP, ObjectTypeEnum.Any, OpCodeClass.Execute, OpCodeType.Execute_0A_0T_1R, OpCodeExtendedFlags.AML_FLAGS_EXEC_0A_0T_1R), - -/* ACPI 5.0 opcodes */ - -/* 7F */ new OpCode(OpCodeEnum.FieldConnection, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, OpCodeFlags.HasArguments), -/* 80 */ new OpCode(OpCodeEnum.ExternalAccessField, ParseArgs.ARGP_CONNECTFIELD_OP, InterpreterArgs.ARGI_CONNECTFIELD_OP, ObjectTypeEnum.Any, OpCodeClass.Internal, OpCodeType.Bogus, 0), - -/* ACPI 6.0 opcodes */ - -/* 81 */ new OpCode(OpCodeEnum.External, ParseArgs.ARGP_EXTERNAL_OP, InterpreterArgs.ARGI_EXTERNAL_OP, ObjectTypeEnum.Any, OpCodeClass.NamedObject, OpCodeType.NamedSimple, OpCodeFlags.HasArguments | OpCodeFlags.NSObject | OpCodeFlags.NSOpCode | OpCodeFlags.NSNode | OpCodeFlags.Named), -/* 82 */ new OpCode(OpCodeEnum.Comment, ParseArgs.ARGP_COMMENT_OP, InterpreterArgs.ARGI_COMMENT_OP, ObjectTypeEnum.String, OpCodeClass.Argument, OpCodeType.Literal, OpCodeFlags.Constant) -}; - - public static OpCode GetOpcode(ushort opCodeValue) - { - OpCode opCode = null; - - if ((opCodeValue & 0xFF00) == 0x0) - { - //Simple (8-bit) opcode - opCode = OpCodes[ShortOpCodeIndexes[(byte)opCodeValue]]; - } - - if (((opCodeValue & 0xFF00) == 0x5b00) && (((byte)opCodeValue) <= 0x88)) - { - //Extended (16-bit) opcode - opCode = OpCodes[LongOpCodeIndexes[(byte)opCodeValue]]; - } - - return opCode; - } - } -} diff --git a/source/Cosmos.Core/ACPI/AML/OpCodeType.cs b/source/Cosmos.Core/ACPI/AML/OpCodeType.cs deleted file mode 100644 index b784279bc8..0000000000 --- a/source/Cosmos.Core/ACPI/AML/OpCodeType.cs +++ /dev/null @@ -1,39 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - public enum OpCodeType : byte - { - Execute_0A_0T_1R = 0x00, - Execute_1A_0T_0R = 0x01, - Execute_1A_0T_1R = 0x02, - Execute_1A_1T_0R = 0x03, - Execute_1A_1T_1R = 0x04, - Execute_2A_0T_0R = 0x05, - Execute_2A_0T_1R = 0x06, - Execute_2A_1T_1R = 0x07, - Execute_2A_2T_1R = 0x08, - Execute_3A_0T_0R = 0x09, - Execute_3A_1T_1R = 0x0A, - Execute_6A_0T_1R = 0x0B, - - Literal = 0x0C, - Constant = 0x0D, - MethodArgument = 0x0E, - LocalVariable = 0x0F, - DataTerm = 0x10, - - MethodCall = 0x11, - - CreateField = 0x12, - CreateObject = 0x13, - Control = 0x14, - NamedNoObject = 0x15, - NamedField = 0x16, - NamedSimple = 0x17, - NamedComplex = 0x18, - Return = 0x19, - Undefined = 0x1A, - Bogus = 0x1B, - } -} diff --git a/source/Cosmos.Core/ACPI/AML/ParseArgs.cs b/source/Cosmos.Core/ACPI/AML/ParseArgs.cs deleted file mode 100644 index 81a0fb4c05..0000000000 --- a/source/Cosmos.Core/ACPI/AML/ParseArgs.cs +++ /dev/null @@ -1,162 +0,0 @@ -using System; - -namespace ACPILib.AML -{ - [Flags] - public enum ParseArgFlags : byte - { - None = 0x0, - ByteData = 0x01, - ByteList = 0x02, - CharList = 0x03, - DataObject = 0x04, - DataObjectList = 0x05, - DWordData = 0x06, - FieldList = 0x07, - Name = 0x08, - NameString = 0x09, - ObjectList = 0x0A, - PackageLength = 0x0B, - SuperName = 0x0C, - Target = 0x0D, - TermArg = 0x0E, - TermList = 0x0F, - WordData = 0x10, - QWordData = 0x11, - SimpleName = 0x12, - NameOrReference = 0x13, - Max = 0x13, - Comment = 0x14, - } - - class ParseArgs - { - public static ParseArgFlags[] ARGP_ACCESSFIELD_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_ACQUIRE_OP = { ParseArgFlags.SuperName, ParseArgFlags.WordData }; - public static ParseArgFlags[] ARGP_ADD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_ALIAS_OP = { ParseArgFlags.NameString, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_ARG0 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG1 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG2 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG3 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG4 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG5 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ARG6 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_BANK_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.NameString, ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; - public static ParseArgFlags[] ARGP_BIT_AND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BIT_NAND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BIT_NOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BIT_NOT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BIT_OR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BIT_XOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_BREAK_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_BREAK_POINT_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_BUFFER_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.ByteList }; - public static ParseArgFlags[] ARGP_BYTE_OP = { ParseArgFlags.ByteData }; - public static ParseArgFlags[] ARGP_BYTELIST_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_COMMENT_OP = { ParseArgFlags.ByteData, ParseArgFlags.Comment }; - public static ParseArgFlags[] ARGP_CONCAT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_CONCAT_RES_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_COND_REF_OF_OP = { ParseArgFlags.SimpleName, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_CONNECTFIELD_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_CONTINUE_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_COPY_OP = { ParseArgFlags.TermArg, ParseArgFlags.SimpleName }; - public static ParseArgFlags[] ARGP_CREATE_BIT_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_CREATE_BYTE_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_CREATE_DWORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_CREATE_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_CREATE_QWORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_CREATE_WORD_FIELD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_DATA_REGION_OP = { ParseArgFlags.Name, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_DEBUG_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_DECREMENT_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_DEREF_OF_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_DEVICE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ObjectList }; - public static ParseArgFlags[] ARGP_DIVIDE_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_DWORD_OP = { ParseArgFlags.DWordData }; - public static ParseArgFlags[] ARGP_ELSE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermList }; - public static ParseArgFlags[] ARGP_EVENT_OP = { ParseArgFlags.Name }; - public static ParseArgFlags[] ARGP_EXTERNAL_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.ByteData }; - public static ParseArgFlags[] ARGP_FATAL_OP = { ParseArgFlags.ByteData, ParseArgFlags.DWordData, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; - public static ParseArgFlags[] ARGP_FIND_SET_LEFT_BIT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_FIND_SET_RIGHT_BIT_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_FROM_BCD_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_IF_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.TermList }; - public static ParseArgFlags[] ARGP_INCREMENT_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_INDEX_FIELD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.NameString, ParseArgFlags.NameString, ParseArgFlags.ByteData, ParseArgFlags.FieldList }; - public static ParseArgFlags[] ARGP_INDEX_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_LAND_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LGREATER_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LGREATEREQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LLESS_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LLESSEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LNOT_OP = { ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LNOTEQUAL_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LOAD_OP = { ParseArgFlags.NameString, ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_LOAD_TABLE_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_LOCAL0 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL1 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL2 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL3 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL4 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL5 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL6 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOCAL7 = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_LOR_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_MATCH_OP = { ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_METHOD_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.TermList }; - public static ParseArgFlags[] ARGP_METHODCALL_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_MID_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_MOD_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_MULTIPLY_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_MUTEX_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData }; - public static ParseArgFlags[] ARGP_NAME_OP = { ParseArgFlags.Name, ParseArgFlags.DataObject }; - public static ParseArgFlags[] ARGP_NAMEDFIELD_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_NAMEPATH_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_NOOP_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_NOTIFY_OP = { ParseArgFlags.SuperName, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_OBJECT_TYPE_OP = { ParseArgFlags.SimpleName }; - public static ParseArgFlags[] ARGP_ONE_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_ONES_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_PACKAGE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.ByteData, ParseArgFlags.DataObjectList }; - public static ParseArgFlags[] ARGP_POWER_RES_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.WordData, ParseArgFlags.ObjectList }; - public static ParseArgFlags[] ARGP_PROCESSOR_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.DWordData, ParseArgFlags.ByteData, ParseArgFlags.ObjectList }; - public static ParseArgFlags[] ARGP_QWORD_OP = { ParseArgFlags.QWordData }; - public static ParseArgFlags[] ARGP_REF_OF_OP = { ParseArgFlags.SimpleName }; - public static ParseArgFlags[] ARGP_REGION_OP = { ParseArgFlags.Name, ParseArgFlags.ByteData, ParseArgFlags.TermArg, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_RELEASE_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_RESERVEDFIELD_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_RESET_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_RETURN_OP = { ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_REVISION_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_SCOPE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.TermList }; - public static ParseArgFlags[] ARGP_SERIALFIELD_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_SHIFT_LEFT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_SHIFT_RIGHT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_SIGNAL_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_SIZE_OF_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_SLEEP_OP = { ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_STALL_OP = { ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_STATICSTRING_OP = { ParseArgFlags.NameString }; - public static ParseArgFlags[] ARGP_STORE_OP = { ParseArgFlags.TermArg, ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_STRING_OP = { ParseArgFlags.CharList }; - public static ParseArgFlags[] ARGP_SUBTRACT_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_THERMAL_ZONE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.Name, ParseArgFlags.ObjectList }; - public static ParseArgFlags[] ARGP_TIMER_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARGP_TO_BCD_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_TO_BUFFER_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_TO_DEC_STR_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_TO_HEX_STR_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_TO_INTEGER_OP = { ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_TO_STRING_OP = { ParseArgFlags.TermArg, ParseArgFlags.TermArg, ParseArgFlags.Target }; - public static ParseArgFlags[] ARGP_UNLOAD_OP = { ParseArgFlags.SuperName }; - public static ParseArgFlags[] ARGP_VAR_PACKAGE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.DataObjectList }; - public static ParseArgFlags[] ARGP_WAIT_OP = { ParseArgFlags.SuperName, ParseArgFlags.TermArg }; - public static ParseArgFlags[] ARGP_WHILE_OP = { ParseArgFlags.PackageLength, ParseArgFlags.TermArg, ParseArgFlags.TermList }; - public static ParseArgFlags[] ARGP_WORD_OP = { ParseArgFlags.WordData }; - public static ParseArgFlags[] ARGP_ZERO_OP = { ParseArgFlags.None }; - public static ParseArgFlags[] ARG_NONE = { ParseArgFlags.None }; - } -} diff --git a/source/Cosmos.Core/ACPI/Interupter/EisaId.cs b/source/Cosmos.Core/ACPI/Interupter/EisaId.cs deleted file mode 100644 index 969a41f5a5..0000000000 --- a/source/Cosmos.Core/ACPI/Interupter/EisaId.cs +++ /dev/null @@ -1,26 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace ACPIAML.Interupter -{ - public class EisaId - { - public static string ToText(long ID) - { - var vendor = ID & 0xFFFF; - var device = ID >> 16; - var device1 = device & 0xFF; - var device2 = device >> 8; - var vendor_rev = ((vendor & 0xFF) << 8) | vendor >> 8; - var vendor1 = ((vendor_rev >> 10)&0x1f)+64; - var vendor2 = ((vendor_rev >> 5)&0x1f)+64; - var vendor3= ((vendor_rev >> 0)&0x1f)+64; - - string vendorStr = new(new char[] { (char)vendor1 , (char)vendor2 , (char)vendor3 }); - return vendorStr + device1.ToString("X2") + device2.ToString("X2"); - } - } -} diff --git a/source/Cosmos.Core/ACPI/Interupter/StackObject.cs b/source/Cosmos.Core/ACPI/Interupter/StackObject.cs deleted file mode 100644 index 076177bc95..0000000000 --- a/source/Cosmos.Core/ACPI/Interupter/StackObject.cs +++ /dev/null @@ -1,69 +0,0 @@ -using ACPILib.Parser2; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace ACPIAML.Interupter -{ - public class StackObject - { - private StackObject() - { - - } - - public object? Value; - public StackObjectType Type; - - public static StackObject Create(string s) - { - return new() { Type = StackObjectType.String, Value = s }; - } - public static StackObject Create(ParseNode s) - { - return new() { Type = StackObjectType.ParseNode, Value = s }; - } - public static StackObject Create(byte s) - { - return new() { Type = StackObjectType.Byte, Value = s }; - } - public static StackObject Create(short s) - { - return new() { Type = StackObjectType.Word, Value = s }; - } - public static StackObject Create(int s) - { - return new() { Type = StackObjectType.DWord, Value = s }; - } - public static StackObject Create(long s) - { - return new() { Type = StackObjectType.QWord, Value = s }; - } - public static StackObject Create(byte[] s) - { - return new() { Type = StackObjectType.ByteArray, Value = s }; - } - } - public enum StackObjectType - { - Null, - ParseNode, - String, - Byte, - ByteArray, - /// - /// short - /// - Word, - /// - /// int - /// - DWord, - /// - /// long - /// - QWord, - } -} diff --git a/source/Cosmos.Core/ACPI/Parser/AMLOp.cs b/source/Cosmos.Core/ACPI/Parser/AMLOp.cs deleted file mode 100644 index 394709db51..0000000000 --- a/source/Cosmos.Core/ACPI/Parser/AMLOp.cs +++ /dev/null @@ -1,71 +0,0 @@ -using ACPILib.AML; -using System.Collections.Generic; - -namespace ACPILib.Parser -{ - public class AMLOp - { - public AMLOp Parent; - - public OpCode OpCode; - - public string Name; - - public int Start; - public int Length; - public int End - { - get { return (Start + Length); } - } - - public object Value; - - public List Nodes = new List(); - - public AMLOp(AMLOp parent) - { - Parent = parent; - } - - public AMLOp(OpCode op, AMLOp parent) - { - OpCode = op; - Parent = parent; - } - - public override string ToString() - { - return OpCode.ToString(); - } - - public AMLOp FindScope() - { - AMLOp check = Parent; - while (check != null) - { - if (check.OpCode != null && check.OpCode.Code == OpCodeEnum.Scope) - return check; - - check = check.Parent; - } - - return null; - } - - public AMLOp FindMethod(string name) - { - if (OpCode != null && OpCode.Code == OpCodeEnum.Method && Name == name) - return this; - - foreach (AMLOp node in Nodes) - { - AMLOp method = node.FindMethod(name); - - if (method != null) - return method; - } - - return null; - } - } -} diff --git a/source/Cosmos.Core/ACPI/Parser/Parser.cs b/source/Cosmos.Core/ACPI/Parser/Parser.cs deleted file mode 100644 index 862ab711d4..0000000000 --- a/source/Cosmos.Core/ACPI/Parser/Parser.cs +++ /dev/null @@ -1,472 +0,0 @@ -using ACPILib.AML; -using System; -using System.IO; -using System.Text; - -namespace ACPILib.Parser -{ - public class Parser - { - private Stream _source; - - public Parser(Stream source) - { - _source = source; - } - - #region Stream reading tools - private byte PeekByte() - { - byte val = (byte)_source.ReadByte(); - _source.Seek(-1, SeekOrigin.Current); - - return val; - } - - private byte[] PeekBytes(int number) - { - byte[] buffer = new byte[number]; - int moved = _source.Read(buffer, 0, number); - - _source.Seek(-moved, SeekOrigin.Current); - - return buffer; - } - - private byte[] ReadBytes(int number) - { - byte[] buffer = new byte[number]; - _source.Read(buffer, 0, number); - - return buffer; - } - #endregion - - #region AML reading tools - private OpCode ReadOpcode() - { - ushort opCodeValue = (ushort)_source.ReadByte(); - if (opCodeValue == 0x5B) //Extended op prefix - { - opCodeValue = (ushort)((opCodeValue << 8) | (byte)_source.ReadByte()); - } - - return OpCodeTable.GetOpcode(opCodeValue); - } - - private ushort PeekOpcode() - { - ushort opCodeValue = (ushort)_source.ReadByte(); - if (opCodeValue == 0x5B) //Extended op prefix - { - opCodeValue = (ushort)((opCodeValue << 8) | (byte)_source.ReadByte()); - - _source.Seek(-2, SeekOrigin.Current); - } - else - { - _source.Seek(-1, SeekOrigin.Current); - } - - return opCodeValue; - } - - private AMLOp ReadAmlOp(AMLOp parent) - { - AMLOp op = new AMLOp(parent); - - op.Start = (int)_source.Position; - op.OpCode = ReadOpcode(); - - return op; - } - - private int ReadPackageLength() - { - int length = 0; - - byte b0 = (byte)_source.ReadByte(); - - int byteCount = (b0 >> 6); - - byte firstMask = (byte)(byteCount > 0 ? 0x0F : 0x3F); - - for (int b = 0; b < byteCount; b++) - { - length |= ((byte)_source.ReadByte() << ((byteCount << 3) - 4)); - } - - length |= (b0 & firstMask); - - return length; - } - - private string ReadNameString() - { - string name = string.Empty; - - int start = (int)_source.Position; - int end = (int)_source.Position; - - while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) - { - start++; - _source.Seek(start, SeekOrigin.Begin); - } - - end = start; - - //Find the size of the segment - _source.Seek(start, SeekOrigin.Begin); - int length = 0; - switch (PeekByte()) - { - case 0x0: //Null name - end++; - start = end; - break; - case Definitions.DualNamePrefix: - //Two name segments - start = end = (int)_source.Position + 1; - end += (2 * Definitions.NameSize); - - length = end - start; - break; - case Definitions.MultiNamePrefix: - //Multiple name segments, 4 chars each - _source.Seek(start + 1, SeekOrigin.Begin); - byte count = PeekByte(); - - start = end = (int)_source.Position + 1; - end += (count * Definitions.NameSize); - - length = end - start; - break; - default: - //Single segment - length = Definitions.NameSize; - end += length; - break; - } - - _source.Seek(start, SeekOrigin.Begin); - for (int x = 0; x < length; x++) - { - byte readByte = (byte)_source.ReadByte(); - if (readByte == 0x0) - continue; - - name += (char)readByte; - - if ((x + 1) % 4 == 0 && x + 1 < length) - name += "."; - } - - _source.Seek(end, SeekOrigin.Begin); - - return name; - } - - private string ReadNamePath() - { - return ReadNameString(); //Is this the same as the path? - } - - private AMLOp ReadField(AMLOp parent) - { - OpCodeEnum type = (OpCodeEnum)PeekByte(); - - AMLOp amlOp = null; - switch (type) - { - case OpCodeEnum.FieldOffset: - amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ReservedField), parent); - _source.Seek(1, SeekOrigin.Current); - - amlOp.Value = ReadPackageLength(); //Read the value as a PkgLength - break; - case OpCodeEnum.FieldAccess: - case OpCodeEnum.FieldExternalAccess: - amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)((type == OpCodeEnum.FieldAccess) ? OpCodeEnum.AccessField : OpCodeEnum.ByteList)), parent); - _source.Seek(1, SeekOrigin.Current); - - int accessType = (byte)_source.ReadByte(); - int accessAttribute = (byte)_source.ReadByte(); - - amlOp.Value = (int)(accessType | (accessAttribute << 8)); - - if (type == OpCodeEnum.FieldExternalAccess) //This one has a 3rd byte - { - amlOp.Value = (int)amlOp.Value | (_source.ReadByte() << 16); - } - break; - case OpCodeEnum.FieldConnection: - amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Connection), parent); - _source.Seek(1, SeekOrigin.Current); - - if (PeekByte() == (byte)OpCodeEnum.Buffer) - { - _source.Seek(1, SeekOrigin.Current); - - int end = (int)_source.Position + ReadPackageLength(); - - while (_source.Position < end) - { - AMLOp arg = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ByteList), parent); - - OpCodeEnum actualOpCode = (OpCodeEnum)(byte)_source.ReadByte(); - int bufferLength = 0; - switch (actualOpCode) - { - case OpCodeEnum.Byte: - bufferLength = (byte)_source.ReadByte(); - break; - case OpCodeEnum.Word: - bufferLength = BitConverter.ToInt16(ReadBytes(2), 0); - break; - case OpCodeEnum.DWord: - bufferLength = BitConverter.ToInt32(ReadBytes(4), 0); - break; - } - - arg.Value = ReadBytes(bufferLength); - - amlOp.Nodes.Add(arg); - } - } - else - { - AMLOp arg = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), parent); - arg.Value = ReadNameString(); - - amlOp.Nodes.Add(arg); - } - break; - default: - amlOp = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamedField), parent); - - amlOp.Name = Encoding.ASCII.GetString(ReadBytes(4)); - - amlOp.Value = ReadPackageLength(); //Read the value as a PkgLength - break; - } - - return amlOp; - } - - private AMLOp ReadTermArg(AMLOp parent) - { - byte[] peek4 = PeekBytes(4); - - //Check if all of the chars are letters - bool probalbyString = true; - for (int x = 0; x < peek4.Length; x++) - { - if (!char.IsDigit((char)peek4[x]) && !char.IsUpper((char)peek4[x])) - { - probalbyString = false; - break; - } - } - - if (probalbyString) //No idea what I'm doing here - { - AMLOp str = new AMLOp(OpCodeTable.GetOpcode(0x41), parent); - str.Value = ReadNameString(); - - return str; - } - - return ReadAmlOp(parent); - } - #endregion - - #region AML parsing - public AMLOp Parse() - { - AMLOp root = new AMLOp(null); - root.Name = "Root"; - - while (_source.Position < _source.Length) - { - AMLOp op = ReadAmlOp(null); - - root.Nodes.Add(op); - - ParseOp(op, false); - } - - return root; - } - - private void ParseOp(AMLOp op, bool isMethodBody) - { - if (op.OpCode == null) - return; - - for (int x = 0; x < op.OpCode.ParseArgs.Length; x++) - { - switch (op.OpCode.ParseArgs[x]) - { - //None - case ParseArgFlags.None: - break; - - //Simple values - case ParseArgFlags.Name: - case ParseArgFlags.NameString: - op.Name = ReadNameString(); - break; - case ParseArgFlags.ByteData: - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Byte), op) - { - Value = (byte)_source.ReadByte() - }); - break; - case ParseArgFlags.WordData: - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.Word), op) - { - Value = BitConverter.ToInt16(ReadBytes(2), 0) - }); - break; - case ParseArgFlags.DWordData: - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.DWord), op) - { - Value = BitConverter.ToInt32(ReadBytes(4), 0) - }); - break; - case ParseArgFlags.QWordData: - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.QWord), op) - { - Value = BitConverter.ToInt64(ReadBytes(8), 0) - }); - break; - case ParseArgFlags.CharList: - //Null terminated string - string value = ""; - - byte read; - while ((read = (byte)_source.ReadByte()) != 0x0) - { - value += (char)read; - } - - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.String), op) - { - Value = value - }); - break; - case ParseArgFlags.ByteList: - int length = op.End - (int)_source.Position + 1; - if (length < 0) - { - throw new ArgumentOutOfRangeException(); - } - - op.Nodes.Add(new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.ByteList), op) - { - Value = ReadBytes(length) - }); - break; - - //Complex values - case ParseArgFlags.PackageLength: - op.Length = ReadPackageLength(); - break; - case ParseArgFlags.ObjectList: - case ParseArgFlags.DataObjectList: - case ParseArgFlags.TermList: - if (op.OpCode.Code == OpCodeEnum.Method) - { - //Methods are too buggy, skip them - - _source.Seek(op.End + 1, SeekOrigin.Begin); - break; - } - - while (_source.Position < op.End) - { - AMLOp term = ReadTermArg(op); - - op.Nodes.Add(term); - - ParseOp(term, (op.OpCode.Code == OpCodeEnum.Method)); - } - break; - case ParseArgFlags.DataObject: - case ParseArgFlags.TermArg: - - AMLOp arg = ReadTermArg(op); - - if (isMethodBody || op.OpCode.Code == OpCodeEnum.Method) - { - if (arg.Value is string) - { - AMLOp scope = arg.FindScope(); - if (scope != null) - { - AMLOp method = scope.FindMethod((string)arg.Value); - - if (method != null) - { - AMLOp call = new ACPILib.Parser.AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.MethodCall), op); - call.Value = arg.Value; - arg = call; - } - } - } - } - - op.Nodes.Add(arg); - ParseOp(arg, isMethodBody); - - break; - case ParseArgFlags.FieldList: - while (_source.Position < op.End) - { - op.Nodes.Add(ReadField(op)); - } - break; - case ParseArgFlags.SimpleName: - case ParseArgFlags.NameOrReference: - ushort subOp = PeekOpcode(); - if (subOp == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp) || Definitions.IsLeadingChar((byte)subOp)) - { - AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); - op.Nodes.Add(namePath); - - namePath.Value = ReadNamePath(); - } - else - { - AMLOp term = ReadAmlOp(op); - op.Nodes.Add(term); - ParseOp(term, isMethodBody); - } - break; - case ParseArgFlags.Target: - case ParseArgFlags.SuperName: - ushort subOp2 = PeekOpcode(); - if (subOp2 == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp2) || Definitions.IsLeadingChar((byte)subOp2)) - { - AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); - op.Nodes.Add(namePath); - - namePath.Value = ReadNamePath(); - } - else - { - AMLOp term = ReadAmlOp(op); - op.Nodes.Add(term); - ParseOp(term, isMethodBody); - } - break; - - default: - throw new NotImplementedException("Unknown opcode"); - } - } - } - #endregion - } -} diff --git a/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs b/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs deleted file mode 100644 index baec302b49..0000000000 --- a/source/Cosmos.Core/ACPI/Parser2/ParseNode.cs +++ /dev/null @@ -1,30 +0,0 @@ -using ACPIAML.Interupter; -using ACPILib.AML; -using System.Collections.Generic; - -namespace ACPILib.Parser2 -{ - public class ParseNode - { - public OpCode Op; - public string Name; - - public long Start; - public long DataStart; - public long Length; - - public long End - { - get { return Start + Length + Op.CodeByteSize; } - } - - public StackObject? ConstantValue; - public List Arguments = new List(); - public List Nodes = new List(); - - public override string ToString() - { - return Op.ToString(); - } - } -} diff --git a/source/Cosmos.Core/ACPI/Parser2/Parser2.cs b/source/Cosmos.Core/ACPI/Parser2/Parser2.cs deleted file mode 100644 index 38a2667dd5..0000000000 --- a/source/Cosmos.Core/ACPI/Parser2/Parser2.cs +++ /dev/null @@ -1,538 +0,0 @@ -using ACPIAML.Interupter; -using ACPILib.AML; -using System; -using System.Collections.Generic; -using System.IO; -using System.Text; - -namespace ACPILib.Parser2 -{ - public class Parser - { - private Stream _source; - - public Parser(Stream s) - { - _source = s; - } - - public ParseNode Parse() - { - return PreParse(); - } - - private ParseNode PreParse() - { - ParseNode root = new ParseNode() - { - Name = "\\" - }; - - while (_source.Position < _source.Length) - { - ParseNode op = ParseFullOpCodeNode(); - root.Nodes.Add(op); - } - - return root; - } - - private ParseNode ParseFullOpCodeNode() - { - //Read the opcode - ParseNode op = ReadOpCode(); - OpCode info = op.Op; - - _source.Seek(op.DataStart, SeekOrigin.Begin); - long methodBodyAddr = 0; - - //Parse opcode arguments - if (info.ParseArgs.Length > 0) - { - bool parseArguments = false; - - switch (info.Code) - { - case OpCodeEnum.Byte: - case OpCodeEnum.Word: - case OpCodeEnum.DWord: - case OpCodeEnum.QWord: - case OpCodeEnum.String: - op.ConstantValue = ParseSimpleArgument(info.ParseArgs[0]); - break; - - case OpCodeEnum.NamePath: - op.Arguments.Add(StackObject.Create(ReadNameString())); - break; - - default: - parseArguments = true; - break; - } - - if (parseArguments) //If the opcode is not a constant - { - for (int x = 0; x < info.ParseArgs.Length; x++) - { - switch (info.ParseArgs[x]) - { - case ParseArgFlags.None: - break; - - case ParseArgFlags.ByteData: - case ParseArgFlags.WordData: - case ParseArgFlags.DWordData: - case ParseArgFlags.CharList: - case ParseArgFlags.Name: - case ParseArgFlags.NameString: - { - var arg = ParseSimpleArgument(info.ParseArgs[x]); - if (arg != null) - { - op.Arguments.Add(arg); - } - } - break; - case ParseArgFlags.DataObject: - case ParseArgFlags.TermArg: - { - //HACK: todo make this properly - methodBodyAddr = _source.Position; - var arg = ParseFullOpCodeNode(); //parsenode - - op.Arguments.Add(StackObject.Create(arg)); - } - break; - - case ParseArgFlags.PackageLength: - var xx = op.Length = ReadPackageLength(); - op.Arguments.Add(StackObject.Create(xx)); - break; - - case ParseArgFlags.FieldList: - while (_source.Position < op.End) - { - op.Arguments.Add(StackObject.Create(ReadField())); - } - break; - - case ParseArgFlags.ByteList: - if (_source.Position < op.End) - { - op.ConstantValue = StackObject.Create(ReadBytes((int)(op.End - _source.Position))); - } - break; - - case ParseArgFlags.DataObjectList: - case ParseArgFlags.TermList: - case ParseArgFlags.ObjectList: - var startPosition = _source.Position; - if (op.Arguments[1].Type == StackObjectType.String) - { - if ((string)op.Arguments[1].Value == "CPUS") - { - ; - } - } - while (_source.Position < op.End) - { - ParseNode child = ParseFullOpCodeNode(); - - op.Nodes.Add(child); - } - - break; - - case ParseArgFlags.Target: - case ParseArgFlags.SuperName: - ushort subOp2 = PeekUShort(); - if (subOp2 == 0 || Definitions.IsNameRootPrefixOrParentPrefix((byte)subOp2) || Definitions.IsLeadingChar((byte)subOp2)) - { - //AMLOp namePath = new AMLOp(OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath), op); - // var xxx = ParseFullOpCodeNode(); - //xxx.Name =; - var str = ReadNameString(); - op.Arguments.Add(StackObject.Create(str)); - - - } - else - { - _source.Seek(op.DataStart, SeekOrigin.Begin); - var xxx = ParseFullOpCodeNode(); - op.Nodes.Add(xxx); - ; - } - break; - - default: - Console.WriteLine("psargs.c / line 913 - Unknown arg: " + info.ParseArgs[x]); - break; - } - } - } - } - - //Parse the opcode - if ((info.Flags & OpCodeFlags.Named) == OpCodeFlags.Named) - { - for (int x = 0; x < info.ParseArgs.Length; x++) - { - if (info.ParseArgs[x] == ParseArgFlags.Name) - { - op.Name = (string)op.Arguments[x].Value; - break; - } - } - } - - if (op.Op.Name == "Scope") - { - var orgPosition = op.DataStart; - while (_source.Position < orgPosition + op.Length) - { - ParseNode op2 = ParseFullOpCodeNode(); - op.Nodes.Add(op2); - } - } - //else if (op.Op.Name == "Method") - //{ - // //We add one because we expect a DualNamePrefix (0x2E) - // _source.Seek(methodBodyAddr, SeekOrigin.Begin); - - // ////Read until function name string ends - // //while(_source.ReadByte() != 0) - // //{ - - // //} - - // var codeEnd = op.DataStart + op.Length; - - // while (_source.Position < codeEnd) - // { - // ParseNode op2 = ParseFullOpCodeNode(); - // op.Nodes.Add(op2); - // } - //} - - return op; - } - - private ParseNode ReadField() - { - OpCodeEnum opCode; - switch ((OpCodeEnum)PeekByte()) - { - case OpCodeEnum.FieldOffset: - - opCode = OpCodeEnum.ReservedField; ; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldAccess: - - opCode = OpCodeEnum.AccessField; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldConnection: - - opCode = OpCodeEnum.Connection; - _source.Seek(1, SeekOrigin.Current); - break; - - case OpCodeEnum.FieldExternalAccess: - - opCode = OpCodeEnum.ExternalAccessField; - _source.Seek(1, SeekOrigin.Current); - break; - - default: - opCode = OpCodeEnum.NamedField; - break; - } - - ParseNode node = new ParseNode() - { - Op = OpCodeTable.GetOpcode((ushort)opCode) - }; - - switch (opCode) - { - case OpCodeEnum.NamedField: - node.Name = Read4ByteName(); - node.ConstantValue = StackObject.Create(ReadPackageLength()); - break; - case OpCodeEnum.ReservedField: - node.ConstantValue = StackObject.Create(ReadPackageLength()); - break; - case OpCodeEnum.AccessField: - node.ConstantValue = StackObject.Create((ReadByte() | ((uint)ReadByte() << 8))); - break; - case OpCodeEnum.ExternalAccessField: - node.ConstantValue = StackObject.Create((ReadByte() | ((uint)ReadByte() << 8) | ((uint)ReadByte() << 16))); - break; - - default: - throw new Exception("psargs.c / line 703"); - } - - return node; - } - - private int ReadPackageLength() - { - int length; - - byte b0 = (byte)ReadByte(); - - byte sz = (byte)((b0 >> 6) & 3); - - if (sz == 0) - { - //out = (size_t)(code[*pc] & 0x3F); - //(*pc)++; - //return 0; - - length = b0 & 0x3F; - } - else if (sz == 1) - { - // *out = (size_t)(code[*pc] & 0x0F) | (size_t)(code[*pc + 1] << 4); - - length = ((b0 & 0x0F) | ReadByte() << 4); - } - else if (sz == 2) - { - length = ((b0 & 0x0F) | ReadByte() << 4) | (ReadByte() << 12); - } - else if (sz == 3) - { - length = ((b0 & 0x0F) | ReadByte() << 4) | (ReadByte() << 12) | (ReadByte() << 20); - } - else - { - throw new NotImplementedException(); - } - - return length; - } - - private StackObject ParseSimpleArgument(ParseArgFlags arg) - { - switch (arg) - { - case ParseArgFlags.ByteData: - return StackObject.Create((byte)ReadByte()); - case ParseArgFlags.WordData: - return StackObject.Create(BitConverter.ToInt16(ReadBytes(2), 0)); - case ParseArgFlags.DWordData: - return StackObject.Create(BitConverter.ToInt32(ReadBytes(4), 0)); - case ParseArgFlags.QWordData: - return StackObject.Create(BitConverter.ToInt64(ReadBytes(8), 0)); - case ParseArgFlags.CharList: //Nullterminated string - string str = string.Empty; - - byte read; - while ((read = (byte)ReadByte()) != 0) - str += (char)read; - - return StackObject.Create(str); - case ParseArgFlags.Name: - case ParseArgFlags.NameString: - return StackObject.Create(ReadNameString()); - } - - return null; - } - private string ReadNameString() - { - var x = _source.Position; - var b = (char)ReadByte(); - bool is_absolute = false; - if (b == '\\') - { - is_absolute = true; - } - else - { - bool xx = false; - while ((char)PeekByte() == '^') - { - xx = true; - _source.Position++; - } - if (xx) - { - b = (char)PeekByte(); - } - } - - int segmentNumber = 0; - bool UseBChar = false; - //var b2 = (char)ReadByte(); - string o = ""; - if (b == '\0') - { - segmentNumber = 0; - } - else if (b == 0x2E) - { - //dual prefix - segmentNumber = 2; - } - else if (b == 0x2F) - { - //dual prefix - segmentNumber = ReadByte(); - } - else - { - segmentNumber = 1; //default? - o += b.ToString(); - UseBChar = true; - } - var len = segmentNumber * 4; - if (UseBChar) - len -= 1; - for (int i = 0; i < len; i++) - { - o += ((char)ReadByte()).ToString(); - } - - foreach (var item in o) - { - if (!char.IsAscii(item)) - throw new Exception("Check failed: Char is not ASCII"); - } - return o; - ////Read past prefix chars - //while (Definitions.IsNameRootPrefixOrParentPrefix(PeekByte())) - //{ - // _source.Seek(1, SeekOrigin.Current); - //} - - //int segments = 0; - //var b = ReadByte(); - //switch (b) - //{ - // case 0: //Null string - // return string.Empty; - - // case Definitions.DualNamePrefix: - // segments = 2; - // break; - // case Definitions.MultiNamePrefix: - // segments = ReadByte(); - // break; - - // default: - // segments = 1; - - // _source.Seek(-1, SeekOrigin.Current); - // break; - //} - - //string name = string.Empty; - - //for (int seg = 0; seg < segments; seg++) - //{ - // string nameSeg = Read4ByteName(); - - // name += nameSeg; - - // if (seg < segments - 1) - // name += "."; - //} - - //return name; - } - - private ParseNode ReadOpCode() - { - long pos = _source.Position; - - ushort op = ReadUShort(); - OpCode? info = OpCodeTable.GetOpcode(op); - switch (info.Class) - { - case OpCodeClass.ASCII: - case OpCodeClass.Prefix: - info = OpCodeTable.GetOpcode((ushort)OpCodeEnum.NamePath); - pos -= 1; //The op code byte is the data itself - break; - case OpCodeClass.ClassUnknown: - Console.WriteLine("Unknown AML opcode: 0x" + op.ToString("X") + " at " + _source.Position); - break; - default: - _source.Seek(info.CodeByteSize, SeekOrigin.Current); - break; - } - - return new ParseNode() - { - Op = info, - Start = pos, - DataStart = pos + info.CodeByteSize - }; - } - - private string Read4ByteName() - { - byte[] dt = new byte[4]; - _source.Read(dt, 0, 4); - - return Encoding.ASCII.GetString(dt); - } - - private byte[] ReadBytes(int num) - { - byte[] temp = new byte[num]; - _source.Read(temp, 0, num); - - return temp; - } - - private byte PeekByte() - { - byte read = (byte)_source.ReadByte(); - - _source.Seek(-1, SeekOrigin.Current); - - return read; - } - - private ushort PeekUShort() - { - ushort code = (ushort)_source.ReadByte(); - if (code == Definitions.ExtendedOpCodePrefix) - { - code = (ushort)((code << 8) | (ushort)_source.ReadByte()); - - _source.Seek(-2, SeekOrigin.Current); - } - else - { - _source.Seek(-1, SeekOrigin.Current); - } - - return code; - } - - private byte ReadByte() - { - return (byte)_source.ReadByte(); - } - - private ushort ReadUShort() - { - ushort code = (ushort)_source.ReadByte(); - if (code == Definitions.ExtendedOpCodePrefix) - { - code = (ushort)((code << 8) | (ushort)_source.ReadByte()); - } - - return code; - } - } -} From 3ab0253ee68e5b04c46a04ada2187c16d9004bad Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Mon, 24 Oct 2022 17:04:27 +0200 Subject: [PATCH 31/35] ACPI Fixes + Hardcode IO APIC / Local APIC addresses if no ACPI detected --- source/Cosmos.Core/ACPI/ACPI.cs | 4 +--- source/Cosmos.Core/IOAPIC.cs | 11 +++++++---- source/Cosmos.Core/LocalAPIC.cs | 17 ++++++++++------- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index bd5359d6a7..8706ea75a2 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -1,6 +1,4 @@ -using ACPILib.AML; -using ACPILib.Parser2; -using Cosmos.Debug.Kernel; +using Cosmos.Debug.Kernel; using System; using System.Collections.Generic; using System.IO; diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index 9d55c0cf38..b9174fa29b 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -33,11 +33,14 @@ public static void Initialize() { if (ACPI.IOAPIC == null) { - Global.mDebugger.Send("Can't initialize IO APIC"); - return; + //TODO: Fix ACPI tables on Bochs + //No APIC detected, hardcode APIC address + Address = 0xFEC00000; + } + else + { + Address = ACPI.IOAPIC->IOApicAddress; } - - Address = ACPI.IOAPIC->IOApicAddress; Global.mDebugger.Send("IO APIC address:0x" + Address.ToString("X")); diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index d3a9c3de26..4e968cf6eb 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -74,15 +74,18 @@ public static unsafe class LocalAPIC /// public static void Initialize() { - if (ACPI.MADT == null) - { - Global.mDebugger.Send("Can't initialize Local APIC"); - return; - } - Global.PIC.Disable(); - Address = ACPI.MADT->LocalAPICAddress; + //TODO: Fix ACPI tables on Bochs + if (ACPI.LocalApicCpus.Count == 0) + { + //No APIC detected, hardcode APIC address + Address = 0xFEE00000; + } + else + { + Address = ACPI.MADT->LocalAPICAddress; + } Global.mDebugger.Send("Local APIC address:0x" + Address.ToString("X")); From 61b44113167888ba2fa1a85a618f3cdff6c54038 Mon Sep 17 00:00:00 2001 From: Quajak Date: Thu, 5 Jan 2023 11:22:29 -0500 Subject: [PATCH 32/35] Fix change to static IO Ports Fix compliation (Might have introduced bug) --- source/Cosmos.Core/ACPI/ACPI.cs | 18 +++-------------- source/Cosmos.Core/LocalAPIC.cs | 2 +- source/Cosmos.HAL2/PIT.cs | 36 ++++++++++++++++++++++++--------- 3 files changed, 30 insertions(+), 26 deletions(-) diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs index 8706ea75a2..e94e19a3ce 100644 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ b/source/Cosmos.Core/ACPI/ACPI.cs @@ -366,12 +366,6 @@ struct ApicInterruptOverride public ushort Flags; } - // New Port I/O - /// - /// IO port. - /// - private static IOPort smiIO, pm1aIO, pm1bIO, ResetRegister; - // ACPI variables /// /// SMI CMD. @@ -511,11 +505,11 @@ public static void Shutdown() Init(); } - pm1aIO.Word = (ushort)(SLP_TYPa | SLP_EN); + IOPort.Write16((ushort)PM1a_CNT, (ushort)(SLP_TYPa | SLP_EN)); if (PM1b_CNT != null) { - pm1bIO.Word = (ushort)(SLP_TYPb | SLP_EN); + IOPort.Write16((ushort)PM1b_CNT, (ushort)(SLP_TYPb | SLP_EN)); } CPU.Halt(); @@ -536,7 +530,7 @@ public static void Reboot() var header = FADT->Header; if (header.Revision >= 2 && (FADT->Flags & (1 << 10)) != 0) { - ResetRegister.Byte = ResetValue; + IOPort.Write16((ushort)FADT->ResetReg.Address, ResetValue); } else { @@ -697,10 +691,6 @@ private static void ParseDT(AcpiHeader* hdr) PM1_CNT_LEN = FADT->PM1ControlLength; SLP_EN = 1 << 13; - smiIO = new IOPort((ushort)SMI_CMD); - pm1aIO = new IOPort((ushort)PM1a_CNT); - pm1bIO = new IOPort((ushort)PM1b_CNT); - ResetRegister = new IOPort((ushort)FADT->ResetReg.Address); if (acpiCheckHeader((byte*)FADT->Dsdt, "DSDT") == 0) { @@ -833,7 +823,6 @@ private static void SearchPackage(ParseNode op) /// public static void Enable() { - smiIO = new IOPort(ACPI_ENABLE); } /// @@ -841,7 +830,6 @@ public static void Enable() /// public static void Disable() { - smiIO = new IOPort(ACPI_DISABLE); } /// diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 4e968cf6eb..65f4043cc4 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -74,7 +74,7 @@ public static unsafe class LocalAPIC /// public static void Initialize() { - Global.PIC.Disable(); + //Global.PIC.Disable(); //TODO: Fix ACPI tables on Bochs if (ACPI.LocalApicCpus.Count == 0) diff --git a/source/Cosmos.HAL2/PIT.cs b/source/Cosmos.HAL2/PIT.cs index 367b598d4f..4b34947974 100644 --- a/source/Cosmos.HAL2/PIT.cs +++ b/source/Cosmos.HAL2/PIT.cs @@ -60,7 +60,6 @@ public void Dispose() } } - protected Core.IOGroup.PIT IO = Core.Global.BaseIOGroups.PIT; private List ActiveHandlers = new List(); private ushort _T0Countdown = 65535; private ushort _T2Countdown = 65535; @@ -70,7 +69,24 @@ public void Dispose() public const uint PITDelayNS = 838; public bool T0RateGen = false; - public PIT() + /// + /// Channel 0 data port. + /// + public const int Data0 = 0x40; + /// + /// Channel 1 data port. + /// + public const int Data1 = 0x41; + /// + /// Channel 2 data port. + /// + public const int Data2 = 0x42; + /// + /// Command register port. + /// + public const int Command = 0x43; + + public PIT() { INTs.SetIntHandler(0x20 + 13, HandleIRQ); IOAPIC.SetEntry(2, 0x20 + 13); //PIT is mapped to IOAPIC via IRQ2 instead of IRQ0 @@ -88,10 +104,10 @@ public ushort T0Countdown { _T0Countdown = value; - IO.Command.Byte = (byte)(T0RateGen ? 0x34 : 0x30); - IO.Data0.Byte = (byte)(value & 0xFF); - IO.Data0.Byte = (byte)(value >> 8); - } + IOPort.Write8(Command, (byte)(T0RateGen ? 0x34 : 0x30)); + IOPort.Write8(Data0, (byte)(value & 0xFF)); + IOPort.Write8(Data0, (byte)(value >> 8)); + } } public uint T0Frequency { @@ -134,10 +150,10 @@ public ushort T2Countdown { _T2Countdown = value; - IO.Command.Byte = 0xB6; - IO.Data0.Byte = (byte)(value & 0xFF); - IO.Data0.Byte = (byte)(value >> 8); - } + IOPort.Write8(Command, 0xB6); + IOPort.Write8(Data0, (byte)(value & 0xFF)); + IOPort.Write8(Data0, (byte)(value >> 8)); + } } public uint T2Frequency { From 84d85644ef080038188c91cdede32b0750d73e54 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Tue, 26 Dec 2023 16:47:08 +0100 Subject: [PATCH 33/35] =?UTF-8?q?=F0=9F=90=9B=20Fix=20conflicts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/Cosmos.Core/ACPI.cs | 877 ++++++++++++++++++++++--------- source/Cosmos.Core/ACPI/ACPI.cs | 895 -------------------------------- source/Cosmos.Core/IOAPIC.cs | 6 +- source/Cosmos.Core/LocalAPIC.cs | 4 +- source/Cosmos.HAL2/APICTimer.cs | 14 +- source/Cosmos.HAL2/Global.cs | 22 +- 6 files changed, 676 insertions(+), 1142 deletions(-) delete mode 100644 source/Cosmos.Core/ACPI/ACPI.cs diff --git a/source/Cosmos.Core/ACPI.cs b/source/Cosmos.Core/ACPI.cs index 20e4ef9fd8..169e04d4e0 100644 --- a/source/Cosmos.Core/ACPI.cs +++ b/source/Cosmos.Core/ACPI.cs @@ -1,13 +1,49 @@ -using System; +using Cosmos.Debug.Kernel; +using System; +using System.Collections.Generic; +using System.IO; using System.Runtime.InteropServices; +using System.Text; namespace Cosmos.Core { + /// + /// PCI IRQ Routing information. + /// + public class IrqRouting + { + /// + /// The address of the PCI device. + /// + public uint Address; + + /// + /// The PCI pin number of the device. + /// + public byte Pin; + + /// + /// Source. + /// + public byte Source; + + /// + /// Source Index. + /// + public byte SourceIndex; + } + /// /// ACPI (Advanced Configuration and Power Interface) class. /// public unsafe class ACPI { + + /// + /// Debugger instance at the System ring, of the Global section. + /// + public static readonly Debugger debugger = new Debugger("Core"); + /// /// RSD table struct. /// @@ -18,29 +54,317 @@ public unsafe struct RSDPtr /// Signature. /// public fixed byte Signature[8]; + /// /// CheckSum /// public byte CheckSum; + /// /// OemID /// public fixed byte OemID[6]; + /// /// Revision /// public byte Revision; + /// /// RSDT Address /// public int RsdtAddress; }; - // New Port I/O + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct AcpiHeader + { + /// + /// Signature. + /// + public fixed byte Signature[4]; + + /// + /// Length. + /// + public uint Length; + + /// + /// Revision. + /// + public byte Revision; + + /// + /// Checksum. + /// + public byte Checksum; + + /// + /// OEM ID. + /// + public fixed byte OEMID[6]; + + /// + /// OEM Table ID. + /// + public fixed byte OEMTableID[8]; + + /// + /// OEM Revision. + /// + public uint OEMRevision; + + /// + /// CreatorID. + /// + public uint CreatorID; + + /// + /// Creator Revision. + /// + public uint CreatorRevision; + }; + + /// + /// FADT struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct FADTPtr + { + /// + /// ACPI Header. + /// + public AcpiHeader Header; + + /// + /// Firmware Control. + /// + public uint FirmwareCtrl; + + /// + /// DSDT Signature. + /// + public uint Dsdt; + + public byte Reserved; + public byte PreferredPowerManagementProfile; + public ushort SCI_Interrupt; + public uint SMI_CommandPort; + + /// + /// ACPI Enable. + /// + public byte AcpiEnable; + + /// + /// ACPI Disable. + /// + public byte AcpiDisable; + + public byte S4BIOS_REQ; + public byte PSTATE_Control; + public uint PM1aEventBlock; + public uint PM1bEventBlock; + public uint PM1aControlBlock; + public uint PM1bControlBlock; + public uint PM2ControlBlock; + public uint PMTimerBlock; + public uint GPE0Block; + public uint GPE1Block; + public byte PM1EventLength; + public byte PM1ControlLength; + public byte PM2ControlLength; + public byte PMTimerLength; + public byte GPE0Length; + public byte GPE1Length; + public byte GPE1Base; + public byte CStateControl; + public ushort WorstC2Latency; + public ushort WorstC3Latency; + public ushort FlushSize; + public ushort FlushStride; + public byte DutyOffset; + public byte DutyWidth; + public byte DayAlarm; + public byte MonthAlarm; + public byte Century; + + public ushort BootArchitectureFlags; + + public byte Reserved2; + public uint Flags; + + // 12 public byte structure; see below for details + public GenericAddressStructure ResetReg; + + public byte ResetValue; + public byte Reserved3; + public byte Reserved34; + public byte Reserved35; + + // 64bit pointers - Available on ACPI 2.0+ + public ulong X_FirmwareControl; + public ulong X_Dsdt; + + public GenericAddressStructure X_PM1aEventBlock; + public GenericAddressStructure X_PM1bEventBlock; + public GenericAddressStructure X_PM1aControlBlock; + public GenericAddressStructure X_PM1bControlBlock; + public GenericAddressStructure X_PM2ControlBlock; + public GenericAddressStructure X_PMTimerBlock; + public GenericAddressStructure X_GPE0Block; + public GenericAddressStructure X_GPE1Block; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct GenericAddressStructure + { + public byte AddressSpace; + public byte BitWidth; + public byte BitOffset; + public byte AccessSize; + public ulong Address; + }; + /// - /// IO port. + /// MADT struct. /// - private static ushort smiIO, pm1aIO, pm1bIO; + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct MADTPtr + { + /// + /// ACPI Header. + /// + public AcpiHeader Header; + + /// + /// Local APIC Address. + /// + public uint LocalAPICAddress; + + /// + /// Flags. + /// + public uint Flags; + } + + /// + /// APIC Header struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ApicHeader + { + /// + /// APIC Type. + /// + public ApicType Type; + + /// + /// Length. + /// + public byte Length; + } + + /// + /// APIC Type enum. + /// + public enum ApicType : byte + { + LocalAPIC, + IOAPIC, + InterruptOverride + } + + /// + /// ApicLocalApic struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + struct ApicLocalApic + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// ACPI Processor ID. + /// + public byte AcpiProcessorId; + + /// + /// APIC ID. + /// + public byte ApicId; + + /// + /// APIC Flags. + /// + public uint Flags; + } + + /// + /// ApicIOApic struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct ApicIOApic + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// APIC ID. + /// + public byte IOApicId; + + /// + /// Reserved. + /// + public byte Reserved; + + /// + /// IO APIC Base Address. + /// + public uint IOApicAddress; + + /// + /// Global System Interrupt Base Address. + /// + public uint GlobalSystemInterruptBase; + } + + /// + /// ApicInterruptOverride struct. + /// + [StructLayout(LayoutKind.Sequential, Pack = 1)] + struct ApicInterruptOverride + { + /// + /// APIC Header. + /// + public ApicHeader Header; + + /// + /// Bus. + /// + public byte Bus; + + /// + /// Source. + /// + public byte Source; + + /// + /// Interrupt. + /// + public uint Interrupt; + + /// + /// Floags. + /// + public ushort Flags; + } // ACPI variables /// @@ -56,6 +380,10 @@ public unsafe struct RSDPtr /// private static byte ACPI_DISABLE; /// + /// Reset value to write into reset register when you need to reboot + /// + private static byte ResetValue; + /// /// PM1a CNT /// private static int* PM1a_CNT; @@ -79,6 +407,30 @@ public unsafe struct RSDPtr /// PM1 CNT LEN1 /// private static byte PM1_CNT_LEN; + /// + /// Global MADT. + /// + public static MADTPtr* MADT; + /// + /// Global IO APIC. + /// + public static ApicIOApic* IOAPIC; + /// + /// FADT table + /// + public static FADTPtr* FADT; + + public static uint DSDTLenght = 0; + + /// + /// PCI IRQ Routing Table. + /// + public static List IrqRoutingTable; + + /// + /// PCI IRQ Routing Table. + /// + public static List LocalApicCpus; /// /// Check ACPI header. @@ -91,71 +443,6 @@ static int acpiCheckHeader(byte* ptr, string sig) return Compare(sig, ptr); } - /// - /// FACP. - /// - private static byte* Facp = null; - /// - /// FACP struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - struct FACP - { - /// - /// Signature. - /// - public fixed byte Signature[4]; - /// - /// Length. - /// - public int Length; - - /// - /// Unused. - /// - public fixed byte unneded1[40 - 8]; - /// - /// DSDT. - /// - public int* DSDT; - /// - /// Unused. - /// - public fixed byte unneded2[48 - 44]; - /// - /// SMI CMD. - /// - public int* SMI_CMD; - /// - /// ACPI ENABLE. - /// - public byte ACPI_ENABLE; - /// - /// ACPI DISABLE. - /// - public byte ACPI_DISABLE; - /// - /// Unused. - /// - public fixed byte unneded3[64 - 54]; - /// - /// PM1a CNT BLK. - /// - public int* PM1a_CNT_BLK; - /// - /// PM1b CNT BLK. - /// - public int* PM1b_CNT_BLK; - /// - /// Unused. - /// - public fixed byte unneded4[89 - 72]; - /// - /// PM1 CNT LEN. - /// - public byte PM1_CNT_LEN; - }; - /// /// Compare string to byte array. /// @@ -164,7 +451,7 @@ struct FACP /// 0 - identical, -1 different. static int Compare(string c1, byte* c2) { - for (int i = 0; i < c1.Length; i++) + for (var i = 0; i < c1.Length; i++) { if (c1[i] != c2[i]) { return -1; } } @@ -179,9 +466,9 @@ static int Compare(string c1, byte* c2) static bool Check_RSD(uint address) { byte sum = 0; - byte* check = (byte*)address; + var check = (byte*)address; - for (int i = 0; i < 20; i++) + for (var i = 0; i < 20; i++) { sum += *check++; } @@ -213,17 +500,16 @@ public static void Start(bool initialize = true, bool enable = true) /// Thrown on IO error. public static void Shutdown() { - Console.Clear(); if (PM1a_CNT == null) { Init(); } - IOPort.Write16(pm1aIO, (ushort)(SLP_TYPa | SLP_EN)); + IOPort.Write16((ushort)PM1a_CNT, (ushort)(SLP_TYPa | SLP_EN)); if (PM1b_CNT != null) { - IOPort.Write16(pm1bIO, (ushort)(SLP_TYPb | SLP_EN)); + IOPort.Write16((ushort)PM1b_CNT, (ushort)(SLP_TYPb | SLP_EN)); } CPU.Halt(); @@ -236,7 +522,22 @@ public static void Shutdown() /// Thrown always. public static void Reboot() { - throw new NotImplementedException("ACPI Reset not implemented yet."); //TODO + if (PM1a_CNT == null) + { + Init(); + } + + var header = FADT->Header; + if (header.Revision >= 2 && (FADT->Flags & (1 << 10)) != 0) + { + IOPort.Write16((ushort)FADT->ResetReg.Address, ResetValue); + } + else + { + throw new Exception("Hardware does not support ACPI reboot."); + } + + throw new Exception("ACPI reboot failed."); } /// @@ -245,106 +546,283 @@ public static void Reboot() /// true on success, false on failure. private static bool Init() { - byte* ptr = (byte*)RSDPAddress(); - int addr = 0; + IOAPIC = null; + IrqRoutingTable = new List(); + LocalApicCpus = new List(); + + var rsdp = RSDPAddress(); + var ptr = (byte*)rsdp; + + Global.debugger.Send("ACPI v" + rsdp->Revision); - for (int i = 19; i >= 16; i--) + var rsdt = (AcpiHeader*)rsdp->RsdtAddress; + ptr = (byte*)rsdt; + + var p = (uint*)(rsdt + 1); + var end = (uint*)((byte*)rsdt + rsdt->Length); + + while (p < end) { - addr += *(ptr + i); - addr = i == 16 ? addr : addr << 8; - } + var address = *p++; - ptr = (byte*)addr; - ptr += 4; addr = 0; + ParseDT((AcpiHeader*)address); + } - for (int i = 3; i >= 0; i--) + if (LocalApicCpus.Count > 0) { - addr += *(ptr + i); - addr = i == 0 ? addr : addr << 8; + Global.debugger.Send("Found " + LocalApicCpus.Count + " CPUs via MADT."); } - int length = addr; - ptr -= 4; + return true; + } + + private static uint SdtLength = 0; + + private static void ReadHeader(BinaryReader _reader) + { + Global.debugger.Send("SDT header:"); + + //Signature + Global.debugger.Send("\tSignature: " + Encoding.ASCII.GetString(_reader.ReadBytes(4))); + + //Length + SdtLength = _reader.ReadUInt32(); + Global.debugger.Send("\tLendth: " + SdtLength.ToString()); + + //Revision + Global.debugger.Send("\tRevision: " + _reader.ReadByte().ToString()); - if (ptr != null && acpiCheckHeader(ptr, "RSDT") == 0) + //Checksum + Global.debugger.Send("\tChecksum: " + _reader.ReadByte().ToString()); + + //OEM ID + Global.debugger.Send("\tOEM ID: " + Encoding.ASCII.GetString(_reader.ReadBytes(6))); + + //OEMTableID + Global.debugger.Send("\tOEMTableID: " + Encoding.ASCII.GetString(_reader.ReadBytes(8))); + + //OEMRevision + Global.debugger.Send("\tOEMRevision: " + _reader.ReadUInt32().ToString()); + + //OEMRevision + Global.debugger.Send("\tCreatorID: " + _reader.ReadUInt32().ToString()); + + //OEMRevision + Global.debugger.Send("\tCreatorRevision: " + _reader.ReadUInt32().ToString()); + } + + private static void ParseS5() + { + byte* S5Addr = (byte*)FADT->Dsdt; + + while (0 < DSDTLenght--) { - addr = 0; - int entrys = length; - entrys = (entrys - 36) / 4; - ptr += 36; - byte* yeuse; + if (Compare("_S5_", S5Addr) == 0) + { + break; + } + S5Addr++; + } - while (0 < entrys--) + if (DSDTLenght > 0) + { + if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) { - for (int i = 3; i >= 0; i--) + S5Addr += 5; + S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; + if (*S5Addr == 0x0A) + { + S5Addr++; + } + SLP_TYPa = (short)(*(S5Addr) << 10); + S5Addr++; + if (*S5Addr == 0x0A) { - addr += *(ptr + i); - addr = i == 0 ? addr : addr << 8; + S5Addr++; } + SLP_TYPb = (short)(*(S5Addr) << 10); + + Global.debugger.Send("SLP_TYPa=" + SLP_TYPa); + Global.debugger.Send("SLP_TYPb=" + SLP_TYPb); + } + } + } + + private static void ParsePRT() + { + /* + if (DSDTLenght > 0) + { + var dsdtBlock = new MemoryBlock08(FADT->Dsdt + (uint)sizeof(AcpiHeader), SdtLength - (uint)sizeof(AcpiHeader)); - yeuse = (byte*)addr; - Facp = yeuse; + Stream stream = new MemoryStream(dsdtBlock.ToArray()); - if (acpiCheckHeader((byte*)facpget(0), "DSDT") == 0) + Global.debugger.Send("Create parser..."); + + var root = new Parser(stream); + + Global.debugger.Send("Parse first node..."); + + var node = root.Parse(); + foreach (var item in node.Nodes) + { + Global.debugger.Send("Node: " + item.Name); + } + }*/ + } + + private static void ParseDT(AcpiHeader* hdr) + { + var signature = Encoding.ASCII.GetString(hdr->Signature, 4); + + Global.debugger.Send(signature + " detected"); + + if (signature == "FACP") + { + Global.debugger.Send("Parse FACP"); + + FADT = (FADTPtr*)hdr; + + SMI_CMD = (int*)FADT->SMI_CommandPort; + ACPI_ENABLE = FADT->AcpiEnable; + ACPI_DISABLE = FADT->AcpiDisable; + PM1a_CNT = (int*)FADT->PM1aControlBlock; + PM1b_CNT = (int*)FADT->PM1bControlBlock; + PM1_CNT_LEN = FADT->PM1ControlLength; + SLP_EN = 1 << 13; + + + if (acpiCheckHeader((byte*)FADT->Dsdt, "DSDT") == 0) + { + uint dsdtAddress = FADT->Dsdt; + uint dsdtLength = (uint)(*((int*)FADT->Dsdt + 1) - sizeof(AcpiHeader)); + + var dsdtHeader = new MemoryBlock08(dsdtAddress, 36); + var _reader = new BinaryReader(new MemoryStream(dsdtHeader.ToArray())); + + ReadHeader(_reader); + + Global.debugger.Send("Parsing _S5..."); + + ParseS5(); + + Global.debugger.Send("Parsing _PRT..."); + + ParsePRT(); + } + } + else if (signature == "APIC") + { + Global.debugger.Send("Parse APIC"); + + MADT = (MADTPtr*)hdr; + + var p = (byte*)(MADT + 1); + var end = (byte*)MADT + MADT->Header.Length; + while (p < end) + { + var header = (ApicHeader*)p; + var type = header->Type; + var length = header->Length; + + if (type == ApicType.LocalAPIC) { - byte* S5Addr = (byte*)facpget(0) + 36; - int dsdtLength = *(facpget(0) + 1) - 36; + var pic = (ApicLocalApic*)p; - while (0 < dsdtLength--) + if (((pic->Flags & 1) ^ ((pic->Flags >> 1) & 1)) != 0) { - if (Compare("_S5_", S5Addr) == 0) - { - break; - } - S5Addr++; - } + LocalApicCpus.Add(pic->ApicId); - if (dsdtLength > 0) + Global.debugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); + } + } + else if (type == ApicType.IOAPIC) + { + var ioapic = (ApicIOApic*)p; + if (IOAPIC == null) { - if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) - { - S5Addr += 5; - S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPa = (short)(*S5Addr << 10); - S5Addr++; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPb = (short)(*S5Addr << 10); - SMI_CMD = facpget(1); - ACPI_ENABLE = facpbget(0); - ACPI_DISABLE = facpbget(1); - PM1a_CNT = facpget(2); - PM1b_CNT = facpget(3); - PM1_CNT_LEN = facpbget(3); - SLP_EN = 1 << 13; - - smiIO = (ushort)SMI_CMD; - pm1aIO = (ushort)PM1a_CNT; - pm1bIO = (ushort)PM1b_CNT; - - return true; - } + IOAPIC = ioapic; } + Global.debugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + " (Address:0x" + ((ulong)ioapic->IOApicAddress).ToString("X") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); } - ptr += 4; + else if (type == ApicType.InterruptOverride) + { + var ovr = (ApicInterruptOverride*)p; + + Global.debugger.Send("Found APIC Interrupt Override (Bus: " + ((ulong)ovr->Bus).ToString() + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:0x" + ((ulong)ovr->Interrupt).ToString("X") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); + } + + p += length; } } + } + + /* + private static void PopulateNode(ParseNode op) + { + //Recursive function does a null reference exception trick the matrice with a Stack and iterative function + var sthack = new Stack(); + + sthack.Push(op); + + while (sthack.Count != 0) + { + ParseNode current = sthack.Pop(); + + if (current.Arguments.Count > 0) + { + SearchPackage(current); + } - return false; + if (current != null) + { + for (int i = current.Nodes.Count - 1; i >= 0; i--) + { + sthack.Push(current.Nodes[i]); + } + } + } } + + private static void SearchPackage(ParseNode op) + { + for (int x = 0; x < op.Op.ParseArgs.Length; x++) + { + if (op.Op.ParseArgs[x] == ParseArgFlags.DataObjectList || op.Op.ParseArgs[x] == ParseArgFlags.TermList || op.Op.ParseArgs[x] == ParseArgFlags.ObjectList) + continue; + + if (op.Arguments[x].ToString() == "Package") + { + Global.debugger.Send("Package found!"); + + //var arg = (ParseNode)op.Arguments[x]; + + /* + for (int y = 0; y < arg.Nodes.Count; y++) + { + List package = arg.Nodes[y].Nodes; + + var irqRouting = new IrqRouting() + { + Address = (uint)package[0].ConstantValue, + Pin = (byte)package[1].ConstantValue, + Source = (byte)package[2].ConstantValue, + SourceIndex = (byte)package[3].ConstantValue + }; + + IrqRoutingTable.Add(irqRouting); + } + + } + } + }*/ + /// /// Enable ACPI. /// public static void Enable() { - smiIO = ACPI_ENABLE; } /// @@ -352,14 +830,13 @@ public static void Enable() /// public static void Disable() { - smiIO = ACPI_DISABLE; } /// /// Get the RSDP address. /// /// uint value. - private static unsafe uint RSDPAddress() + private static unsafe RSDPtr* RSDPAddress() { for (uint addr = 0xE0000; addr < 0x100000; addr += 4) { @@ -367,118 +844,52 @@ private static unsafe uint RSDPAddress() { if (Check_RSD(addr)) { - return addr; + return (RSDPtr*)addr; } } } - uint ebda_address = *(uint*)0x040E; - ebda_address = (ebda_address * 0x10) & 0x000fffff; + var ebda_address = *(uint*)0x040E; + ebda_address = ebda_address * 0x10 & 0x000fffff; - for (uint addr = ebda_address; addr < ebda_address + 1024; addr += 4) + for (var addr = ebda_address; addr < ebda_address + 1024; addr += 4) { if (Compare("RSD PTR ", (byte*)addr) == 0) { - return addr; + return (RSDPtr*)addr; } } - return 0; + return null; } - /// - /// Check RSDT table - /// - /// A pointer to the RSDT - /// RSDT table address - private static uint* acpiCheckRSDPtr(uint* ptr) + public static uint RemapIRQ(uint irq) { - string sig = "RSD PTR "; - var rsdp = (RSDPtr*)ptr; + var p = (byte*)(MADT + 1); + var end = (byte*)MADT + MADT->Header.Length; - byte* bptr; - byte check = 0; - int i; - - if (Compare(sig, (byte*)rsdp) == 0) + while (p < end) { - bptr = (byte*)ptr; + var header = (ApicHeader*)p; + var type = header->Type; + var length = header->Length; - for (i = 0; i < 20; i++) + if (type == ApicType.InterruptOverride) { - check += *bptr; - bptr++; - } + var ovr = (ApicInterruptOverride*)p; - if (check == 0) - { - Compare("RSDT", (byte*)rsdp->RsdtAddress); - - if (rsdp->RsdtAddress != 0) + if (ovr->Source == irq) { - return (uint*)rsdp->RsdtAddress; + Global.debugger.Send("IRQ" + irq + " remapped to IRQ" + ovr->Interrupt); + + return ovr->Interrupt; } } - } - - return null; - } - /// - /// Get data from the FACP table. - /// - /// Index number of the data to get. - /// - /// 0 - ACPI ENABLE - /// 1 - ACPI DISABLE - /// 2 - PM1 CNT LEN - /// other - 0 - /// - /// - /// byte value. - private static byte facpbget(int number) - { - switch (number) - { - case 0: - return *(Facp + 52); - case 1: - return *(Facp + 53); - case 2: - return *(Facp + 89); - default: - return 0; + p += length; } - } - /// - /// Get pointer to the data on the FACP. - /// - /// Index number of the data to get. - /// - /// 0 - DSDT - /// 1 - SMI CMD - /// 2 - PM1a - /// 3 - PM1b - /// other - null - /// - /// - /// int pointer. - private static int* facpget(int number) - { - switch (number) - { - case 0: - return (int*)*(int*)(Facp + 40); - case 1: - return (int*)*(int*)(Facp + 48); - case 2: - return (int*)*(int*)(Facp + 64); - case 3: - return (int*)*(int*)(Facp + 68); - default: - return null; - } + return irq; } } } \ No newline at end of file diff --git a/source/Cosmos.Core/ACPI/ACPI.cs b/source/Cosmos.Core/ACPI/ACPI.cs deleted file mode 100644 index e94e19a3ce..0000000000 --- a/source/Cosmos.Core/ACPI/ACPI.cs +++ /dev/null @@ -1,895 +0,0 @@ -using Cosmos.Debug.Kernel; -using System; -using System.Collections.Generic; -using System.IO; -using System.Runtime.InteropServices; -using System.Text; - -namespace Cosmos.Core -{ - /// - /// PCI IRQ Routing information. - /// - public class IrqRouting - { - /// - /// The address of the PCI device. - /// - public uint Address; - - /// - /// The PCI pin number of the device. - /// - public byte Pin; - - /// - /// Source. - /// - public byte Source; - - /// - /// Source Index. - /// - public byte SourceIndex; - } - - /// - /// ACPI (Advanced Configuration and Power Interface) class. - /// - public unsafe class ACPI - { - - /// - /// Debugger instance at the System ring, of the Global section. - /// - public static readonly Debugger mDebugger = new Debugger("System", "Global"); - - /// - /// RSD table struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public unsafe struct RSDPtr - { - /// - /// Signature. - /// - public fixed byte Signature[8]; - - /// - /// CheckSum - /// - public byte CheckSum; - - /// - /// OemID - /// - public fixed byte OemID[6]; - - /// - /// Revision - /// - public byte Revision; - - /// - /// RSDT Address - /// - public int RsdtAddress; - }; - - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct AcpiHeader - { - /// - /// Signature. - /// - public fixed byte Signature[4]; - - /// - /// Length. - /// - public uint Length; - - /// - /// Revision. - /// - public byte Revision; - - /// - /// Checksum. - /// - public byte Checksum; - - /// - /// OEM ID. - /// - public fixed byte OEMID[6]; - - /// - /// OEM Table ID. - /// - public fixed byte OEMTableID[8]; - - /// - /// OEM Revision. - /// - public uint OEMRevision; - - /// - /// CreatorID. - /// - public uint CreatorID; - - /// - /// Creator Revision. - /// - public uint CreatorRevision; - }; - - /// - /// FADT struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct FADTPtr - { - /// - /// ACPI Header. - /// - public AcpiHeader Header; - - /// - /// Firmware Control. - /// - public uint FirmwareCtrl; - - /// - /// DSDT Signature. - /// - public uint Dsdt; - - public byte Reserved; - public byte PreferredPowerManagementProfile; - public ushort SCI_Interrupt; - public uint SMI_CommandPort; - - /// - /// ACPI Enable. - /// - public byte AcpiEnable; - - /// - /// ACPI Disable. - /// - public byte AcpiDisable; - - public byte S4BIOS_REQ; - public byte PSTATE_Control; - public uint PM1aEventBlock; - public uint PM1bEventBlock; - public uint PM1aControlBlock; - public uint PM1bControlBlock; - public uint PM2ControlBlock; - public uint PMTimerBlock; - public uint GPE0Block; - public uint GPE1Block; - public byte PM1EventLength; - public byte PM1ControlLength; - public byte PM2ControlLength; - public byte PMTimerLength; - public byte GPE0Length; - public byte GPE1Length; - public byte GPE1Base; - public byte CStateControl; - public ushort WorstC2Latency; - public ushort WorstC3Latency; - public ushort FlushSize; - public ushort FlushStride; - public byte DutyOffset; - public byte DutyWidth; - public byte DayAlarm; - public byte MonthAlarm; - public byte Century; - - public ushort BootArchitectureFlags; - - public byte Reserved2; - public uint Flags; - - // 12 public byte structure; see below for details - public GenericAddressStructure ResetReg; - - public byte ResetValue; - public byte Reserved3; - public byte Reserved34; - public byte Reserved35; - - // 64bit pointers - Available on ACPI 2.0+ - public ulong X_FirmwareControl; - public ulong X_Dsdt; - - public GenericAddressStructure X_PM1aEventBlock; - public GenericAddressStructure X_PM1bEventBlock; - public GenericAddressStructure X_PM1aControlBlock; - public GenericAddressStructure X_PM1bControlBlock; - public GenericAddressStructure X_PM2ControlBlock; - public GenericAddressStructure X_PMTimerBlock; - public GenericAddressStructure X_GPE0Block; - public GenericAddressStructure X_GPE1Block; - } - - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct GenericAddressStructure - { - public byte AddressSpace; - public byte BitWidth; - public byte BitOffset; - public byte AccessSize; - public ulong Address; - }; - - /// - /// MADT struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct MADTPtr - { - /// - /// ACPI Header. - /// - public AcpiHeader Header; - - /// - /// Local APIC Address. - /// - public uint LocalAPICAddress; - - /// - /// Flags. - /// - public uint Flags; - } - - /// - /// APIC Header struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct ApicHeader - { - /// - /// APIC Type. - /// - public ApicType Type; - - /// - /// Length. - /// - public byte Length; - } - - /// - /// APIC Type enum. - /// - public enum ApicType : byte - { - LocalAPIC, - IOAPIC, - InterruptOverride - } - - /// - /// ApicLocalApic struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - struct ApicLocalApic - { - /// - /// APIC Header. - /// - public ApicHeader Header; - - /// - /// ACPI Processor ID. - /// - public byte AcpiProcessorId; - - /// - /// APIC ID. - /// - public byte ApicId; - - /// - /// APIC Flags. - /// - public uint Flags; - } - - /// - /// ApicIOApic struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - public struct ApicIOApic - { - /// - /// APIC Header. - /// - public ApicHeader Header; - - /// - /// APIC ID. - /// - public byte IOApicId; - - /// - /// Reserved. - /// - public byte Reserved; - - /// - /// IO APIC Base Address. - /// - public uint IOApicAddress; - - /// - /// Global System Interrupt Base Address. - /// - public uint GlobalSystemInterruptBase; - } - - /// - /// ApicInterruptOverride struct. - /// - [StructLayout(LayoutKind.Sequential, Pack = 1)] - struct ApicInterruptOverride - { - /// - /// APIC Header. - /// - public ApicHeader Header; - - /// - /// Bus. - /// - public byte Bus; - - /// - /// Source. - /// - public byte Source; - - /// - /// Interrupt. - /// - public uint Interrupt; - - /// - /// Floags. - /// - public ushort Flags; - } - - // ACPI variables - /// - /// SMI CMD. - /// - private static int* SMI_CMD; - /// - /// ACPI ENABLE. - /// - private static byte ACPI_ENABLE; - /// - /// ACPI DISABLE. - /// - private static byte ACPI_DISABLE; - /// - /// Reset value to write into reset register when you need to reboot - /// - private static byte ResetValue; - /// - /// PM1a CNT - /// - private static int* PM1a_CNT; - /// - /// PM1b CNT - /// - private static int* PM1b_CNT; - /// - /// SLP TYPa - /// - private static short SLP_TYPa; - /// - /// SLP TYPb - /// - private static short SLP_TYPb; - /// - /// SLP EN. - /// - private static short SLP_EN; - /// - /// PM1 CNT LEN1 - /// - private static byte PM1_CNT_LEN; - /// - /// Global MADT. - /// - public static MADTPtr* MADT; - /// - /// Global IO APIC. - /// - public static ApicIOApic* IOAPIC; - /// - /// FADT table - /// - public static FADTPtr* FADT; - - public static uint DSDTLenght = 0; - - /// - /// PCI IRQ Routing Table. - /// - public static List IrqRoutingTable; - - /// - /// PCI IRQ Routing Table. - /// - public static List LocalApicCpus; - - /// - /// Check ACPI header. - /// - /// - /// - /// - static int acpiCheckHeader(byte* ptr, string sig) - { - return Compare(sig, ptr); - } - - /// - /// Compare string to byte array. - /// - /// String. - /// Pointer to the head of the byte array. - /// 0 - identical, -1 different. - static int Compare(string c1, byte* c2) - { - for (var i = 0; i < c1.Length; i++) - { - if (c1[i] != c2[i]) { return -1; } - } - return 0; - } - - /// - /// Check RSD checksum. - /// - /// Address to check. - /// True if RSDT table checksum is good. - static bool Check_RSD(uint address) - { - byte sum = 0; - var check = (byte*)address; - - for (var i = 0; i < 20; i++) - { - sum += *check++; - } - - return sum == 0; - } - - /// - /// Start the ACPI. - /// - /// Initialize the ACPI. (default = true) - /// Enable the ACPI. (default = true) - public static void Start(bool initialize = true, bool enable = true) - { - if (initialize) - { - Init(); - } - - if (enable) - { - Enable(); - } - } - - /// - /// Shutdown the ACPI. - /// - /// Thrown on IO error. - public static void Shutdown() - { - if (PM1a_CNT == null) - { - Init(); - } - - IOPort.Write16((ushort)PM1a_CNT, (ushort)(SLP_TYPa | SLP_EN)); - - if (PM1b_CNT != null) - { - IOPort.Write16((ushort)PM1b_CNT, (ushort)(SLP_TYPb | SLP_EN)); - } - - CPU.Halt(); - } - - /// - /// Reboot ACPI. - /// Not implemented. - /// - /// Thrown always. - public static void Reboot() - { - if (PM1a_CNT == null) - { - Init(); - } - - var header = FADT->Header; - if (header.Revision >= 2 && (FADT->Flags & (1 << 10)) != 0) - { - IOPort.Write16((ushort)FADT->ResetReg.Address, ResetValue); - } - else - { - throw new Exception("Hardware does not support ACPI reboot."); - } - - throw new Exception("ACPI reboot failed."); - } - - /// - /// Initialize the ACPI. - /// - /// true on success, false on failure. - private static bool Init() - { - IOAPIC = null; - IrqRoutingTable = new List(); - LocalApicCpus = new List(); - - var rsdp = RSDPAddress(); - var ptr = (byte*)rsdp; - - Global.mDebugger.Send("ACPI v" + rsdp->Revision); - - var rsdt = (AcpiHeader*)rsdp->RsdtAddress; - ptr = (byte*)rsdt; - - var p = (uint*)(rsdt + 1); - var end = (uint*)((byte*)rsdt + rsdt->Length); - - while (p < end) - { - var address = *p++; - - ParseDT((AcpiHeader*)address); - } - - if (LocalApicCpus.Count > 0) - { - Global.mDebugger.Send("Found " + LocalApicCpus.Count + " CPUs via MADT."); - } - - return true; - } - - private static uint SdtLength = 0; - - private static void ReadHeader(BinaryReader _reader) - { - Global.mDebugger.Send("SDT header:"); - - //Signature - Global.mDebugger.Send("\tSignature: " + Encoding.ASCII.GetString(_reader.ReadBytes(4))); - - //Length - SdtLength = _reader.ReadUInt32(); - Global.mDebugger.Send("\tLendth: " + SdtLength.ToString()); - - //Revision - Global.mDebugger.Send("\tRevision: " + _reader.ReadByte().ToString()); - - //Checksum - Global.mDebugger.Send("\tChecksum: " + _reader.ReadByte().ToString()); - - //OEM ID - Global.mDebugger.Send("\tOEM ID: " + Encoding.ASCII.GetString(_reader.ReadBytes(6))); - - //OEMTableID - Global.mDebugger.Send("\tOEMTableID: " + Encoding.ASCII.GetString(_reader.ReadBytes(8))); - - //OEMRevision - Global.mDebugger.Send("\tOEMRevision: " + _reader.ReadUInt32().ToString()); - - //OEMRevision - Global.mDebugger.Send("\tCreatorID: " + _reader.ReadUInt32().ToString()); - - //OEMRevision - Global.mDebugger.Send("\tCreatorRevision: " + _reader.ReadUInt32().ToString()); - } - - private static void ParseS5() - { - byte* S5Addr = (byte*)FADT->Dsdt; - - while (0 < DSDTLenght--) - { - if (Compare("_S5_", S5Addr) == 0) - { - break; - } - S5Addr++; - } - - if (DSDTLenght > 0) - { - if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12) - { - S5Addr += 5; - S5Addr += ((*S5Addr & 0xC0) >> 6) + 2; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPa = (short)(*(S5Addr) << 10); - S5Addr++; - if (*S5Addr == 0x0A) - { - S5Addr++; - } - SLP_TYPb = (short)(*(S5Addr) << 10); - - Global.mDebugger.Send("SLP_TYPa=" + SLP_TYPa); - Global.mDebugger.Send("SLP_TYPb=" + SLP_TYPb); - } - } - } - - private static void ParsePRT() - { - /* - if (DSDTLenght > 0) - { - var dsdtBlock = new MemoryBlock08(FADT->Dsdt + (uint)sizeof(AcpiHeader), SdtLength - (uint)sizeof(AcpiHeader)); - - Stream stream = new MemoryStream(dsdtBlock.ToArray()); - - Global.mDebugger.Send("Create parser..."); - - var root = new Parser(stream); - - Global.mDebugger.Send("Parse first node..."); - - var node = root.Parse(); - foreach (var item in node.Nodes) - { - Global.mDebugger.Send("Node: " + item.Name); - } - }*/ - } - - private static void ParseDT(AcpiHeader* hdr) - { - var signature = Encoding.ASCII.GetString(hdr->Signature, 4); - - Global.mDebugger.Send(signature + " detected"); - - if (signature == "FACP") - { - Global.mDebugger.Send("Parse FACP"); - - FADT = (FADTPtr*)hdr; - - SMI_CMD = (int*)FADT->SMI_CommandPort; - ACPI_ENABLE = FADT->AcpiEnable; - ACPI_DISABLE = FADT->AcpiDisable; - PM1a_CNT = (int*)FADT->PM1aControlBlock; - PM1b_CNT = (int*)FADT->PM1bControlBlock; - PM1_CNT_LEN = FADT->PM1ControlLength; - SLP_EN = 1 << 13; - - - if (acpiCheckHeader((byte*)FADT->Dsdt, "DSDT") == 0) - { - uint dsdtAddress = FADT->Dsdt; - uint dsdtLength = (uint)(*((int*)FADT->Dsdt + 1) - sizeof(AcpiHeader)); - - var dsdtHeader = new MemoryBlock08(dsdtAddress, 36); - var _reader = new BinaryReader(new MemoryStream(dsdtHeader.ToArray())); - - ReadHeader(_reader); - - Global.mDebugger.Send("Parsing _S5..."); - - ParseS5(); - - Global.mDebugger.Send("Parsing _PRT..."); - - ParsePRT(); - } - } - else if (signature == "APIC") - { - Global.mDebugger.Send("Parse APIC"); - - MADT = (MADTPtr*)hdr; - - var p = (byte*)(MADT + 1); - var end = (byte*)MADT + MADT->Header.Length; - while (p < end) - { - var header = (ApicHeader*)p; - var type = header->Type; - var length = header->Length; - - if (type == ApicType.LocalAPIC) - { - var pic = (ApicLocalApic*)p; - - if (((pic->Flags & 1) ^ ((pic->Flags >> 1) & 1)) != 0) - { - LocalApicCpus.Add(pic->ApicId); - - Global.mDebugger.Send("Found APIC " + (ulong)pic->ApicId + " (Processor ID:" + pic->AcpiProcessorId + ")"); - } - } - else if (type == ApicType.IOAPIC) - { - var ioapic = (ApicIOApic*)p; - if (IOAPIC == null) - { - IOAPIC = ioapic; - } - Global.mDebugger.Send("Found IO APIC " + (ulong)ioapic->IOApicId + " (Address:0x" + ((ulong)ioapic->IOApicAddress).ToString("X") + ", GSIB:" + (ulong)ioapic->GlobalSystemInterruptBase + ")"); - } - else if (type == ApicType.InterruptOverride) - { - var ovr = (ApicInterruptOverride*)p; - - Global.mDebugger.Send("Found APIC Interrupt Override (Bus: " + ((ulong)ovr->Bus).ToString() + ", Source:" + ((ulong)ovr->Source).ToString() + ", Interrupt:0x" + ((ulong)ovr->Interrupt).ToString("X") + ", Flags:" + ((ulong)ovr->Flags).ToString() + ")"); - } - - p += length; - } - } - } - - /* - private static void PopulateNode(ParseNode op) - { - //Recursive function does a null reference exception trick the matrice with a Stack and iterative function - var sthack = new Stack(); - - sthack.Push(op); - - while (sthack.Count != 0) - { - ParseNode current = sthack.Pop(); - - if (current.Arguments.Count > 0) - { - SearchPackage(current); - } - - if (current != null) - { - for (int i = current.Nodes.Count - 1; i >= 0; i--) - { - sthack.Push(current.Nodes[i]); - } - } - } - } - - - private static void SearchPackage(ParseNode op) - { - for (int x = 0; x < op.Op.ParseArgs.Length; x++) - { - if (op.Op.ParseArgs[x] == ParseArgFlags.DataObjectList || op.Op.ParseArgs[x] == ParseArgFlags.TermList || op.Op.ParseArgs[x] == ParseArgFlags.ObjectList) - continue; - - if (op.Arguments[x].ToString() == "Package") - { - Global.mDebugger.Send("Package found!"); - - //var arg = (ParseNode)op.Arguments[x]; - - /* - for (int y = 0; y < arg.Nodes.Count; y++) - { - List package = arg.Nodes[y].Nodes; - - var irqRouting = new IrqRouting() - { - Address = (uint)package[0].ConstantValue, - Pin = (byte)package[1].ConstantValue, - Source = (byte)package[2].ConstantValue, - SourceIndex = (byte)package[3].ConstantValue - }; - - IrqRoutingTable.Add(irqRouting); - } - - } - } - }*/ - - /// - /// Enable ACPI. - /// - public static void Enable() - { - } - - /// - /// Disable ACPI. - /// - public static void Disable() - { - } - - /// - /// Get the RSDP address. - /// - /// uint value. - private static unsafe RSDPtr* RSDPAddress() - { - for (uint addr = 0xE0000; addr < 0x100000; addr += 4) - { - if (Compare("RSD PTR ", (byte*)addr) == 0) - { - if (Check_RSD(addr)) - { - return (RSDPtr*)addr; - } - } - } - - var ebda_address = *(uint*)0x040E; - ebda_address = ebda_address * 0x10 & 0x000fffff; - - for (var addr = ebda_address; addr < ebda_address + 1024; addr += 4) - { - if (Compare("RSD PTR ", (byte*)addr) == 0) - { - return (RSDPtr*)addr; - } - } - - return null; - } - - public static uint RemapIRQ(uint irq) - { - var p = (byte*)(MADT + 1); - var end = (byte*)MADT + MADT->Header.Length; - - while (p < end) - { - var header = (ApicHeader*)p; - var type = header->Type; - var length = header->Length; - - if (type == ApicType.InterruptOverride) - { - var ovr = (ApicInterruptOverride*)p; - - if (ovr->Source == irq) - { - Global.mDebugger.Send("IRQ" + irq + " remapped to IRQ" + ovr->Interrupt); - - return ovr->Interrupt; - } - } - - p += length; - } - - return irq; - } - } -} diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index b9174fa29b..d02e797fe0 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -42,12 +42,12 @@ public static void Initialize() Address = ACPI.IOAPIC->IOApicAddress; } - Global.mDebugger.Send("IO APIC address:0x" + Address.ToString("X")); + Global.debugger.Send("IO APIC address:0x" + Address.ToString("X")); uint x = In(IOAPICVER); uint count = ((x >> 16) & 0xFF) + 1; - Global.mDebugger.Send("IO APIC pins:" + count); + Global.debugger.Send("IO APIC pins:" + count); //Disable All Entries, Make all interrupts edge triggered and not routed to any CPUs for (uint i = 0; i < count; ++i) @@ -55,7 +55,7 @@ public static void Initialize() SetEntry((byte)i, (1 << 16) | 0x20 + i); } - Global.mDebugger.Send("IO APIC " + GetId() + " Initialized"); + Global.debugger.Send("IO APIC " + GetId() + " Initialized"); } /// diff --git a/source/Cosmos.Core/LocalAPIC.cs b/source/Cosmos.Core/LocalAPIC.cs index 65f4043cc4..25b1a3cbef 100644 --- a/source/Cosmos.Core/LocalAPIC.cs +++ b/source/Cosmos.Core/LocalAPIC.cs @@ -87,7 +87,7 @@ public static void Initialize() Address = ACPI.MADT->LocalAPICAddress; } - Global.mDebugger.Send("Local APIC address:0x" + Address.ToString("X")); + Global.debugger.Send("Local APIC address:0x" + Address.ToString("X")); //Enable All Interrupts Out(LAPIC_TPR, 0); @@ -106,7 +106,7 @@ public static void Initialize() // accept all level of interrupts Out(LAPIC_TPR, 0); - Global.mDebugger.Send("Local APIC " + GetId() + " initialized"); + Global.debugger.Send("Local APIC " + GetId() + " initialized"); } /// diff --git a/source/Cosmos.HAL2/APICTimer.cs b/source/Cosmos.HAL2/APICTimer.cs index 910dad716b..2945d5a57b 100644 --- a/source/Cosmos.HAL2/APICTimer.cs +++ b/source/Cosmos.HAL2/APICTimer.cs @@ -28,7 +28,7 @@ public static class APICTimer /// public static void Initialize() { - INTs.SetIntHandler(0x20, HandleApicTimer); + INTs.SetIntHandler(0x21, HandleApicTimer); // setup timer, Intel IA manual 10-16 Vol. 3A LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); // divide timer counts by 1 @@ -40,15 +40,15 @@ public static void Initialize() throw new Exception("APIC timer is not calibrated"); } - LocalAPIC.Out(LocalAPIC.LAPIC_TIMER, 0x20000 | 0x20); // periodic, bind to corresponding IRQ + LocalAPIC.Out(LocalAPIC.LAPIC_TIMER, 0x20000 | 0x21); // periodic, bind to corresponding IRQ LocalAPIC.Out(LocalAPIC.LAPIC_TDCR, 0xB); - Global.mDebugger.Send("Local APIC Timer Initialized"); + Global.debugger.Send("Local APIC Timer Initialized"); } public static void HandleApicTimer(ref INTs.IRQContext aContext) { - Global.mDebugger.Send("APIC Timer IRQ"); + Global.debugger.Send("APIC Timer IRQ"); //Tick++; } @@ -72,7 +72,7 @@ public static void SetTimerCount(uint count) public static void Calibrate() { - Global.mDebugger.Send("Calibrating APIC timer..."); + Global.debugger.Send("Calibrating APIC timer..."); SetTimerCount(0xFFFFFFFF); // Set APIC init counter to -1 @@ -82,11 +82,11 @@ public static void Calibrate() ulong ticks = 0xFFFFFFFF - LocalAPIC.In(LocalAPIC.LAPIC_TCCR); // Now we know how often the APIC timer has ticked in 10ms - Global.mDebugger.Send("APIC timer ticks per 10ms: " + ticks); + Global.debugger.Send("APIC timer ticks per 10ms: " + ticks); TickFrequency = (uint)(ticks * 1000 / 1000); - Global.mDebugger.Send("APIC timer tick frequency: " + TickFrequency); + Global.debugger.Send("APIC timer tick frequency: " + TickFrequency); } } } diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index c088298b5b..72e6aa3060 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -12,13 +12,13 @@ public static class Global { public static readonly Debugger debugger = new("Global"); - public static PIT PIT = new(); + public static PIT PIT; // Must be static init, other static inits rely on it not being null public static TextScreenBase TextScreen = new TextScreen(); public static PCI Pci; - public static readonly PS2Controller PS2Controller = new(); + public static readonly PS2Controller PS2Controller; // TODO: continue adding exceptions to the list, as HAL and Core would be documented. /// @@ -33,9 +33,27 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In TextScreen = textScreen; } + Console.Clear(); + debugger.Send("Before Core.Global.Init"); Core.Global.Init(); + Console.WriteLine("Starting ACPI"); + debugger.Send("ACPI Init"); + ACPI.Start(); + + Console.WriteLine("Starting APIC"); + debugger.Send("Local APIC Init"); + LocalAPIC.Initialize(); + debugger.Send("IO APIC Init"); + IOAPIC.Initialize(); + + Console.WriteLine("Starting PIT"); + PIT = new PIT(); + + debugger.Send("Local APIC Timer Init"); + APICTimer.Initialize(); + //TODO Redo this - Global init should be other. // Move PCI detection to hardware? Or leave it in core? Is Core PC specific, or deeper? // If we let hardware do it, we need to protect it from being used by System. From 757da7b43933f2b641d43db8db08c03f296d3a19 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Tue, 26 Dec 2023 16:51:47 +0100 Subject: [PATCH 34/35] =?UTF-8?q?=F0=9F=90=9B=20Fix=20boot=20(NRE=20on=20P?= =?UTF-8?q?S/2=20keyboard)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/Cosmos.HAL2/Global.cs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/source/Cosmos.HAL2/Global.cs b/source/Cosmos.HAL2/Global.cs index 72e6aa3060..098b55b960 100644 --- a/source/Cosmos.HAL2/Global.cs +++ b/source/Cosmos.HAL2/Global.cs @@ -18,7 +18,7 @@ public static class Global public static TextScreenBase TextScreen = new TextScreen(); public static PCI Pci; - public static readonly PS2Controller PS2Controller; + public static PS2Controller PS2Controller; // TODO: continue adding exceptions to the list, as HAL and Core would be documented. /// @@ -68,16 +68,13 @@ static public void Init(TextScreenBase textScreen, bool InitScrollWheel, bool In debugger.Send("PCI Devices"); PCI.Setup(); - Console.WriteLine("Starting ACPI"); - debugger.Send("ACPI Init"); - ACPI.Start(); - // http://wiki.osdev.org/%228042%22_PS/2_Controller#Initialising_the_PS.2F2_Controller // TODO: USB should be initialized before the PS/2 controller // TODO: ACPI should be used to check if a PS/2 controller exists debugger.Send("PS/2 Controller Init"); if (InitPS2) { + PS2Controller = new PS2Controller(); PS2Controller.Initialize(InitScrollWheel); } else From bda39ef16ccc77dbbcaec79c91ae0b27aba2c985 Mon Sep 17 00:00:00 2001 From: valentinbreiz Date: Tue, 26 Dec 2023 17:18:29 +0100 Subject: [PATCH 35/35] =?UTF-8?q?=F0=9F=90=9B=20Fix=20IRQ=20handling?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/Cosmos.Core/INTs.cs | 2 +- source/Cosmos.Core/IOAPIC.cs | 14 ++++++-------- source/Cosmos.HAL2/Drivers/Network/AMDPCNetII.cs | 1 - 3 files changed, 7 insertions(+), 10 deletions(-) diff --git a/source/Cosmos.Core/INTs.cs b/source/Cosmos.Core/INTs.cs index 169524dfc0..c07ad280da 100644 --- a/source/Cosmos.Core/INTs.cs +++ b/source/Cosmos.Core/INTs.cs @@ -283,7 +283,7 @@ public static void SetIntHandler(byte aIntNo, IRQDelegate aHandler) { /// IRQ index. /// IRQ handler. public static void SetIrqHandler(byte aIrqNo, IRQDelegate aHandler) { - IOAPIC.SetEntry(aIrqNo); + IOAPIC.SetEntry((uint)aIrqNo + 0x20); SetIntHandler((byte)(0x20 + aIrqNo), aHandler); } diff --git a/source/Cosmos.Core/IOAPIC.cs b/source/Cosmos.Core/IOAPIC.cs index d02e797fe0..54eeddcd8d 100644 --- a/source/Cosmos.Core/IOAPIC.cs +++ b/source/Cosmos.Core/IOAPIC.cs @@ -82,22 +82,20 @@ public static uint In(byte reg) /// /// Set IO APIC Entry. /// - /// Entry index. - /// Data. - /// Local APIC Id. - public static void SetEntry(byte index, ulong data, uint lapicId = 0) + /// Irq ID. + public static void SetEntry(uint irq) { - Out((byte)(IOREDTBL + index * 2), (uint)data); - Out((byte)(IOREDTBL + index * 2 + 1), (lapicId << 24)); + SetEntry((byte)ACPI.RemapIRQ(irq - 0x20), irq); } /// /// Set IO APIC Entry. /// /// Irq ID. - public static void SetEntry(uint irq) + public static void SetEntry(byte index, ulong data) { - SetEntry((byte)ACPI.RemapIRQ(irq), 0x20 + irq); + Out((byte)(IOREDTBL + index * 2), (uint)data); + Out((byte)(IOREDTBL + index * 2 + 1), (uint)(data >> 32)); } /// diff --git a/source/Cosmos.HAL2/Drivers/Network/AMDPCNetII.cs b/source/Cosmos.HAL2/Drivers/Network/AMDPCNetII.cs index caaf1c4b6a..0102068b78 100644 --- a/source/Cosmos.HAL2/Drivers/Network/AMDPCNetII.cs +++ b/source/Cosmos.HAL2/Drivers/Network/AMDPCNetII.cs @@ -149,7 +149,6 @@ protected void HandleNetworkInterrupt(ref INTs.IRQContext aContext) } StatusRegister = cur_status; - Core.Global.PIC.EoiSlave(); } ///