feature: Full fat PS/2 controller, keyboard, and INT9H

Author: maximilien-noal

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.BufferEntry.cs

@@ -0,0 +1,11 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+public partial class Intel8042Controller {
+    // Controller internal buffer
+    private struct BufferEntry {
+        public byte Data;
+        public bool IsFromAux;
+        public bool IsFromKbd;
+        public bool SkipDelay;
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.ConfigBits.cs

@@ -0,0 +1,46 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using Spice86.Core.Emulator.CPU;
+
+using System;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Configuration byte bit definitions.
+    /// </summary>
+    [Flags]
+    public enum ConfigBits : byte {
+        /// <summary>
+        /// Bit 0: Keyboard IRQ enabled (IRQ1).
+        /// </summary>
+        KbdIrqEnabled = 1 << 0,
+        /// <summary>
+        /// Bit 1: Mouse IRQ enabled (IRQ12).
+        /// </summary>
+        MouseIrqEnabled = 1 << 1,
+        /// <summary>
+        /// Bit 2: Self-test passed.
+        /// </summary>
+        SelfTestPassed = 1 << 2,
+        /// <summary>
+        /// Bit 3: Reserved.
+        /// </summary>
+        Reserved3 = 1 << 3,
+        /// <summary>
+        /// Bit 4: Keyboard port disabled.
+        /// </summary>
+        DisableKbdPort = 1 << 4,
+        /// <summary>
+        /// Bit 5: Auxiliary (mouse) port disabled.
+        /// </summary>
+        DisableAuxPort = 1 << 5,
+        /// <summary>
+        /// Bit 6: Translation enabled (AT -&gt; XT).
+        /// </summary>
+        TranslationEnabled = 1 << 6,
+        /// <summary>
+        /// Bit 7: Reserved.
+        /// </summary>
+        Reserved7 = 1 << 7,
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.ConfigByte.cs

@@ -0,0 +1,57 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using System.Diagnostics;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Byte 0x00 of the controller memory - configuration byte
+    /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class ConfigByte {
+        public ConfigByte(byte initial = 0) => FromByte(initial);
+
+        // bit0: keyboard IRQ enabled (IRQ1)
+        public bool KbdIrqEnabled { get; set; }
+        // bit1: mouse IRQ enabled (IRQ12)
+        public bool MouseIrqEnabled { get; set; }
+        // bit2: self-test passed
+        public bool SelfTestPassed { get; set; }
+        // bit3: reserved
+        public bool Reserved3 { get; set; }
+        // bit4: keyboard port disabled
+        public bool IsKeyboardPortDisabled { get; set; }
+        // bit5: aux (mouse) port disabled
+        public bool IsAuxPortDisabled { get; set; }
+        // bit6: translation enabled (AT -> XT)
+        public bool TranslationEnabled { get; set; }
+        // bit7: reserved
+        public bool Reserved7 { get; set; }
+
+        public byte ToByte() {
+            byte v = 0;
+            if (KbdIrqEnabled) v |= (byte)ConfigBits.KbdIrqEnabled;
+            if (MouseIrqEnabled) v |= (byte)ConfigBits.MouseIrqEnabled;
+            if (SelfTestPassed) v |= (byte)ConfigBits.SelfTestPassed;
+            if (Reserved3) v |= (byte)ConfigBits.Reserved3;
+            if (IsKeyboardPortDisabled) v |= (byte)ConfigBits.DisableKbdPort;
+            if (IsAuxPortDisabled) v |= (byte)ConfigBits.DisableAuxPort;
+            if (TranslationEnabled) v |= (byte)ConfigBits.TranslationEnabled;
+            if (Reserved7) v |= (byte)ConfigBits.Reserved7;
+            return v;
+        }
+
+        public void FromByte(byte value) {
+            KbdIrqEnabled = (value & (byte)ConfigBits.KbdIrqEnabled) != 0;
+            MouseIrqEnabled = (value & (byte)ConfigBits.MouseIrqEnabled) != 0;
+            SelfTestPassed = (value & (byte)ConfigBits.SelfTestPassed) != 0;
+            Reserved3 = (value & (byte)ConfigBits.Reserved3) != 0;
+            IsKeyboardPortDisabled = (value & (byte)ConfigBits.DisableKbdPort) != 0;
+            IsAuxPortDisabled = (value & (byte)ConfigBits.DisableAuxPort) != 0;
+            TranslationEnabled = (value & (byte)ConfigBits.TranslationEnabled) != 0;
+            Reserved7 = (value & (byte)ConfigBits.Reserved7) != 0;
+        }
+
+        private string DebuggerDisplay =>
+            $"0x{ToByte():X2} (IRQ1={KbdIrqEnabled}, IRQ12={MouseIrqEnabled}, KbdDis={IsKeyboardPortDisabled}, AuxDis={IsAuxPortDisabled}, Xlate={TranslationEnabled}, SelfTest={SelfTestPassed})";
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.ControllerModeValue.cs

@@ -0,0 +1,17 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Controller mode values.
+    /// </summary>
+    public enum ControllerModeValue : byte {
+        /// <summary>
+        /// ISA (AT) mode.
+        /// </summary>
+        IsaAt = 0x00,
+        /// <summary>
+        /// PS/2 (MCA) mode.
+        /// </summary>
+        Ps2Mca = 0x01,
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.LineParam.cs

@@ -0,0 +1,26 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using Spice86.Core.Emulator.CPU;
+
+using System;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Line parameter masks used by pulse-lines commands (0xF0-0xFF).
+    /// </summary>
+    [Flags]
+    public enum LineParam : byte {
+        /// <summary>
+        /// Reset line mask (bit 0).
+        /// </summary>
+        Reset = 0b0001,
+        /// <summary>
+        /// All lines mask (bits 0..3 set).
+        /// </summary>
+        AllLines = 0b1111,
+        /// <summary>
+        /// All lines except Reset (bits 1..3 set).
+        /// </summary>
+        AllLinesExceptReset = 0b1110,
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.OutputPortBits.cs

@@ -0,0 +1,30 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using Spice86.Core.Emulator.CPU;
+
+using System;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Output port (P2) bit definitions.
+    /// </summary>
+    [Flags]
+    public enum OutputPortBits : byte {
+        /// <summary>
+        /// Bit 0: 1 = normal, 0 = CPU reset asserted.
+        /// </summary>
+        ResetNotAsserted = 1 << 0,
+        /// <summary>
+        /// Bit 1: A20 line enabled.
+        /// </summary>
+        A20Enabled = 1 << 1,
+        /// <summary>
+        /// Bit 4: Keyboard IRQ1 active.
+        /// </summary>
+        KeyboardIrqActive = 1 << 4,
+        /// <summary>
+        /// Bit 5: Mouse IRQ12 active.
+        /// </summary>
+        MouseIrqActive = 1 << 5,
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.Response.cs

@@ -0,0 +1,26 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Common controller byte values used across 8042 operations.
+    /// </summary>
+    public enum Response : byte {
+        /// <summary>
+        /// Generic OK/zero value, used by port tests and various default reads.
+        /// Also used as NUL terminator for the firmware copyright string.
+        /// </summary>
+        Ok = 0x00,
+        /// <summary>
+        /// Controller self-test passed value (result of command 0xAA).
+        /// </summary>
+        SelfTestPassed = 0x55,
+        /// <summary>
+        /// Password not installed or unsupported (command 0xA4 result).
+        /// </summary>
+        PasswordNotInstalled = 0xF1,
+        /// <summary>
+        /// Space key make code in Set 1 (used by diagnostic dump formatting).
+        /// </summary>
+        SpaceScanCodeSet1 = 0x39,
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.Status.cs

@@ -0,0 +1,88 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using System.Diagnostics;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Encapsulates the 8042 status register for easier debugging.
+    /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    private sealed class Status {
+        public Status(byte initial = 0) => FromByte(initial);
+
+        /// <summary>
+        /// bit0: output buffer status (1 = data available)
+        /// </summary>
+        public bool IsDataPending { get; set; }
+
+        /// <summary>
+        /// bit1: input buffer status (not used here, kept for completeness)
+        /// </summary>
+        public bool InputBufferFull { get; set; }
+
+        /// <summary>
+        /// bit2: system flag (not used here)
+        /// </summary>
+        public bool SystemFlag { get; set; }
+
+        /// <summary>
+        /// bit3: last write was command
+        /// </summary>
+        public bool WasLastWriteCmd { get; set; }
+
+        /// <summary>
+        /// bit4: unused/reserved in this emulation
+        /// </summary>
+        public bool Reserved4 { get; set; }
+
+        /// <summary>
+        /// bit5: data came from aux (mouse)
+        /// </summary>
+        public bool IsDataFromAux { get; set; }
+
+        /// <summary>
+        /// bit6: timeout
+        /// </summary>
+        public bool Timeout { get; set; }
+
+        /// <summary>
+        /// bit7: parity (not used here)
+        /// </summary>
+        public bool ParityError { get; set; }
+
+        /// <summary>
+        /// Converts the current status flags to their byte representation.
+        /// </summary>
+        /// <returns>A byte value representing the combined status flags. Each bit corresponds to a specific status flag.</returns>
+        public byte ToByte() {
+            byte v = 0;
+            if (IsDataPending) v |= (byte)StatusBits.OutputBufferFull;
+            if (InputBufferFull) v |= (byte)StatusBits.InputBufferFull;
+            if (SystemFlag) v |= (byte)StatusBits.SystemFlag;
+            if (WasLastWriteCmd) v |= (byte)StatusBits.LastWriteWasCommand;
+            if (Reserved4) v |= (byte)StatusBits.Reserved4;
+            if (IsDataFromAux) v |= (byte)StatusBits.DataFromAux;
+            if (Timeout) v |= (byte)StatusBits.Timeout;
+            if (ParityError) v |= (byte)StatusBits.ParityError;
+            return v;
+        }
+
+        /// <summary>
+        /// Parses the specified status byte and updates the corresponding status flags of the instance.
+        /// </summary>
+        /// <param name="value">A byte value representing the status bits to parse and apply.</param>
+        public void FromByte(byte value) {
+            IsDataPending = (value & (byte)StatusBits.OutputBufferFull) != 0;
+            InputBufferFull = (value & (byte)StatusBits.InputBufferFull) != 0;
+            SystemFlag = (value & (byte)StatusBits.SystemFlag) != 0;
+            WasLastWriteCmd = (value & (byte)StatusBits.LastWriteWasCommand) != 0;
+            Reserved4 = (value & (byte)StatusBits.Reserved4) != 0;
+            IsDataFromAux = (value & (byte)StatusBits.DataFromAux) != 0;
+            Timeout = (value & (byte)StatusBits.Timeout) != 0;
+            ParityError = (value & (byte)StatusBits.ParityError) != 0;
+        }
+
+        private string DebuggerDisplay =>
+            $"0x{ToByte():X2} (New={IsDataPending}, Aux={IsDataFromAux}, Cmd={WasLastWriteCmd}, TO={Timeout})";
+    }
+}

src/Spice86.Core/Emulator/Devices/Input/Keyboard/Intel8042Controller.StatusBits.cs

@@ -0,0 +1,47 @@
+namespace Spice86.Core.Emulator.Devices.Input.Keyboard;
+
+using Spice86.Core.Emulator.CPU;
+
+using System;
+
+public partial class Intel8042Controller {
+    /// <summary>
+    /// Status register bit definitions.
+    /// </summary>
+    [Flags]
+    public enum StatusBits : byte {
+        /// <summary>
+        /// Bit 0: Output buffer status (1 = data available).
+        /// </summary>
+        OutputBufferFull = 0x01,
+        /// <summary>
+        /// Bit 1: Input buffer status.
+        /// </summary>
+        InputBufferFull = 0x02,
+
+        /// <summary>
+        /// Bit 2: System flag.
+        /// </summary>
+        SystemFlag = 0x04,
+        /// <summary>
+        /// Bit 3: Last write was a command.
+        /// </summary>
+        LastWriteWasCommand = 0x08,
+        /// <summary>
+        /// Bit 4: Reserved/unused.
+        /// </summary>
+        Reserved4 = 0x10,
+        /// <summary>
+        /// Bit 5: Data came from auxiliary device (mouse).
+        /// </summary>
+        DataFromAux = 0x20,
+        /// <summary>
+        /// Bit 6: Timeout.
+        /// </summary>
+        Timeout = 0x40,
+        /// <summary>
+        /// Bit 7: Parity error.
+        /// </summary>
+        ParityError = 0x80,
+    }
+}