Remove qemu uart driver, the raspi3 UART driver works with qemu

src/bsp/mod.rs

@@ -1,8 +1,6 @@
 //! Board Support Package: module containing implementation 
 //! specific to a board.
 
-pub mod qemu;
-
 #[cfg(feature = "target_rpi3")]
 pub mod rpi3;
 

src/bsp/qemu/console.rs

@@ -1,106 +0,0 @@
-//! Implement the Qemu magic UART.
-
-use core::fmt;
-
-use crate::traits::console::{Console, Read, Write};
-use crate::traits::synchronization::{DummyMutex, Mutex};
-
-/// The address for the magic qemu uart
-const QEMU_MAGIC_UART_ADDR: *mut u8 = 0x3F20_1000 as *mut u8;
-const QEMU_MAGIC_UART_ADDR_FR: *mut u8 = 0x3F20_1018 as *mut u8;
-
-/// The unique QemuUart allowing access to the qemu uart.
-static QEMU_UART: QemuUart = QemuUart::new();
-
-/// A structure allowing access to the qemu magic uart.
-struct QemuUart {
-    inner: DummyMutex<QemuUartInner>,
-}
-
-/// Inner Qemu Uart.
-struct QemuUartInner;
-
-impl QemuUartInner {
-    /// Constructor for [`QemuUartInner`].
-    const fn new() -> Self {
-        Self {}
-    }
-
-    /// Write a character to the output.
-    fn write_char(&mut self, c: char) {
-        unsafe {
-            core::ptr::write_volatile(QEMU_MAGIC_UART_ADDR, c as u8);
-        }
-    }
-
-    /// Read a character from the uart.
-    fn read_char(&mut self) -> char {
-        loop {
-            let fr = unsafe { core::ptr::read_volatile(QEMU_MAGIC_UART_ADDR_FR) };
-            if fr & 0b1_0000 == 0 {
-                break;
-            }
-        }
-        unsafe {
-            core::ptr::read_volatile(QEMU_MAGIC_UART_ADDR) as u8 as char
-        }
-    }
-}
-
-impl QemuUart {
-    /// Constructor for [`QemuUart`].
-    pub const fn new() -> Self {
-        Self {
-            inner: DummyMutex::new(QemuUartInner::new()),
-        }
-    }
-}
-
-/// Allow to use QemuUartInner for print! and formating macros.
-/// `write_str` needs `&mut self` (mutable ref), so we can implement 
-/// it only on the inner type, the `QemuUart` need to be manipulable
-/// using unmutable references (`&self`), so we will use a custom 
-/// interface for it.
-impl fmt::Write for QemuUartInner {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.chars() {
-            // \n -> \r\n
-            if c == '\n' {
-                self.write_char('\r');
-            }
-            self.write_char(c);
-        }
-        Ok(())
-    }
-}
-
-impl Write for QemuUart {
-    fn write_char(&self, c: char) {
-        self.inner.lock(|q_out| q_out.write_char(c))
-    }
-
-    fn write_fmt(&self, args: fmt::Arguments) -> fmt::Result {
-        self.inner.lock(|q_out| fmt::Write::write_fmt(q_out, args))
-    }
-
-    /// Empty function, the qemu uart has no buffering afaik
-    fn flush(&self) {
-        // self.inner.lock(|q_out| q_out.flush())
-    }
-}
-
-impl Read for QemuUart {
-    fn read_char(&self) -> char {
-        self.inner.lock(|q_in| q_in.read_char())
-    }
-
-    fn flush_input(&self) {}
-}
-
-impl Console for QemuUart {}
-
-// TODO: move? 
-/// Return a reference to the Qemu Uart.
-pub fn console() -> &'static dyn Console {
-    &QEMU_UART
-}

src/bsp/qemu/mod.rs

@@ -1,7 +0,0 @@
-//! Implement the features specific to code running inside qemu.
-//!
-//! # TODO
-//!
-//! Move this somewhere else?
-
-pub mod console;

src/main.rs

@@ -27,7 +27,6 @@ use core::arch::global_asm;
 use core::arch::asm;
 
 // TODO: handle this with features
-//use crate::bsp::qemu::console::console;
 #[cfg(not(test))]
 use crate::bsp::rpi3::uart::console;
 #[cfg(not(test))]