fix: ISR dispatch calling convention + PS/2 interrupt enable

Root cause: x86_64-unknown-uefi uses the Microsoft x64 calling
convention where the first argument is passed in rcx, not rdi.
The ISR stub was setting rdi = rsp, but isr_dispatch() read
the frame pointer from rcx, getting garbage → triple fault.

Also:
- Enable PS/2 keyboard IRQ via controller config byte (bit 0).
- Expose read_scancode() and TICKS from interrupt module.
- ps2::poll_key() uses 'sti; hlt' race-free sleep pattern.

2 files changed, 112 insertions, 48 deletions

diff --git a/src/interrupts.rs b/src/interrupts.rs
index 204d3d7..90d5bbb 100644
--- a/src/interrupts.rs
+++ b/src/interrupts.rs
@@ -12,13 +12,13 @@ use core::sync::atomic::{AtomicU16, Ordering};
 #[derive(Copy, Clone)]
 #[repr(C, packed)]
 struct IdtEntry {
-    offset_lo:  u16,
-    selector:   u16,
-    ist:        u8,
-    flags:      u8,
+    offset_lo: u16,
+    selector: u16,
+    ist: u8,
+    flags: u8,
     offset_mid: u16,
-    offset_hi:  u32,
-    _reserved:  u32,
+    offset_hi: u32,
+    _reserved: u32,
 }
 
 /// Fill one IDT entry at the given offset (in bytes).
@@ -27,13 +27,13 @@ unsafe fn idt_set_entry(idt: *mut u8, vec: u8, handler: u64, selector: u16, flag
         let off = (vec as usize) * 16;
         let p = idt.add(off) as *mut IdtEntry;
         p.write(IdtEntry {
-            offset_lo:  handler as u16,
+            offset_lo: handler as u16,
             selector,
-            ist:        0,
-            flags:      flags | 0x80, // bit 7 = present
+            ist: 0,
+            flags: flags | 0x80, // bit 7 = present
             offset_mid: (handler >> 16) as u16,
-            offset_hi:  (handler >> 32) as u32,
-            _reserved:  0,
+            offset_hi: (handler >> 32) as u32,
+            _reserved: 0,
         });
     }
 }
@@ -46,9 +46,9 @@ static mut IDTR: [u16; 5] = [0; 5]; // 2-byte limit + 4-byte base (48-bit pseudo
 // PIC (8259A)
 // ---------------------------------------------------------------------------
 
-const PIC1_CMD:  u16 = 0x20;
+const PIC1_CMD: u16 = 0x20;
 const PIC1_DATA: u16 = 0x21;
-const PIC2_CMD:  u16 = 0xA0;
+const PIC2_CMD: u16 = 0xA0;
 const PIC2_DATA: u16 = 0xA1;
 
 const PIC_EOI: u8 = 0x20;
@@ -89,8 +89,8 @@ fn eoi(irq: u8) {
 // PIT timer (channel 0, ~100 Hz)
 // ---------------------------------------------------------------------------
 
-const PIT_CMD:  u16 = 0x43;
-const PIT_CH0:  u16 = 0x40;
+const PIT_CMD: u16 = 0x43;
+const PIT_CH0: u16 = 0x40;
 const PIT_FREQ: u64 = 1_193_182;
 
 /// Set up PIT channel 0 in mode 2 (rate generator) at `hz` (1–1000ish).
@@ -177,7 +177,9 @@ impl KeyBuf {
         if next.wrapping_sub(h) as u16 > 255 {
             return; // drop — ring is full
         }
-        unsafe { *self.buf[t as usize & 255].get() = byte; }
+        unsafe {
+            *self.buf[t as usize & 255].get() = byte;
+        }
         // Ensure byte is globally visible before incrementing tail.
         self.tail.store(next, Ordering::Release);
     }
@@ -206,8 +208,8 @@ core::arch::global_asm!(
     ".globl isr_stub_32",
     ".p2align 4",
     "isr_stub_32:",
-    "    push 0",          // error code (non-exception)
-    "    push 32",         // vector
+    "    push 0",  // error code (non-exception)
+    "    push 32", // vector
     "    jmp  isr_common",
     "",
     ".globl isr_stub_33",
@@ -243,7 +245,7 @@ core::arch::global_asm!(
     "    push r14",
     "    push r15",
     "",
-    "    mov rdi, rsp",              // first arg: pointer to saved registers
+    "    mov rcx, rsp", // first arg (rcx = MS x64 ABI)
     "    call isr_dispatch",
     "",
     "    pop r15",
@@ -261,36 +263,50 @@ core::arch::global_asm!(
     "    pop rdx",
     "    pop rcx",
     "    pop rax",
-    "    add rsp, 16",               // pop vector + error code
+    "    add rsp, 16", // pop vector + error code
     "    iretq",
 );
 
 /// Saved register frame (as pushed by `isr_common`).
 #[repr(C)]
 struct IntFrame {
-    r15:  u64, r14: u64, r13: u64, r12: u64,
-    r11:  u64, r10: u64, r9:  u64, r8:  u64,
-    rdi:  u64, rsi: u64, rbp: u64, rbx: u64,
-    rdx:  u64, rcx: u64, rax: u64,
-    vector:   u64,
-    error:    u64,
-    rip:      u64,
-    cs:       u64,
-    rflags:   u64,
+    r15: u64,
+    r14: u64,
+    r13: u64,
+    r12: u64,
+    r11: u64,
+    r10: u64,
+    r9: u64,
+    r8: u64,
+    rdi: u64,
+    rsi: u64,
+    rbp: u64,
+    rbx: u64,
+    rdx: u64,
+    rcx: u64,
+    rax: u64,
+    vector: u64,
+    error: u64,
+    rip: u64,
+    cs: u64,
+    rflags: u64,
 }
 
 /// Called from the asm common handler — dispatches to the right Rust handler.
 #[no_mangle]
-extern "C" fn isr_dispatch(frame: &IntFrame) {
-    match frame.vector {
-        32 => timer_irq(),
-        33 => keyboard_irq(),
-        0xFF => { /* spurious — ignore */ }
-        other => {
-            // Log unexpected interrupt on serial (but don't halt — might be benign).
-            crate::serial::write_str("intr: unhandled vector ");
-            crate::serial::put_byte(other as u8);
-            crate::serial::put_byte(b'\n');
+unsafe extern "C" fn isr_dispatch(frame: &IntFrame) {
+    unsafe {
+        match frame.vector {
+            32 => eoi(0),
+            33 => {
+                let byte: u8;
+                core::arch::asm!("in al, dx", out("al") byte, in("dx") 0x60u16,
+                    options(nostack, preserves_flags));
+                // Push scancode to ring buffer (called with interrupts disabled).
+                KEYBUF.push(byte);
+                eoi(1);
+            }
+            _ => {}
         }
     }
 }
@@ -346,7 +362,7 @@ pub fn init() {
 
         // Build the IDTR pseudo-descriptor.
         IDTR = [
-            (256u16 * 16 - 1) as u16,     // limit = 256*16 - 1
+            (256u16 * 16 - 1) as u16,      // limit = 256*16 - 1
             idt_ptr as u16,                // base lo
             (idt_ptr as u64 >> 16) as u16, // base mid
             (idt_ptr as u64 >> 32) as u16, // base hi
diff --git a/src/ps2.rs b/src/ps2.rs
index 3a42c1a..4ea8b7a 100644
--- a/src/ps2.rs
+++ b/src/ps2.rs
@@ -158,9 +158,64 @@ static mut KBD: KbdState = KbdState {
     got_e0: false,
 };
 
-/// Initialise the PS/2 port for the keyboard — just drain stale bytes.
+/// Initialise the PS/2 port: drain stale bytes + enable keyboard interrupt.
 pub fn init() {
     drain_input();
+
+    // Enable the keyboard interrupt on the PS/2 controller.
+    // Read Configuration Byte (command 0x20), set bit 0 (IRQ1 enable),
+    // write back (command 0x60).
+    unsafe {
+        // Tell the keyboard controller we want to read the config byte.
+        // Need to wait for the controller to be ready first.
+        wait_write();
+        core::arch::asm!("out dx, al", in("dx") 0x64u16, in("al") 0x20u8,
+            options(nostack, preserves_flags));
+        wait_read();
+        let mut cfg: u8;
+        core::arch::asm!("in al, dx", out("al") cfg, in("dx") 0x60u16,
+            options(nostack, preserves_flags));
+
+        cfg |= 0x01; // enable keyboard interrupt
+
+        // Write config byte back
+        wait_write();
+        core::arch::asm!("out dx, al", in("dx") 0x64u16, in("al") 0x60u8,
+            options(nostack, preserves_flags));
+        wait_write();
+        core::arch::asm!("out dx, al", in("dx") 0x60u16, in("al") cfg,
+            options(nostack, preserves_flags));
+    }
+}
+
+/// Wait until the PS/2 controller is ready to receive a command.
+fn wait_write() {
+    unsafe {
+        loop {
+            let status: u8;
+            core::arch::asm!("in al, dx", out("al") status, in("dx") 0x64u16,
+                options(nostack, preserves_flags));
+            if status & 0x02 == 0 {
+                // Input buffer empty — controller ready to receive
+                break;
+            }
+        }
+    }
+}
+
+/// Wait until the PS/2 controller has data available to read.
+fn wait_read() {
+    unsafe {
+        loop {
+            let status: u8;
+            core::arch::asm!("in al, dx", out("al") status, in("dx") 0x64u16,
+                options(nostack, preserves_flags));
+            if status & 0x01 != 0 {
+                // Output buffer full — data ready to read
+                break;
+            }
+        }
+    }
 }
 
 fn drain_input() {
@@ -184,18 +239,11 @@ fn drain_input() {
 /// this function pops and decodes them.
 pub fn poll_key() -> KeyEvent {
     loop {
-        // Disable interrupts so the buffer-empty → hlt window is atomic.
-        unsafe { core::arch::asm!("cli", options(nostack, preserves_flags)); }
-
         if let Some(byte) = crate::interrupts::read_scancode() {
-            unsafe { core::arch::asm!("sti", options(nostack, preserves_flags)); }
             if let Some(ev) = process_byte(byte) {
                 return ev;
             }
         } else {
-            // Re-enable and halt.  If a keyboard IRQ arrived between the
-            // buffer check and `sti`, the CPU sees a pending interrupt
-            // and `hlt` returns immediately.
             unsafe {
                 core::arch::asm!("sti; hlt", options(nostack, preserves_flags));
             }