Some serial port fixes.

Tested with QEMU BIOS.

Author: jonathanpallant

src/commands/hardware.rs

@@ -15,8 +15,14 @@ pub static SHUTDOWN_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
         function: shutdown,
         parameters: &[
-            menu::Parameter::Named { parameter_name: "reboot", help: Some("Reboot after shutting down") },
-            menu::Parameter::Named { parameter_name: "bootloader", help: Some("Reboot into the bootloader after shutting down") }
+            menu::Parameter::Named {
+                parameter_name: "reboot",
+                help: Some("Reboot after shutting down"),
+            },
+            menu::Parameter::Named {
+                parameter_name: "bootloader",
+                help: Some("Reboot into the bootloader after shutting down"),
+            },
         ],
     },
     command: "shutdown",

src/commands/input.rs

@@ -13,15 +13,32 @@ pub static KBTEST_ITEM: menu::Item<Ctx> = menu::Item {
 
 /// Called when the "kbtest" command is executed.
 fn kbtest(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &mut Ctx) {
-    osprintln!("Press ESC to quit");
-    loop {
+    osprintln!("Press Ctrl-X to quit");
+    const CTRL_X: u8 = 0x18;
+    'outer: loop {
         if let Some(ev) = crate::STD_INPUT.lock().get_raw() {
             osprintln!("Event: {ev:?}");
-            if ev == pc_keyboard::DecodedKey::RawKey(pc_keyboard::KeyCode::Escape)
-                || ev == pc_keyboard::DecodedKey::Unicode('\u{001b}')
-            {
-                break;
+            if ev == pc_keyboard::DecodedKey::Unicode(CTRL_X as char) {
+                break 'outer;
+            }
+        }
+        let mut buffer = [0u8; 8];
+        let count = if let Some(serial) = crate::SERIAL_CONSOLE.lock().as_mut() {
+            serial
+                .read_data(&mut buffer)
+                .ok()
+                .and_then(|n| if n == 0 { None } else { Some(n) })
+        } else {
+            None
+        };
+        if let Some(count) = count {
+            osprintln!("Serial RX: {:x?}", &buffer[0..count]);
+            for b in &buffer[0..count] {
+                if *b == CTRL_X {
+                    break 'outer;
+                }
             }
         }
     }
+    osprintln!("Finished.");
 }

src/lib.rs

@@ -115,7 +115,7 @@ impl StdInput {
     /// The data you get might be cut in the middle of a UTF-8 character.
     fn get_data(&mut self, buffer: &mut [u8]) -> usize {
         let count = self.get_buffered_data(buffer);
-        if buffer.len() == 0 || count > 0 {
+        if buffer.is_empty() || count > 0 {
             return count;
         }
 
@@ -169,14 +169,14 @@ impl StdInput {
 #[macro_export]
 macro_rules! osprint {
     ($($arg:tt)*) => {
-        crate::VGA_CONSOLE.with(|guard| {
+        $crate::VGA_CONSOLE.with(|guard| {
             if let Some(console) = guard.as_mut() {
                 #[allow(unused)]
                 use core::fmt::Write as _;
                 write!(console, $($arg)*).unwrap();
             }
         }).unwrap();
-        crate::SERIAL_CONSOLE.with(|guard| {
+        $crate::SERIAL_CONSOLE.with(|guard| {
             if let Some(console) = guard.as_mut() {
                 #[allow(unused)]
                 use core::fmt::Write as _;
@@ -276,7 +276,11 @@ impl SerialConsole {
     fn read_data(&mut self, buffer: &mut [u8]) -> Result<usize, bios::Error> {
         let api = API.get();
         let ffi_buffer = bios::FfiBuffer::new(buffer);
-        let res = (api.serial_read)(self.0, ffi_buffer, bios::FfiOption::Some(bios::Timeout::new_ms(0)));
+        let res = (api.serial_read)(
+            self.0,
+            ffi_buffer,
+            bios::FfiOption::Some(bios::Timeout::new_ms(0)),
+        );
         res.into()
     }
 }
@@ -377,17 +381,20 @@ pub extern "C" fn os_main(api: &bios::Api) -> ! {
                 height as isize,
             );
             vga.clear();
-            let mut guard = VGA_CONSOLE.try_lock().unwrap();
+            let mut guard = VGA_CONSOLE.lock();
             *guard = Some(vga);
+            // Drop the lock before trying to grab it again to print something!
             drop(guard);
             osprintln!("\u{001b}[0mConfigured VGA console {}x{}", width, height);
         }
     }
 
     if let Some((idx, serial_config)) = config.get_serial_console() {
         let _ignored = (api.serial_configure)(idx, serial_config);
-        let mut guard = SERIAL_CONSOLE.try_lock().unwrap();
+        let mut guard = SERIAL_CONSOLE.lock();
         *guard = Some(SerialConsole(idx));
+        // Drop the lock before trying to grab it again to print something!
+        drop(guard);
         osprintln!("Configured Serial console on Serial {}", idx);
     }