feat: add PS/2 keyboard interrupt driver

Cargo.toml

@@ -216,6 +216,15 @@ virtio-vsock = ["virtio"]
 ## This is only useful on PCs (x86-64).
 vga = []
 
+## Enables the PS/2 keyboard driver.
+## 
+## This feature initializes the PS/2 keyboard controller and installs a keyboard interrupt handler. 
+## It also provides a system call to receive the last scancode from the internal keyboard buffer. 
+## Note that this is not a complete keyboard driver and not needed for general keyboard support.
+## It allows receiving scancodes from the PS/2 keyboard that can be used to port applications.
+## This is only useful on PCs (x86-64). 
+pc-keyboard = []   
+
 #! ### Performance Features
 
 ## Disables putting the CPU to sleep.

src/arch/x86_64/kernel/interrupts.rs

@@ -157,7 +157,14 @@ pub(crate) fn install() {
 	IRQ_NAMES.lock().insert(7, "FPU");
 }
 
-pub(crate) fn install_handlers(handlers: InterruptHandlerMap) {
+pub(crate) fn install_handlers(#[allow(unused_mut)] mut handlers: InterruptHandlerMap) {
+	#[cfg(feature = "pc-keyboard")]
+	{
+		use crate::arch::kernel::pc_keyboard::get_keyboard_handler;
+		let (irq, handler) = get_keyboard_handler();
+		handlers.entry(irq).or_default().push_back(handler);
+	}
+
 	IRQ_HANDLERS.set(handlers).unwrap();
 }
 

src/arch/x86_64/kernel/mod.rs

@@ -22,6 +22,8 @@ pub mod interrupts;
 pub mod kernel_stack;
 #[cfg(all(not(feature = "pci"), feature = "virtio"))]
 pub mod mmio;
+#[cfg(feature = "pc-keyboard")]
+pub mod pc_keyboard;
 #[cfg(feature = "pci")]
 pub mod pci;
 pub mod pic;

src/arch/x86_64/kernel/pc_keyboard.rs

@@ -0,0 +1,75 @@
+use core::sync::atomic::{AtomicU8, AtomicUsize, Ordering};
+
+use x86_64::instructions::port::Port;
+
+use crate::kernel::interrupts;
+
+const BUFFER_SIZE: usize = 256;
+#[allow(clippy::declare_interior_mutable_const)]
+const ATOMIC_ZERO: AtomicU8 = AtomicU8::new(0);
+const PS2_DATA_PORT: u16 = 0x60;
+const PS2_CMD_PORT: u16 = 0x64;
+const PS2_CMD_READ_CNFG: u8 = 0x20;
+const PS2_CMD_WRITE_CNFG: u8 = 0x60;
+const PS2_CMD_DISABLE_KEYBOARD: u8 = 0xad;
+const PS2_CMD_DISABLE_MOUSE: u8 = 0xa7;
+const PS2_CMD_ENABLE_KEYBOARD: u8 = 0xae;
+const PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT: u8 = 0x01;
+const PS2_BUFFER_FULL: u8 = 0x01;
+
+static KEYBOARD_BUFFER: [AtomicU8; BUFFER_SIZE] = [ATOMIC_ZERO; BUFFER_SIZE];
+static WRITE_INDEX: AtomicUsize = AtomicUsize::new(0);
+static READ_INDEX: AtomicUsize = AtomicUsize::new(0);
+
+pub(crate) fn get_keyboard_handler() -> (u8, fn()) {
+	unsafe {
+		let mut cmd_port = Port::<u8>::new(PS2_CMD_PORT);
+		let mut data_port = Port::<u8>::new(PS2_DATA_PORT);
+		cmd_port.write(PS2_CMD_DISABLE_KEYBOARD);
+		cmd_port.write(PS2_CMD_DISABLE_MOUSE);
+
+		while (cmd_port.read() & PS2_BUFFER_FULL) != 0 {
+			let _ = data_port.read();
+		}
+
+		cmd_port.write(PS2_CMD_READ_CNFG);
+		let mut config = data_port.read();
+
+		config |= PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT;
+
+		cmd_port.write(PS2_CMD_WRITE_CNFG);
+		data_port.write(config);
+		cmd_port.write(PS2_CMD_ENABLE_KEYBOARD);
+	}
+	fn keyboard_handler() {
+		let mut data_port = Port::<u8>::new(PS2_DATA_PORT);
+		let scancode = unsafe { data_port.read() };
+
+		let write_idx = WRITE_INDEX.load(Ordering::Relaxed);
+		let next_write_idx = write_idx.wrapping_add(1) % BUFFER_SIZE;
+
+		let read_idx = READ_INDEX.load(Ordering::Acquire);
+		if next_write_idx != read_idx {
+			KEYBOARD_BUFFER[write_idx].store(scancode, Ordering::Release);
+			WRITE_INDEX.store(next_write_idx, Ordering::Release);
+		}
+	}
+
+	interrupts::add_irq_name(1, "PS/2 Keyboard");
+
+	(1, keyboard_handler)
+}
+
+/// Pops a scancode from the keyboard buffer, returning None if the buffer is empty.
+pub fn pop_scancode() -> Option<u8> {
+	let read_idx = READ_INDEX.load(Ordering::Relaxed);
+	let write_idx = WRITE_INDEX.load(Ordering::Acquire);
+
+	if read_idx == write_idx {
+		None
+	} else {
+		let scancode = KEYBOARD_BUFFER[read_idx].load(Ordering::Acquire);
+		READ_INDEX.store(read_idx.wrapping_add(1) % BUFFER_SIZE, Ordering::Release);
+		Some(scancode)
+	}
+}

src/syscalls/system.rs

@@ -6,3 +6,10 @@ use crate::arch::mm::paging::{BasePageSize, PageSize};
 pub extern "C" fn sys_getpagesize() -> i32 {
 	BasePageSize::SIZE.try_into().unwrap()
 }
+
+#[cfg(all(target_arch = "x86_64", feature = "pc-keyboard"))]
+#[hermit_macro::system]
+#[unsafe(no_mangle)]
+pub extern "C" fn sys_read_keyboard() -> u8 {
+	crate::kernel::pc_keyboard::pop_scancode().unwrap_or(0)
+}