hal: uart and serial support

TODO: test if the code works on uarts and pads other than those in the example

Signed-off-by: zhujunxing <zjx1319@hust.edu.cn>

Author: jakezhu9

Cargo.lock

@@ -11,6 +11,9 @@ repository.workspace = true
 [dependencies]
 sophgo-rom-rt = { version = "0.0.0", path = "../../sophgo-rom-rt" }
 panic-halt = "0.2.0"
+riscv = "0.11.0"
+embedded-io = "0.6.1"
+embedded-hal = "1.0.0"
 
 [[bin]]
 name = "hello-world"

examples/hello-world/Cargo.toml

@@ -4,13 +4,19 @@
 #![no_std]
 #![no_main]
 
+use embedded_io::Write;
 use panic_halt as _;
 use sophgo_rom_rt::{entry, Peripherals};
 
 #[entry]
 fn main(p: Peripherals) -> ! {
+    let uart0_tx = p.pads.uart0_tx.into_function(&p.pinmux);
+    let uart0_rx = p.pads.uart0_rx.into_function(&p.pinmux);
+
+    let mut serial = p.uart0.serial(Default::default(), (uart0_tx, uart0_rx));
+
     loop {
-        p.uart0.write(b"Hello World from Rust!\n");
-        // TODO fix Uart16550 crate bug; it doesn't block when UART FIFO is not empty
+        writeln!(serial, "Hello World from Rust!").ok();
+        riscv::asm::delay(10_000_000);
     }
 }

examples/hello-world/src/main.rs

@@ -10,9 +10,9 @@ repository.workspace = true
 
 [dependencies]
 base-address = "0.0.0"
-uart16550 = "0.0.1"
 volatile-register = "0.2.1"
 embedded-hal = "1.0.0"
+embedded-io = "0.6.1"
 
 [dev-dependencies]
 memoffset = "0.9.0"

sophgo-hal/Cargo.toml

@@ -2,18 +2,19 @@
 
 pub mod gpio;
 pub mod pad;
+pub mod uart;
 
 use core::ops;
 
 use base_address::BaseAddress;
 
 /// Universal Asynchronous Receiver/Transmitter.
-pub struct UART<A: BaseAddress> {
+pub struct UART<A: BaseAddress, const I: usize> {
     base: A,
 }
 
-impl<A: BaseAddress> ops::Deref for UART<A> {
-    type Target = uart16550::Uart16550<u32>;
+impl<A: BaseAddress, const I: usize> ops::Deref for UART<A, I> {
+    type Target = uart::RegisterBlock;
 
     #[inline(always)]
     fn deref(&self) -> &Self::Target {

sophgo-hal/src/lib.rs

@@ -5,6 +5,7 @@ use core::marker::PhantomData;
 use volatile_register::RW;
 
 /// The `PINMUX` pad multiplexer peripheral.
+#[repr(C)]
 pub struct PinMux {
     /// Pad function multiplexer registers for all the pads.
     pub fmux: FMux,
@@ -21,32 +22,74 @@ impl AsRef<FMux> for PinMux {
 }
 
 /// Pad function multiplexer registers for all the pads.
+#[repr(C)]
 pub struct FMux {
-    _reserved0: [u8; 0xAC],
+    _reserved0: [u8; 0x40],
+    /// UART-0 TX pad function.
+    pub uart0_tx: RW<u32>,
+    /// UART-0 RX pad function.
+    pub uart0_rx: RW<u32>,
+    _reserved1: [u8; 0x28],
+    /// I2C-0 Serial Clock (SCL) pad function.
+    pub i2c0_scl: RW<u32>,
+    /// I2C-0 Serial Data (SDA) pad function.
+    pub i2c0_sda: RW<u32>,
+    _reserved2: [u8; 0x34],
     /// Power (RTC) domain GPIO-2 pad function.
     pub pwr_gpio2: RW<u32>,
     // TODO other fields and padding
+    _reserved3: [u8; 0x1750],
 }
 
 impl FMux {
     /// Gets the pad function multiplexer register for the given pad number `N`.
     #[inline]
     pub fn fmux<const N: usize>(&self) -> &RW<u32> {
         match N {
+            18 => &self.uart0_tx,
+            19 => &self.uart0_rx,
+            28 => &self.i2c0_scl,
+            29 => &self.i2c0_sda,
             49 => &self.pwr_gpio2,
             _ => todo!(),
         }
     }
 }
 
 /// Non-RTC domain pad configurations.
+#[repr(C)]
 pub struct PadConfigs {
-    // TODO
+    _reserved0: [u8; 0x10C],
+    /// Non-RTC domain UART-0 TX pad configurations.
+    pub uart0_tx: RW<PadConfig>,
+    /// Non-RTC domain UART-0 RX pad configurations.
+    pub uart0_rx: RW<PadConfig>,
+    _reserved1: [u8; 0x28],
+    /// Non-RTC domain i2c-0 SCL pad configurations.
+    pub i2c0_scl: RW<PadConfig>,
+    /// Non-RTC domain i2c-0 SDA pad configurations.
+    pub i2c0_sda: RW<PadConfig>,
 }
 
-// TODO fn pad_config in impl PadConfigs
+impl PadConfigs {
+    /// Gets the pad configuration register for the given pad number `N`.
+    ///
+    /// `N` must be number of a pad in the non-RTC domain.
+    #[inline]
+    const fn pad_config<const N: usize>(&self) -> &RW<PadConfig> {
+        match N {
+            18 => &self.uart0_tx,
+            19 => &self.uart0_rx,
+            28 => &self.i2c0_scl,
+            29 => &self.i2c0_sda,
+            // if not a non-RTC pad, return unimplemented!()
+            _ => todo!(),
+        }
+    }
+}
 
 /// Power (RTC) domain pad configurations.
+#[repr(C)]
 pub struct PwrPadConfigs {
     _reserved0: [u8; 0x34],
     /// Power (RTC) domain GPIO-2 pad configuration.
@@ -138,11 +181,14 @@ impl<A: BaseAddress, const N: usize, F> Pad<A, N, F> {
         }
     }
     #[inline]
-    fn pad_config(&self) -> &RW<PadConfig> {
+    pub fn pad_config(&self) -> &RW<PadConfig> {
         match N {
             // TODO in range of power pads ...
             49 => unsafe { &*(self.base.ptr() as *const PwrPadConfigs) }.pad_config::<N>(),
             // TODO in range of conventional pads ...
+            18..=19 | 28..=29 => {
+                unsafe { &*(self.base.ptr() as *const PadConfigs) }.pad_config::<N>()
+            }
             // .. => { ... }
             _ => todo!(),
         }
@@ -174,6 +220,9 @@ pub struct PullUp;
 /// Floating as pull mode (type state).
 pub struct Floating;
 
+/// UART function (type state).
+pub struct UartFunc<const I: usize>;
+
 /// Trait for all valid pad functions.
 pub trait Function {
     /// Pull direction associated with this pad function.
@@ -214,6 +263,32 @@ const fn gpio_fmux<const N: usize>() -> u32 {
     }
 }
 
+impl<const I: usize> Function for UartFunc<I> {
+    const PULL: Pull = Pull::Up;
+    #[inline]
+    fn fmux<const N: usize>() -> u32 {
+        uart_fmux::<N, I>()
+    }
+}
+
+const fn uart_fmux<const N: usize, const I: usize>() -> u32 {
+    match I {
+        0 => match N {
+            18..=19 => 0,
+            _ => unimplemented!(),
+        },
+        1 => match N {
+            28..=29 => 1,
+            _ => unimplemented!(),
+        },
+        2 => match N {
+            28..=29 => 2,
+            _ => unimplemented!(),
+        },
+        _ => unimplemented!(),
+    }
+}
+
 /// Pad internal pull direction values.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[repr(u8)]
@@ -225,3 +300,32 @@ pub enum Pull {
     /// Internally pulled down.
     Down = 2,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{FMux, PadConfigs, PinMux};
+    use memoffset::offset_of;
+
+    #[test]
+    fn struct_pinmux_offset() {
+        assert_eq!(offset_of!(PinMux, fmux), 0x00);
+        assert_eq!(offset_of!(PinMux, config), 0x1800);
+    }
+
+    #[test]
+    fn struct_fmux_offset() {
+        assert_eq!(offset_of!(FMux, uart0_tx), 0x40);
+        assert_eq!(offset_of!(FMux, uart0_rx), 0x44);
+        assert_eq!(offset_of!(FMux, i2c0_scl), 0x70);
+        assert_eq!(offset_of!(FMux, i2c0_sda), 0x74);
+        assert_eq!(offset_of!(FMux, pwr_gpio2), 0xAC);
+    }
+
+    #[test]
+    fn struct_pad_configs_offset() {
+        assert_eq!(offset_of!(PadConfigs, uart0_tx), 0x190C - 0x1800);
+        assert_eq!(offset_of!(PadConfigs, uart0_rx), 0x1910 - 0x1800);
+        assert_eq!(offset_of!(PadConfigs, i2c0_scl), 0x193C - 0x1800);
+        assert_eq!(offset_of!(PadConfigs, i2c0_sda), 0x1940 - 0x1800);
+    }
+}