From 3889036590b481c385e11fe4fa0d40cd003adc1f Mon Sep 17 00:00:00 2001 From: husky Date: Thu, 11 Sep 2025 17:48:22 -0700 Subject: [PATCH 1/3] initial driver --- qemurun.sh | 2 +- src/arch/virt/asm/linker.ld | 8 +- src/dev/virtio/input.rs | 294 ++++++++++++++++++++++++++++++++++++ src/dev/virtio/mod.rs | 34 ++++- 4 files changed, 334 insertions(+), 4 deletions(-) create mode 100644 src/dev/virtio/input.rs diff --git a/qemurun.sh b/qemurun.sh index c34e967..0a864cc 100755 --- a/qemurun.sh +++ b/qemurun.sh @@ -2,4 +2,4 @@ storage_device="${1}" -qemu-system-riscv32 -machine virt -bios none -drive if=none,format=raw,file="${storage_device}",id=disk1 -device virtio-blk-device,drive=disk1 -display sdl -device virtio-gpu-device -serial stdio -m 10M -device loader,cpu-num=0,file=target/riscv32imac-unknown-none-elf/release/lbos -monitor telnet:127.0.0.1:1235,server,nowait -d guest_errors,unimp \ No newline at end of file +qemu-system-riscv32 -machine virt -bios none -drive if=none,format=raw,file="${storage_device}",id=disk1 -device virtio-blk-device,drive=disk1 -display gtk -device virtio-gpu-device -device virtio-keyboard-device -serial stdio -m 10M -device loader,cpu-num=0,file=target/riscv32imac-unknown-none-elf/release/lbos -monitor telnet:127.0.0.1:1235,server,nowait -d guest_errors,unimp \ No newline at end of file diff --git a/src/arch/virt/asm/linker.ld b/src/arch/virt/asm/linker.ld index 31029b4..bd14a1d 100644 --- a/src/arch/virt/asm/linker.ld +++ b/src/arch/virt/asm/linker.ld @@ -60,9 +60,13 @@ SECTIONS { PROVIDE(_heap_size = _MEM_END - _heap_start); PROVIDE(_virtio_queue_1_start = ORIGIN(virtqueues)); - PROVIDE(_virtio_queue_1_end = _virtio_queue_1_start + 0x10000); + PROVIDE(_virtio_queue_1_end = _virtio_queue_1_start + 0x2000); PROVIDE(_virtio_queue_2_start = _virtio_queue_1_end); - PROVIDE(_virtio_queue_2_end = _virtio_queue_2_start + 0x10000); + PROVIDE(_virtio_queue_2_end = _virtio_queue_2_start + 0x2000); + PROVIDE(_virtio_queue_3_start = _virtio_queue_2_end); + PROVIDE(_virtio_queue_3_end = _virtio_queue_3_start + 0x2000); + PROVIDE(_virtio_queue_4_start = _virtio_queue_3_end); + PROVIDE(_virtio_queue_4_end = _virtio_queue_4_start + 0x2000); PROVIDE(_framebuffer_start = ORIGIN(framebuffer)); } \ No newline at end of file diff --git a/src/dev/virtio/input.rs b/src/dev/virtio/input.rs new file mode 100644 index 0000000..fe06bc0 --- /dev/null +++ b/src/dev/virtio/input.rs @@ -0,0 +1,294 @@ +use crate::dev::virtio::{Descriptor, VirtQueue, VIRTIO_DESC_F_WRITE, VIRTIO_MMIO_GUEST_FEATURES, VIRTIO_MMIO_GUEST_PAGE_SIZE, VIRTIO_MMIO_QUEUE_NUM, VIRTIO_MMIO_QUEUE_NUM_MAX, VIRTIO_MMIO_QUEUE_PFN, VIRTIO_MMIO_QUEUE_SEL, VIRTIO_MMIO_STATUS, VIRTIO_MMIO_STATUS_ACKNOWLEDGE, VIRTIO_MMIO_STATUS_DRIVER, VIRTIO_MMIO_STATUS_DRIVER_OK, VIRTIO_MMIO_STATUS_FAILED, VIRTIO_MMIO_STATUS_FEATURES_OK, VIRTIO_QUEUE_SIZE}; +use crate::trafficcontrol::TrafficControl; + +unsafe extern "C" { + fn _virtio_queue_3_start(); + fn _virtio_queue_4_start(); +} + +pub const VIRTIO_INPUT_EVENT_TYPE_KEYBOARD: u16 = 1; + +#[repr(C)] +pub struct Event { + pub event_type: u16, + pub code: u16, + pub value: u32, +} + +pub const VIRTIO_INPUT_EVENTBUFFER_SIZE: usize = 8; + +pub struct VirtIoInputDevice { + pub addr: usize, + pub queue: usize, + pub idx: u16, + pub ack_used_idx: u16, + pub status_queue: usize, + pub status_queue_idx: u16, + pub status_queue_ack_used_idx: u16, + pub event_buffer: usize, +} + +pub enum VirtIoInputDeviceError { + FeatureSetMismatch, + QueueSetupFailed, +} + +impl VirtIoInputDevice { + pub fn new_and_init( + tc: &mut TrafficControl, + addr: usize, + ) -> Result { + // reset device (write 0 to status) + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(0); + } + // set ack bit + let mut status = VIRTIO_MMIO_STATUS_ACKNOWLEDGE; + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(status); + } + // set driver bit + status |= VIRTIO_MMIO_STATUS_DRIVER; + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(status); + } + // send feature set + let guest_features = 0; // todo: configure properly + unsafe { + ((addr + VIRTIO_MMIO_GUEST_FEATURES) as *mut u32).write_volatile(guest_features); + } + status |= VIRTIO_MMIO_STATUS_FEATURES_OK; + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(status); + } + // make sure features ok is still set, otherwise failed + if unsafe { ((addr + VIRTIO_MMIO_STATUS) as *const u32).read_volatile() } + & VIRTIO_MMIO_STATUS_FEATURES_OK + == 0 + { + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(VIRTIO_MMIO_STATUS_FAILED); + } + return Err(VirtIoInputDeviceError::FeatureSetMismatch); + } + + // setup event queue + let queue_max_by_device = + unsafe { ((addr + VIRTIO_MMIO_QUEUE_NUM_MAX) as *const u32).read_volatile() }; + if queue_max_by_device < VIRTIO_QUEUE_SIZE as _ { + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(VIRTIO_MMIO_STATUS_FAILED); + } + return Err(VirtIoInputDeviceError::QueueSetupFailed); + } + unsafe { + ((addr + VIRTIO_MMIO_QUEUE_NUM) as *mut u32).write_volatile(VIRTIO_QUEUE_SIZE as _); + } + unsafe { + ((addr + VIRTIO_MMIO_QUEUE_SEL) as *mut u32).write_volatile(0); + } + let event_queue_ptr = _virtio_queue_3_start as usize; + // zero out queue + for i in 0..size_of::() { + unsafe { + ((event_queue_ptr + i) as *mut u8).write_volatile(0); + } + } + unsafe { + ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile( + 4096 + ); + } + unsafe { + ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32).write_volatile(event_queue_ptr as u32 / 4096); + } + + // setup status queue + unsafe { + ((addr + VIRTIO_MMIO_QUEUE_SEL) as *mut u32).write_volatile(1); + } + let status_queue_ptr = _virtio_queue_4_start as usize; + // zero out queue + for i in 0..size_of::() { + unsafe { + ((status_queue_ptr + i) as *mut u8).write_volatile(0); + } + } + unsafe { + ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile( + 4096 + ); + } + unsafe { + ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32).write_volatile(status_queue_ptr as u32 / 4096); + } + + // all done! + status |= VIRTIO_MMIO_STATUS_DRIVER_OK; + unsafe { + ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(status); + } + + let event_buffer_ptr = unsafe { + tc.memory_manager.as_mut().unwrap_unchecked().alloc_n_blocks((size_of::() * VIRTIO_INPUT_EVENTBUFFER_SIZE).div_ceil(512)) + }; + + let mut input = VirtIoInputDevice { + addr, + queue: event_queue_ptr, + idx: 0, + ack_used_idx: 0, + status_queue: status_queue_ptr, + status_queue_idx: 0, + status_queue_ack_used_idx: 0, + event_buffer: event_buffer_ptr as usize, + }; + for i in 0..VIRTIO_INPUT_EVENTBUFFER_SIZE { + input.fill_event(i); + } + + + Ok(input) + } + + fn fill_event(&mut self, eventi: usize) { + let desc = Descriptor { + addr: self.event_buffer as u64 + (eventi * size_of::()) as u64, + len: size_of::() as u32, + flags: VIRTIO_DESC_F_WRITE, + next: 0, + }; + let head = self.idx; + let queue = unsafe { &mut (*(self.queue as *mut VirtQueue)) }; + queue.desc[self.idx as usize] = desc; + self.idx = (self.idx + 1) % VIRTIO_QUEUE_SIZE as u16; + queue.avail.ring[queue.avail.idx as usize % VIRTIO_QUEUE_SIZE] = head; + queue.avail.idx = queue.avail.idx.wrapping_add(1); + } + + pub fn pending(&mut self, tc: &mut TrafficControl) { + // event queue + let queue = unsafe { &(*(self.queue as *mut VirtQueue)) }; + while self.ack_used_idx != queue.used.idx { + let elem = &queue.used.ring[self.ack_used_idx as usize % VIRTIO_QUEUE_SIZE]; + self.ack_used_idx = self.ack_used_idx.wrapping_add(1); + let desc = &queue.desc[elem.id as usize]; + let event = unsafe { &*(desc.addr as *const Event) }; + self.fill_event(elem.id as usize); + + match event.event_type { + x if x == VIRTIO_INPUT_EVENT_TYPE_KEYBOARD => { + // todo: handle key events + { + let uart = crate::arch::serial_port(); + if let Some(uart) = uart { + uart.putstr("keybd "); + uart.put_bytes(&crate::strprint::u32_hex(event.code as u32)); + uart.putstr("\n"); + } + } + } + _ => { + } + } + } + + // status queue + let queue = unsafe { &(*(self.status_queue as *mut VirtQueue)) }; + while self.status_queue_ack_used_idx != queue.used.idx { + let elem = &queue.used.ring[self.status_queue_ack_used_idx as usize % VIRTIO_QUEUE_SIZE]; + let desc = &queue.desc[elem.id as usize]; + let event = unsafe { &*(desc.addr as *const Event) }; + self.status_queue_ack_used_idx = self.status_queue_ack_used_idx.wrapping_add(1); + } + } +} + + +// linux keycodes +#[repr(u32)] +pub enum LinuxKeycode { + ESC = 1, + Key1 = 2, + Key2 = 3, + Key3 = 4, + Key4 = 5, + Key5 = 6, + Key6 = 7, + Key7 = 8, + Key8 = 9, + Key9 = 10, + Key0 = 11, + Minus = 12, + Equal = 13, + Backspace = 14, + Tab = 15, + Q = 16, + W = 17, + E = 18, + R = 19, + T = 20, + Y = 21, + U = 22, + I = 23, + O = 24, + P = 25, + LeftBracket = 26, + RightBracket = 27, + Enter = 28, + LeftControl = 29, + A = 30, + S = 31, + D = 32, + F = 33, + G = 34, + H = 35, + J = 36, + K = 37, + L = 38, + Semicolon = 39, + Apostrophe = 40, + Grave = 41, + LeftShift = 42, + Backslash = 43, + Z = 44, + X = 45, + C = 46, + V = 47, + B = 48, + N = 49, + M = 50, + Comma = 51, + Dot = 52, + Slash = 53, + RightShift = 54, + KPAsterisk = 55, + LeftAlt = 56, + Space = 57, + CapsLock = 58, + F1 = 59, + F2 = 60, + F3 = 61, + F4 = 62, + F5 = 63, + F6 = 64, + F7 = 65, + F8 = 66, + F9 = 67, + F10 = 68, + NumLock = 69, + ScrollLock = 70, + KP7 = 71, + KP8 = 72, + KP9 = 73, + KPMinus = 74, + KP4 = 75, + KP5 = 76, + KP6 = 77, + KPPlus = 78, + KP1 = 79, + KP2 = 80, + KP3 = 81, + KP0 = 82, + KPDot = 83, +} \ No newline at end of file diff --git a/src/dev/virtio/mod.rs b/src/dev/virtio/mod.rs index a838e87..515322d 100644 --- a/src/dev/virtio/mod.rs +++ b/src/dev/virtio/mod.rs @@ -5,6 +5,7 @@ use core::sync::atomic::Ordering; use crate::dev::{FRAMEBUFFER_ADDR, FRAMEBUFFER_BPP}; use crate::dev::virtio::block::{VirtIoBlockDevice, VirtIoBlockDeviceError}; use crate::dev::virtio::gpu::{VirtIoGpuDevice, VirtIoGpuDeviceError}; +use crate::dev::virtio::input::{VirtIoInputDevice, VirtIoInputDeviceError}; use crate::rough_panic; use crate::spinlock::Spinlock; use crate::strprint::twodigit; @@ -12,6 +13,7 @@ use crate::trafficcontrol::{TrafficControl}; mod block; mod gpu; +mod input; pub const VIRTIO_MMIO_START: usize = 0x1000_1000; pub const VIRTIO_MMIO_END: usize = 0x1000_8000; @@ -46,6 +48,7 @@ pub static VIRTIO_GPU_DEVICE: Spinlock> = Spinlock::new(None); pub enum VirtIoDevice { BlockDevice(VirtIoBlockDevice), GPUDevice(VirtIoGpuDevice), + InputDevice(VirtIoInputDevice), } #[repr(C)] @@ -159,6 +162,29 @@ pub fn probe_virtio_devices(tc: &mut TrafficControl) { } } } + 18 => { + // input device + let input_device = VirtIoInputDevice::new_and_init(tc, addr); + if let Ok(input_device) = input_device { + devices[i] = Some(VirtIoDevice::InputDevice(input_device)); + if let Some(serial_port) = &serial_port { + serial_port.putstr("virtio input device found\n"); + } + } else if let Err(e) = input_device { + match e { + VirtIoInputDeviceError::FeatureSetMismatch => { + if let Some(serial_port) = &serial_port { + serial_port.putstr("virtio input device feature mismatch\n"); + } + } + VirtIoInputDeviceError::QueueSetupFailed => { + if let Some(serial_port) = &serial_port { + serial_port.putstr("virtio input device queue setup failed\n"); + } + } + } + } + } x => { if let Some(serial_port) = &serial_port { serial_port.putstr("unsupported device type "); @@ -187,7 +213,6 @@ pub fn handle_interrupt(interrupt: u32, tc: &mut TrafficControl) { } } VirtIoDevice::GPUDevice(gpudev) => { - return; let gpu = { let lock = VIRTIO_GPU_DEVICE.lock(); *lock @@ -198,6 +223,13 @@ pub fn handle_interrupt(interrupt: u32, tc: &mut TrafficControl) { } } } + VirtIoDevice::InputDevice(inputdev) => { + { + let uart = crate::uart::UART::new(0x1000_0000); + uart.putstr("input device interrupt\n"); + } + inputdev.pending(tc); + } } } } From a65ba1e487c9da942f46c1565710b3105d34ad53 Mon Sep 17 00:00:00 2001 From: husky Date: Thu, 11 Sep 2025 18:06:24 -0700 Subject: [PATCH 2/3] keyboards are working --- src/dev/virtio/input.rs | 134 +++++++++++++++++++++++++++++++++------- 1 file changed, 110 insertions(+), 24 deletions(-) diff --git a/src/dev/virtio/input.rs b/src/dev/virtio/input.rs index fe06bc0..afdea47 100644 --- a/src/dev/virtio/input.rs +++ b/src/dev/virtio/input.rs @@ -1,4 +1,11 @@ -use crate::dev::virtio::{Descriptor, VirtQueue, VIRTIO_DESC_F_WRITE, VIRTIO_MMIO_GUEST_FEATURES, VIRTIO_MMIO_GUEST_PAGE_SIZE, VIRTIO_MMIO_QUEUE_NUM, VIRTIO_MMIO_QUEUE_NUM_MAX, VIRTIO_MMIO_QUEUE_PFN, VIRTIO_MMIO_QUEUE_SEL, VIRTIO_MMIO_STATUS, VIRTIO_MMIO_STATUS_ACKNOWLEDGE, VIRTIO_MMIO_STATUS_DRIVER, VIRTIO_MMIO_STATUS_DRIVER_OK, VIRTIO_MMIO_STATUS_FAILED, VIRTIO_MMIO_STATUS_FEATURES_OK, VIRTIO_QUEUE_SIZE}; +use core::sync::atomic::{AtomicBool, Ordering}; +use crate::dev::virtio::{ + Descriptor, VIRTIO_DESC_F_WRITE, VIRTIO_MMIO_GUEST_FEATURES, VIRTIO_MMIO_GUEST_PAGE_SIZE, + VIRTIO_MMIO_QUEUE_NUM, VIRTIO_MMIO_QUEUE_NUM_MAX, VIRTIO_MMIO_QUEUE_PFN, VIRTIO_MMIO_QUEUE_SEL, + VIRTIO_MMIO_STATUS, VIRTIO_MMIO_STATUS_ACKNOWLEDGE, VIRTIO_MMIO_STATUS_DRIVER, + VIRTIO_MMIO_STATUS_DRIVER_OK, VIRTIO_MMIO_STATUS_FAILED, VIRTIO_MMIO_STATUS_FEATURES_OK, + VIRTIO_QUEUE_SIZE, VirtQueue, +}; use crate::trafficcontrol::TrafficControl; unsafe extern "C" { @@ -74,7 +81,7 @@ impl VirtIoInputDevice { // setup event queue let queue_max_by_device = - unsafe { ((addr + VIRTIO_MMIO_QUEUE_NUM_MAX) as *const u32).read_volatile() }; + unsafe { ((addr + VIRTIO_MMIO_QUEUE_NUM_MAX) as *const u32).read_volatile() }; if queue_max_by_device < VIRTIO_QUEUE_SIZE as _ { unsafe { ((addr + VIRTIO_MMIO_STATUS) as *mut u32).write_volatile(VIRTIO_MMIO_STATUS_FAILED); @@ -95,12 +102,11 @@ impl VirtIoInputDevice { } } unsafe { - ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile( - 4096 - ); + ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile(4096); } unsafe { - ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32).write_volatile(event_queue_ptr as u32 / 4096); + ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32) + .write_volatile(event_queue_ptr as u32 / 4096); } // setup status queue @@ -115,12 +121,11 @@ impl VirtIoInputDevice { } } unsafe { - ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile( - 4096 - ); + ((addr + VIRTIO_MMIO_GUEST_PAGE_SIZE) as *mut u32).write_volatile(4096); } unsafe { - ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32).write_volatile(status_queue_ptr as u32 / 4096); + ((addr + VIRTIO_MMIO_QUEUE_PFN) as *mut u32) + .write_volatile(status_queue_ptr as u32 / 4096); } // all done! @@ -130,7 +135,10 @@ impl VirtIoInputDevice { } let event_buffer_ptr = unsafe { - tc.memory_manager.as_mut().unwrap_unchecked().alloc_n_blocks((size_of::() * VIRTIO_INPUT_EVENTBUFFER_SIZE).div_ceil(512)) + tc.memory_manager + .as_mut() + .unwrap_unchecked() + .alloc_n_blocks((size_of::() * VIRTIO_INPUT_EVENTBUFFER_SIZE).div_ceil(512)) }; let mut input = VirtIoInputDevice { @@ -147,7 +155,6 @@ impl VirtIoInputDevice { input.fill_event(i); } - Ok(input) } @@ -178,25 +185,44 @@ impl VirtIoInputDevice { match event.event_type { x if x == VIRTIO_INPUT_EVENT_TYPE_KEYBOARD => { - // todo: handle key events - { - let uart = crate::arch::serial_port(); - if let Some(uart) = uart { - uart.putstr("keybd "); - uart.put_bytes(&crate::strprint::u32_hex(event.code as u32)); - uart.putstr("\n"); + let keycode = event.code; + let down = event.value == 1; + + // first, handle shift todo: handle more control characters + if keycode == LinuxKeycode::LeftShift as u16 || keycode == LinuxKeycode::RightShift as u16 { + UPPERCASE.store(down, Ordering::Relaxed); + } + + // next, handle ascii characters + if !down { // write on UP + let ascii = KEYMAP_ASCII.iter().find_map(|(a, b)| { + if keycode == *a as u16 { + Some(*b) + } else { + None + } + }); + if let Some(mut ascii) = ascii { + if UPPERCASE.load(Ordering::Relaxed) { + if ascii.is_ascii_alphabetic() { + ascii = ascii.to_ascii_uppercase(); + } else { + // todo: handle other characters + } + } + tc.write_inbuf(ascii); } } } - _ => { - } + _ => {} } } // status queue let queue = unsafe { &(*(self.status_queue as *mut VirtQueue)) }; while self.status_queue_ack_used_idx != queue.used.idx { - let elem = &queue.used.ring[self.status_queue_ack_used_idx as usize % VIRTIO_QUEUE_SIZE]; + let elem = + &queue.used.ring[self.status_queue_ack_used_idx as usize % VIRTIO_QUEUE_SIZE]; let desc = &queue.desc[elem.id as usize]; let event = unsafe { &*(desc.addr as *const Event) }; self.status_queue_ack_used_idx = self.status_queue_ack_used_idx.wrapping_add(1); @@ -204,9 +230,11 @@ impl VirtIoInputDevice { } } +static UPPERCASE: AtomicBool = AtomicBool::new(false); // linux keycodes -#[repr(u32)] +#[repr(u16)] +#[derive(Copy, Clone)] pub enum LinuxKeycode { ESC = 1, Key1 = 2, @@ -291,4 +319,62 @@ pub enum LinuxKeycode { KP3 = 81, KP0 = 82, KPDot = 83, -} \ No newline at end of file +} + +// keys that do not map directly are handled outside of this +const KEYMAP_ASCII: &[(LinuxKeycode, u8)] = &[ + (LinuxKeycode::ESC, 0x1B), + (LinuxKeycode::Key1, b'1'), + (LinuxKeycode::Key2, b'2'), + (LinuxKeycode::Key3, b'3'), + (LinuxKeycode::Key4, b'4'), + (LinuxKeycode::Key5, b'5'), + (LinuxKeycode::Key6, b'6'), + (LinuxKeycode::Key7, b'7'), + (LinuxKeycode::Key8, b'8'), + (LinuxKeycode::Key9, b'9'), + (LinuxKeycode::Key0, b'0'), + (LinuxKeycode::Minus, b'-'), + (LinuxKeycode::Equal, b'='), + (LinuxKeycode::Backspace, 0x7F), + (LinuxKeycode::Tab, 0x9), + (LinuxKeycode::Q, b'q'), + (LinuxKeycode::W, b'w'), + (LinuxKeycode::E, b'e'), + (LinuxKeycode::R, b'r'), + (LinuxKeycode::T, b't'), + (LinuxKeycode::Y, b'y'), + (LinuxKeycode::U, b'u'), + (LinuxKeycode::I, b'i'), + (LinuxKeycode::O, b'o'), + (LinuxKeycode::P, b'p'), + (LinuxKeycode::LeftBracket, b'['), + (LinuxKeycode::RightBracket, b']'), + (LinuxKeycode::Enter, b'\r'), + (LinuxKeycode::A, b'a'), + (LinuxKeycode::S, b's'), + (LinuxKeycode::D, b'd'), + (LinuxKeycode::F, b'f'), + (LinuxKeycode::G, b'g'), + (LinuxKeycode::H, b'h'), + (LinuxKeycode::J, b'j'), + (LinuxKeycode::K, b'k'), + (LinuxKeycode::L, b'l'), + (LinuxKeycode::Semicolon, b';'), + (LinuxKeycode::Apostrophe, b'\''), + (LinuxKeycode::Grave, b'`'), + (LinuxKeycode::LeftShift, b'/'), + (LinuxKeycode::Backslash, b'\\'), + (LinuxKeycode::Z, b'z'), + (LinuxKeycode::X, b'x'), + (LinuxKeycode::C, b'c'), + (LinuxKeycode::V, b'v'), + (LinuxKeycode::B, b'b'), + (LinuxKeycode::N, b'n'), + (LinuxKeycode::M, b'm'), + (LinuxKeycode::Comma, b','), + (LinuxKeycode::Dot, b'.'), + (LinuxKeycode::Slash, b'/'), + (LinuxKeycode::KPAsterisk, b'*'), + (LinuxKeycode::Space, b' '), +]; From 4d9c24c9b40b3eb22dde2a30e62b481bc11c479b Mon Sep 17 00:00:00 2001 From: husky Date: Thu, 11 Sep 2025 18:20:27 -0700 Subject: [PATCH 3/3] remove some of those old print statements --- qemurun.sh | 2 +- src/dev/virtio/input.rs | 1 - src/dev/virtio/mod.rs | 4 ---- 3 files changed, 1 insertion(+), 6 deletions(-) diff --git a/qemurun.sh b/qemurun.sh index 0a864cc..11fd054 100755 --- a/qemurun.sh +++ b/qemurun.sh @@ -2,4 +2,4 @@ storage_device="${1}" -qemu-system-riscv32 -machine virt -bios none -drive if=none,format=raw,file="${storage_device}",id=disk1 -device virtio-blk-device,drive=disk1 -display gtk -device virtio-gpu-device -device virtio-keyboard-device -serial stdio -m 10M -device loader,cpu-num=0,file=target/riscv32imac-unknown-none-elf/release/lbos -monitor telnet:127.0.0.1:1235,server,nowait -d guest_errors,unimp \ No newline at end of file +qemu-system-riscv32 -machine virt -bios none -drive if=none,format=raw,file="${storage_device}",id=disk1 -device virtio-blk-device,drive=disk1 -display sdl -device virtio-gpu-device -device virtio-keyboard-device -serial stdio -m 10M -device loader,cpu-num=0,file=target/riscv32imac-unknown-none-elf/release/lbos -monitor telnet:127.0.0.1:1235,server,nowait -d guest_errors,unimp \ No newline at end of file diff --git a/src/dev/virtio/input.rs b/src/dev/virtio/input.rs index afdea47..1036262 100644 --- a/src/dev/virtio/input.rs +++ b/src/dev/virtio/input.rs @@ -363,7 +363,6 @@ const KEYMAP_ASCII: &[(LinuxKeycode, u8)] = &[ (LinuxKeycode::Semicolon, b';'), (LinuxKeycode::Apostrophe, b'\''), (LinuxKeycode::Grave, b'`'), - (LinuxKeycode::LeftShift, b'/'), (LinuxKeycode::Backslash, b'\\'), (LinuxKeycode::Z, b'z'), (LinuxKeycode::X, b'x'), diff --git a/src/dev/virtio/mod.rs b/src/dev/virtio/mod.rs index 515322d..2ebf89a 100644 --- a/src/dev/virtio/mod.rs +++ b/src/dev/virtio/mod.rs @@ -224,10 +224,6 @@ pub fn handle_interrupt(interrupt: u32, tc: &mut TrafficControl) { } } VirtIoDevice::InputDevice(inputdev) => { - { - let uart = crate::uart::UART::new(0x1000_0000); - uart.putstr("input device interrupt\n"); - } inputdev.pending(tc); } }