feat: implement keyboard interrupt handling and echo to serial

- Fully disable legacy PIC controller before enabling APIC
  to prevent interrupt conflicts

- Init and config IOAPIC to route keyboard IRQ1 to IDT vector 33

- Verify real-time keyboard interrupt echoed via serial console

Author: gitcomit8

Cargo.toml

@@ -8,6 +8,7 @@ members = ["kernel",
     "graphics",
     "util",
     "task",
+    "keyboard"
 ]
 
 [profile.release]

apic/Cargo.toml

@@ -7,8 +7,7 @@ edition = "2024"
 x86_64 = "0.15.2"
 hal = { path = "../hal" }
 idt = { path = "../idt" }
-lazy_static = "1.5.0"
-
+keyboard = { path = "../keyboard" }
 [profile.release]
 panic = "abort"
 

apic/src/ioapic.rs

@@ -1,27 +1,28 @@
 const IOAPIC_BASE: u64 = 0xFEC00000;
 
 fn ioapic_reg(offset: u32) -> *mut u32 {
-	(IOAPIC_BASE + offset as u64) as *mut u32
+    (IOAPIC_BASE + offset as u64) as *mut u32
 }
 
-unsafe fn ioapic_read(reg: u32) {
-	ioapic_reg(0x00).write_volatile(reg);
-	ioapic_reg(0x10).read_volatile();
+unsafe fn ioapic_read(reg: u32) -> u32 {
+    ioapic_reg(0x00).write_volatile(reg);
+    ioapic_reg(0x10).read_volatile()
 }
+
 unsafe fn ioapic_write(reg: u32, value: u32) {
-	ioapic_reg(0x00).write_volatile(reg);
-	ioapic_reg(0x10).write_volatile(value);
+    ioapic_reg(0x00).write_volatile(reg);
+    ioapic_reg(0x10).write_volatile(value);
 }
 
 pub unsafe fn map_irq(irq: u8, vector: u8) {
-	let reg = 0x10 + (irq as u32 * 2);
-	ioapic_write(reg, vector as u32);
-	ioapic_write(reg + 1, 0);
+    let reg = 0x10 + (irq as u32 * 2);
+    ioapic_write(reg, vector as u32);
+    ioapic_write(reg + 1, 0);
 }
 
 pub unsafe fn init_ioapic() {
-	//example route irq 1 to vector 33(keyboard)
-	map_irq(1, 33);
-	//route irq 0 to vector 32 (timer)
-	map_irq(0, 32);
+    //example route irq 1 to vector 33(keyboard)
+    map_irq(1, 33);
+    //route irq 0 to vector 32 (timer)
+    map_irq(0, 32);
 }

apic/src/lib.rs

@@ -3,7 +3,7 @@
 
 use hal::serial_println;
 
-mod ioapic;
+pub mod ioapic;
 pub mod timer;
 
 const APIC_BASE: u64 = 0xFEE00000;
@@ -12,7 +12,42 @@ fn lapic_reg(offset: u32) -> *mut u32 {
     (APIC_BASE + offset as u64) as *mut u32
 }
 
+pub unsafe fn disable_pic() {
+    use x86_64::instructions::port::Port;
+    
+    // Remap PIC to avoid conflicts, then mask all interrupts
+    let mut pic1_cmd: Port<u8> = Port::new(0x20);
+    let mut pic1_data: Port<u8> = Port::new(0x21);
+    let mut pic2_cmd: Port<u8> = Port::new(0xA0);
+    let mut pic2_data: Port<u8> = Port::new(0xA1);
+    
+    // Start initialization sequence
+    pic1_cmd.write(0x11);
+    pic2_cmd.write(0x11);
+    
+    // Remap IRQs to vectors 32-47
+    pic1_data.write(0x20);
+    pic2_data.write(0x28);
+    
+    // Set up cascading
+    pic1_data.write(0x04);
+    pic2_data.write(0x02);
+    
+    // Set 8086 mode
+    pic1_data.write(0x01);
+    pic2_data.write(0x01);
+    
+    // Mask all interrupts
+    pic1_data.write(0xFF);
+    pic2_data.write(0xFF);
+    
+    serial_println!("Legacy PIC disabled");
+}
+
 pub unsafe fn enable() {
+    // Disable legacy PIC first
+    disable_pic();
+    
     // Check and enable LAPIC in IA32_APIC_BASE MSR (MSR 0x1B)
     let mut apic_base: u64;
     core::arch::asm!("rdmsr", in("ecx") 0x1Bu32, lateout("eax") apic_base, lateout("edx") _);
@@ -29,6 +64,8 @@ pub unsafe fn enable() {
     let svr = lapic_reg(0xF0);
     let val = svr.read_volatile() | 0x100; //Set bit 8
     svr.write_volatile(val);
+    
+    serial_println!("APIC enabled");
 }
 
 pub unsafe fn set_timer(vector: u8, divide: u32, initial_count: u32) {

idt/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 x86_64 = "0.15.2"
 hal = { path = "../hal" }
 util = { path = "../util" }
+keyboard = { path = "../keyboard" }
 lazy_static = { version = "1.5.0", features = ["spin_no_std"] }
 
 [profile.release]

idt/src/lib.rs

@@ -8,8 +8,8 @@ use util::panic::oops;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
 
 struct IdtWrapper {
-	idt: UnsafeCell<InterruptDescriptorTable>,
-	loaded: UnsafeCell<bool>,
+    idt: UnsafeCell<InterruptDescriptorTable>,
+    loaded: UnsafeCell<bool>,
 }
 
 unsafe impl Sync for IdtWrapper {}
@@ -20,58 +20,76 @@ lazy_static! {
 		idt.divide_error.set_handler_fn(divide_by_zero_handler);
 		idt.page_fault.set_handler_fn(page_fault_handler);
 		idt.double_fault.set_handler_fn(double_fault_handler);
+		idt[33].set_handler_fn(keyboard_interrupt_handler);
 		IdtWrapper {
 			idt: UnsafeCell::new(idt),
 			loaded: UnsafeCell::new(false),
 		}
 	};
 }
+
+extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
+    use x86_64::instructions::port::Port;
+
+    //Read scancode from keyboard port 0x60
+    let mut port = Port::new(0x60);
+    let scancode: u8 = unsafe { port.read() };
+
+    //Process scancode
+    keyboard::handle_scancode(scancode);
+
+    //Send EOI to APIC directly
+    unsafe {
+        const APIC_EOI: *mut u32 = 0xFEE000B0 as *mut u32;
+        APIC_EOI.write_volatile(0);
+    }
+}
 extern "x86-interrupt" fn divide_by_zero_handler(_stack: InterruptStackFrame) {
-	oops("Divide by Zero exception");
+    oops("Divide by Zero exception");
 }
 
 extern "x86-interrupt" fn page_fault_handler(stack: InterruptStackFrame, err: PageFaultErrorCode) {
-	serial_println!(
+    serial_println!(
 		"Page fault at instruction pointer: {:#x}",
 		stack.instruction_pointer.as_u64()
 	);
 
-	let cr2: u64;
-	unsafe {
-		core::arch::asm!("mov {}, cr2", out(reg) cr2);
-	}
-	serial_println!("Page fault address: {:#x}", cr2);
-	serial_println!("Error Code: {:?}", err);
+    let cr2: u64;
+    unsafe {
+        core::arch::asm!("mov {}, cr2", out(reg) cr2);
+    }
+    serial_println!("Page fault address: {:#x}", cr2);
+    serial_println!("Error Code: {:?}", err);
 
-	oops("Page fault exception");
+    oops("Page fault exception");
 }
 
 extern "x86-interrupt" fn double_fault_handler(_stack: InterruptStackFrame, _err: u64) -> ! {
-	serial_println!(
+    serial_println!(
 		"Double fault at instruction pointer: {:#x}",
 		_stack.instruction_pointer.as_u64()
 	);
-	panic!("Double fault exception");
+    panic!("Double fault exception");
 }
 
 pub fn init_idt() {
-	unsafe {
-		(*IDT.idt.get()).load();
-		*IDT.loaded.get() = true;
-	}
+    unsafe {
+        (*IDT.idt.get()).load();
+        *IDT.loaded.get() = true;
+    }
 }
 
 pub fn register_interrupt_handler(
-	vector: u8,
-	handler: extern "x86-interrupt" fn(InterruptStackFrame),
+    vector: u8,
+    handler: extern "x86-interrupt" fn(InterruptStackFrame),
 ) {
-	unsafe {
-		let idt = &mut *IDT.idt.get();
-		idt[vector].set_handler_fn(handler);
-		
-		// Only reload if IDT was already loaded
-		if *IDT.loaded.get() {
-			idt.load();
-		}
-	}
+    unsafe {
+        let idt = &mut *IDT.idt.get();
+        idt[vector].set_handler_fn(handler);
+
+        // Only reload if IDT was already loaded
+        if *IDT.loaded.get() {
+            idt.load();
+        }
+    }
 }

kernel/Cargo.toml

@@ -12,7 +12,9 @@ hal = { path = "../hal" }
 idt = { path = "../idt" }
 memory = { path = "../memory" }
 util = { path = "../util" }
-task={ path = "../task" }
+task = { path = "../task" }
+keyboard = { path = "../keyboard" }
+
 [profile.release]
 panic = "abort"
 

kernel/src/main.rs

@@ -9,8 +9,9 @@ use hal::serial_println;
 use limine::request::{FramebufferRequest, MemoryMapRequest};
 use limine::BaseRevision;
 use memory::heap::{init_heap, StaticBootFrameAllocator};
-use task::{SchedClass, Scheduler, TaskCB, TaskManager};
+use task::{Scheduler, TaskManager};
 use util::panic::halt_loop;
+use x86_64::instructions::hlt;
 use x86_64::structures::paging::PhysFrame;
 use x86_64::{PhysAddr, VirtAddr};
 
@@ -65,12 +66,19 @@ pub extern "C" fn _start() -> ! {
     serial_println!("Serial console initialized");
 
     unsafe {
-        apic::enable();
+        apic::enable(); // This now also disables PIC
+        apic::ioapic::init_ioapic(); // Route IRQs through IOAPIC
         apic::timer::register_handler(); // Register timer handler before IDT is loaded
     }
 
     idt::init_idt(); // Setup CPU exception handlers and load IDT
 
+    //Init keyboard
+    hal::serial_println!("Keyboard ready for input!");
+
+    //Enable interrupts globally
+    x86_64::instructions::interrupts::enable();
+
     unsafe {
         apic::timer::init_hardware(); // Initialize timer hardware
     }
@@ -116,43 +124,10 @@ pub extern "C" fn _start() -> ! {
         fill_screen_blue(&fb);
         draw_memory_map(&fb, mmap_response.entries());
     }
-    
+
     // Initialize global scheduler
     Scheduler::init_global();
-    {
-        let mut scheduler = Scheduler::global().lock();
-
-        // Allocate proper stacks for tasks (8KB each)
-        const STACK_SIZE: usize = 8192;
-        
-        // Create kernel boot task - this represents the current execution context
-        let kernel_stack_mem = alloc::vec![0u8; STACK_SIZE];
-        let kernel_stack = VirtAddr::from_ptr(kernel_stack_mem.as_ptr()) + STACK_SIZE as u64;
-        core::mem::forget(kernel_stack_mem);
-        
-        let idle_stack_mem = alloc::vec![0u8; STACK_SIZE];
-        let task1_stack_mem = alloc::vec![0u8; STACK_SIZE];
-
-        // Get stack top addresses (stacks grow downward)
-        let idle_stack = VirtAddr::from_ptr(idle_stack_mem.as_ptr()) + STACK_SIZE as u64;
-        let task1_stack = VirtAddr::from_ptr(task1_stack_mem.as_ptr()) + STACK_SIZE as u64;
-
-        // Prevent stack memory from being deallocated
-        core::mem::forget(idle_stack_mem);
-        core::mem::forget(task1_stack_mem);
-
-        // Add kernel boot task as first task (will never actually run, just holds boot context)
-        let kernel_task = TaskCB::new("kernel_boot", idle_task, kernel_stack, SchedClass::Fair(0));
-        scheduler.add_task(kernel_task);
-        
-        let idle = TaskCB::new("idle", idle_task, idle_stack, SchedClass::Fair(120));
-        let task1 = TaskCB::new("task1", task1, task1_stack, SchedClass::Fair(110));
-        scheduler.add_task(idle);
-        scheduler.add_task(task1);
-
-        serial_println!("Starting scheduler with {} tasks", scheduler.task_count());
-    } // Lock is dropped here
-    
-    // Jump into scheduler - this never returns
-    unsafe { Scheduler::start(); }
+    loop {
+        hlt()
+    }
 }

keyboard/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "keyboard"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+hal = { path = "../hal" }
+x86_64 = "0.15.2"

keyboard/src/lib.rs

@@ -0,0 +1,37 @@
+#![no_std]
+
+//Basic US QWERTY scancode to ASCII mapping
+const SCANDCODE_TO_ASCII: [u8; 128] = [
+    0, 27, b'1', b'2', b'3', b'4', b'5', b'6',  // 0x00-0x07
+    b'7', b'8', b'9', b'0', b'-', b'=', 8, b'\t', // 0x08-0x0F (backspace=8)
+    b'q', b'w', b'e', b'r', b't', b'y', b'u', b'i',  // 0x10-0x17
+    b'o', b'p', b'[', b']', b'\n', 0, b'a', b's',  // 0x18-0x1F (enter=\n, ctrl=0)
+    b'd', b'f', b'g', b'h', b'j', b'k', b'l', b';',  // 0x20-0x27
+    b'\'', b'`', 0, b'\\', b'z', b'x', b'c', b'v',  // 0x28-0x2F (lshift=0)
+    b'b', b'n', b'm', b',', b'.', b'/', 0, b'*',   // 0x30-0x37 (rshift=0)
+    0, b' ', 0, 0, 0, 0, 0, 0,           // 0x38-0x3F (alt=0, space)
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x40-0x4F
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x50-0x5F
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x60-0x6F
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x70-0x7F
+];
+
+pub fn handle_scancode(scancode: u8) {
+    if scancode & 0x80 != 0 {
+        return; //Break code, ignore for now
+    }
+
+    if let Some(&ascii) = SCANDCODE_TO_ASCII.get(scancode as usize) {
+        if ascii != 0 {
+            hal::serial_print!("{}", ascii as char);
+        }
+    }
+}
+
+pub fn enable_keyboard_interrupt() {
+    unsafe {
+        let mut port = x86_64::instructions::port::Port::new(0x21); //PIC1 data port
+        let mask: u8 = port.read();
+        port.write(mask & !0x02); //Clear bit 1 (IRQ1)
+    }
+}