hal: change to fixed base address for all modules

It simplifies types of structures. OS kernel developers may provide their own ownership model and use sophgo-hal by providing an AsRef implemenetation

Signed-off-by: Zhouqi Jiang <[email protected]>

Author: luojia65

Cargo.lock

@@ -0,0 +1,8 @@
+# Blinky example
+
+## Build
+
+```shell
+rustup target install riscv64imac-unknown-none-elf
+cargo build -p blinky --target riscv64imac-unknown-none-elf --release
+```

examples/blinky/README.md

@@ -1,6 +1,3 @@
-// rustup target install riscv64imac-unknown-none-elf
-// cargo build -p blinky --target riscv64imac-unknown-none-elf --release
-
 #![no_std]
 #![no_main]
 

examples/blinky/src/main.rs

@@ -0,0 +1,8 @@
+# Hello World example
+
+## Build
+
+```shell
+rustup target install riscv64imac-unknown-none-elf
+cargo build -p hello-world --target riscv64imac-unknown-none-elf --release
+```

examples/hello-world/README.md

@@ -1,12 +1,9 @@
-// rustup target install riscv64imac-unknown-none-elf
-// cargo build -p hello-world --target riscv64imac-unknown-none-elf --release
-
 #![no_std]
 #![no_main]
 
 use embedded_io::Write;
 use panic_halt as _;
-use sophgo_rom_rt::{entry, Peripherals};
+use sophgo_rom_rt::prelude::*;
 
 #[entry]
 fn main(p: Peripherals) -> ! {

examples/hello-world/src/main.rs

@@ -9,7 +9,6 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-base-address = "0.0.0"
 volatile-register = "0.2.1"
 embedded-hal = "1.0.0"
 embedded-io = "0.6.1"

sophgo-hal/Cargo.toml

@@ -1,10 +1,6 @@
 //! General Purpose Input/Output.
 
-use crate::{
-    pad::{GpioFunc, Pad, PullUp},
-    GPIO,
-};
-use base_address::BaseAddress;
+use crate::pad::{self, GpioFunc, Pad, PullUp};
 use core::marker::PhantomData;
 use embedded_hal::digital::{ErrorType, OutputPin};
 use volatile_register::{RO, RW, WO};
@@ -69,8 +65,8 @@ impl Direction {
 }
 
 /// Owned GPIO peripheral signal with mode type state.
-pub struct Gpio<A: BaseAddress, const I: u8, M> {
-    base: GPIO<A>,
+pub struct Gpio<T, const I: u8, M> {
+    inner: T,
     _mode: PhantomData<M>,
 }
 
@@ -80,7 +76,7 @@ pub struct Input;
 /// Output mode (type state).
 pub struct Output;
 
-impl<A: BaseAddress, const I: u8, M> Gpio<A, I, M> {
+impl<T: AsRef<RegisterBlock>, const I: u8, M> Gpio<T, I, M> {
     /// Configures the GPIO signal as a `GpioPad` operating as a pull up output.
     ///
     /// # Examples
@@ -93,16 +89,16 @@ impl<A: BaseAddress, const I: u8, M> Gpio<A, I, M> {
     /// let mut led = p.pwr_gpio.a2.into_pull_up_output(pad_led);
     /// ```
     #[inline]
-    pub fn into_pull_up_output<A2: BaseAddress, const N: usize>(
+    pub fn into_pull_up_output<U, const N: usize>(
         self,
-        pad: Pad<A2, N, GpioFunc<PullUp>>,
-    ) -> GpioPad<Gpio<A, I, Output>, Pad<A2, N, GpioFunc<PullUp>>> {
+        pad: Pad<U, N, GpioFunc<PullUp>>,
+    ) -> GpioPad<Gpio<T, I, Output>, Pad<U, N, GpioFunc<PullUp>>> {
         unsafe {
-            self.base.direction.modify(|w| w.set_output(I));
+            self.inner.as_ref().direction.modify(|w| w.set_output(I));
         }
         GpioPad {
             gpio: Gpio {
-                base: self.base,
+                inner: self.inner,
                 _mode: PhantomData,
             },
             pad,
@@ -116,12 +112,12 @@ pub struct GpioPad<T, U> {
     pad: U,
 }
 
-impl<A: BaseAddress, A2: BaseAddress, const I: u8, const N: usize, M, T>
-    GpioPad<Gpio<A, I, M>, Pad<A2, N, GpioFunc<T>>>
+impl<T: AsRef<RegisterBlock>, U: AsRef<pad::PadConfigs>, const I: u8, const N: usize, M>
+    GpioPad<Gpio<T, I, M>, Pad<U, N, GpioFunc<T>>>
 {
     /// Reconfigures the `GpioPad` to operate as a pull up output.
     #[inline]
-    pub fn into_pull_up_output(self) -> GpioPad<Gpio<A, I, Output>, Pad<A2, N, GpioFunc<PullUp>>> {
+    pub fn into_pull_up_output(self) -> GpioPad<Gpio<T, I, Output>, Pad<U, N, GpioFunc<PullUp>>> {
         let (gpio, pad) = self.into_inner();
         gpio.into_pull_up_output(pad.into_gpio_pull_up())
     }
@@ -139,19 +135,19 @@ impl<T, U> ErrorType for GpioPad<T, U> {
     type Error = core::convert::Infallible;
 }
 
-impl<A: BaseAddress, const I: u8, U> OutputPin for GpioPad<Gpio<A, I, Output>, U> {
+impl<T: AsRef<RegisterBlock>, const I: u8, U> OutputPin for GpioPad<Gpio<T, I, Output>, U> {
     #[inline]
     fn set_low(&mut self) -> Result<(), Self::Error> {
         unsafe {
-            self.gpio.base.data.modify(|w| w & !(1 << I));
+            self.gpio.inner.as_ref().data.modify(|w| w & !(1 << I));
         }
         Ok(())
     }
 
     #[inline]
     fn set_high(&mut self) -> Result<(), Self::Error> {
         unsafe {
-            self.gpio.base.data.modify(|w| w | (1 << I));
+            self.gpio.inner.as_ref().data.modify(|w| w | (1 << I));
         }
         Ok(())
     }

sophgo-hal/src/gpio.rs

@@ -4,55 +4,6 @@ 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, const I: usize> {
-    base: A,
-}
-
-impl<A: BaseAddress, const I: usize> ops::Deref for UART<A, I> {
-    type Target = uart::RegisterBlock;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*(self.base.ptr() as *const _) }
-    }
-}
-
-/// General Purpose Input/Output.
-pub struct GPIO<A: BaseAddress> {
-    base: A,
-}
-
-impl<A: BaseAddress> ops::Deref for GPIO<A> {
-    type Target = gpio::RegisterBlock;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*(self.base.ptr() as *const _) }
-    }
-}
-
-/// Pad function multiplexer peripheral.
-pub struct PINMUX<A: BaseAddress> {
-    base: A,
-}
-
-impl<A: BaseAddress> ops::Deref for PINMUX<A> {
-    type Target = pad::PinMux;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        unsafe { &*(self.base.ptr() as *const _) }
-    }
-}
-
-impl<A: BaseAddress> AsRef<pad::FMux> for PINMUX<A> {
-    #[inline(always)]
-    fn as_ref(&self) -> &pad::FMux {
-        &self.fmux
-    }
+pub mod prelude {
+    pub use crate::uart::UartExt as __sophgo_hal__uart__UartExt;
 }

sophgo-hal/src/lib.rs

@@ -1,6 +1,5 @@
 //! Silicon pad multiplexer and configurations.
 
-use base_address::BaseAddress;
 use core::marker::PhantomData;
 use volatile_register::RW;
 
@@ -164,43 +163,42 @@ impl PadConfig {
 }
 
 /// Ownership of a pad with function type state.
-pub struct Pad<A: BaseAddress, const N: usize, F> {
-    base: A,
+pub struct Pad<T, const N: usize, F> {
+    inner: T,
     _function: PhantomData<F>,
 }
 
-impl<A: BaseAddress, const N: usize, F> Pad<A, N, F> {
+impl<T: AsRef<PadConfigs>, const N: usize, F> Pad<T, N, F> {
     /// Converts the function of this pad.
     #[inline]
-    pub fn into_function<F2: Function>(self, fmux: impl AsRef<FMux>) -> Pad<A, N, F2> {
+    pub fn into_function<F2: Function>(self, fmux: impl AsRef<FMux>) -> Pad<T, N, F2> {
         unsafe { fmux.as_ref().fmux::<N>().write(F2::fmux::<N>()) };
         unsafe { self.pad_config().modify(|w| w.set_pull(F2::PULL)) };
         Pad {
-            base: self.base,
+            inner: self.inner,
             _function: PhantomData,
         }
     }
     #[inline]
     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>(),
+            49 => unsafe { &*(self.inner.as_ref() as *const _ 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>()
-            }
+            18..=19 | 28..=29 => self.inner.as_ref().pad_config::<N>(),
             // .. => { ... }
             _ => todo!(),
         }
     }
 }
 
-impl<A: BaseAddress, const N: usize, T> Pad<A, N, GpioFunc<T>> {
+impl<T: AsRef<PadConfigs>, const N: usize, F> Pad<T, N, GpioFunc<F>> {
     #[inline]
-    pub(crate) fn into_gpio_pull_up(self) -> Pad<A, N, GpioFunc<PullUp>> {
+    pub(crate) fn into_gpio_pull_up(self) -> Pad<T, N, GpioFunc<PullUp>> {
         unsafe { self.pad_config().modify(|w| w.set_pull(Pull::Up)) };
         Pad {
-            base: self.base,
+            inner: self.inner,
             _function: PhantomData,
         }
     }