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,16 @@ pub(crate) fn install() {
 	IRQ_NAMES.lock().insert(7, "FPU");
 }
 
-pub(crate) fn install_handlers(handlers: InterruptHandlerMap) {
+#[allow(unused_mut)]
+pub(crate) fn install_handlers(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,85 @@
+use alloc::collections::VecDeque;
+
+use hermit_sync::{InterruptTicketMutex, Lazy};
+use x86_64::instructions::port::Port;
+
+use crate::kernel::interrupts;
+
+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;
+
+const BUFFER_SIZE: usize = 256;
+struct Ps2;
+
+impl Ps2 {
+	pub fn read_status() -> u8 {
+		let mut status_port = Port::<u8>::new(PS2_CMD_PORT);
+		unsafe { status_port.read() }
+	}
+
+	pub fn write_cmd(cmd: u8) {
+		let mut cmd_port = Port::<u8>::new(PS2_CMD_PORT);
+		unsafe { cmd_port.write(cmd) }
+	}
+
+	pub fn read_data() -> u8 {
+		let mut data_port = Port::<u8>::new(PS2_DATA_PORT);
+		unsafe { data_port.read() }
+	}
+
+	pub fn write_data(data: u8) {
+		let mut data_port = Port::<u8>::new(PS2_DATA_PORT);
+		unsafe { data_port.write(data) }
+	}
+}
+
+static KEYBOARD_BUFFER: Lazy<InterruptTicketMutex<VecDeque<u8>>> =
+	Lazy::new(|| InterruptTicketMutex::new(VecDeque::with_capacity(BUFFER_SIZE)));
+
+fn keyboard_handler() {
+	let scancode = Ps2::read_data();
+	let mut buffer = KEYBOARD_BUFFER.lock();
+
+	if buffer.len() >= BUFFER_SIZE {
+		buffer.pop_front();
+	}
+	buffer.push_back(scancode);
+}
+
+pub(crate) fn get_keyboard_handler() -> (u8, fn()) {
+	Ps2::write_cmd(PS2_CMD_DISABLE_KEYBOARD);
+	Ps2::write_cmd(PS2_CMD_DISABLE_MOUSE);
+	// Ensure an empty buffer to guard against stuck data
+	while (Ps2::read_status() & PS2_BUFFER_FULL) != 0 {
+		let _ = Ps2::read_data();
+	}
+
+	Ps2::write_cmd(PS2_CMD_READ_CNFG);
+	let mut config = Ps2::read_data();
+
+	config |= PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT;
+
+	Ps2::write_cmd(PS2_CMD_WRITE_CNFG);
+
+	Ps2::write_data(config);
+	Ps2::write_cmd(PS2_CMD_ENABLE_KEYBOARD);
+
+	// Force the initialization of the keyboard buffer to ensure it is ready before any interrupts occur.
+	Lazy::force(&KEYBOARD_BUFFER);
+
+	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> {
+	KEYBOARD_BUFFER.lock().pop_front()
+}

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)
+}