hal: GPIO, pad multiplexer and configurations support

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

Author: jakezhu9

Cargo.lock

@@ -10,7 +10,10 @@ repository.workspace = true
 
 [dependencies]
 sophgo-rom-rt = { version = "0.0.0", path = "../../sophgo-rom-rt" }
+sophgo-hal = { version = "0.0.0", path = "../../sophgo-hal" }
 panic-halt = "0.2.0"
+riscv = "0.11.0"
+embedded-hal = "1.0.0"
 
 [[bin]]
 name = "blinky"

examples/blinky/Cargo.toml

@@ -4,30 +4,19 @@
 #![no_std]
 #![no_main]
 
-use core::arch::asm;
-
+use embedded_hal::digital::OutputPin;
 use panic_halt as _;
 use sophgo_rom_rt::{entry, Peripherals};
 
 #[entry]
 fn main(p: Peripherals) -> ! {
-    unsafe {
-        p.rtc_gpio
-            .direction
-            .write(p.rtc_gpio.direction.read().set_output(2));
-    }
+    let pad_led = p.pwr_pads.gpio2.into_function(&p.pinmux);
+    let mut led = p.pwr_gpio.a2.into_pull_up_output(pad_led);
+
     loop {
-        unsafe {
-            p.rtc_gpio.data.write(p.rtc_gpio.data.read() | (1 << 2));
-        }
-        for _ in 0..=1_000_000 {
-            unsafe { asm!("nop") };
-        }
-        unsafe {
-            p.rtc_gpio.data.write(p.rtc_gpio.data.read() & !(1 << 2));
-        }
-        for _ in 0..=1_000_000 {
-            unsafe { asm!("nop") };
-        }
+        led.set_high().unwrap();
+        riscv::asm::delay(10_000_000);
+        led.set_low().unwrap();
+        riscv::asm::delay(10_000_000);
     }
 }

examples/blinky/src/main.rs

@@ -12,6 +12,7 @@ repository.workspace = true
 base-address = "0.0.0"
 uart16550 = "0.0.1"
 volatile-register = "0.2.1"
+embedded-hal = "1.0.0"
 
 [dev-dependencies]
 memoffset = "0.9.0"

sophgo-hal/Cargo.toml

@@ -1,5 +1,12 @@
 //! General Purpose Input/Output.
 
+use crate::{
+    pad::{GpioFunc, Pad, PullUp},
+    GPIO,
+};
+use base_address::BaseAddress;
+use core::marker::PhantomData;
+use embedded_hal::digital::{ErrorType, OutputPin};
 use volatile_register::{RO, RW, WO};
 
 /// GPIO registers.
@@ -33,7 +40,7 @@ pub struct RegisterBlock {
     pub sync_level: RW<u32>,
 }
 
-/// GPIO direction.
+/// GPIO direction register.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
 pub struct Direction(u32);
@@ -61,6 +68,95 @@ impl Direction {
     }
 }
 
+/// Owned GPIO peripheral signal with mode type state.
+pub struct Gpio<A: BaseAddress, const I: u8, M> {
+    base: GPIO<A>,
+    _mode: PhantomData<M>,
+}
+
+/// Input mode (type state).
+pub struct Input;
+
+/// Output mode (type state).
+pub struct Output;
+
+impl<A: BaseAddress, const I: u8, M> Gpio<A, I, M> {
+    /// Configures the GPIO signal as a `GpioPad` operating as a pull up output.
+    ///
+    /// # Examples
+    ///
+    /// Gets ownership of pad from `PwrPads`, configures it as a pull up output
+    /// to drive an LED.
+    ///
+    /// ```no_run
+    /// let pad_led = p.pwr_pads.gpio2.into_function(&p.pinmux);
+    /// 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>(
+        self,
+        pad: Pad<A2, N, GpioFunc<PullUp>>,
+    ) -> GpioPad<Gpio<A, I, Output>, Pad<A2, N, GpioFunc<PullUp>>> {
+        unsafe {
+            self.base.direction.modify(|w| w.set_output(I));
+        }
+        GpioPad {
+            gpio: Gpio {
+                base: self.base,
+                _mode: PhantomData,
+            },
+            pad,
+        }
+    }
+}
+
+/// Ownership wrapper of a GPIO signal and a pad.
+pub struct GpioPad<T, U> {
+    gpio: T,
+    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>>>
+{
+    /// 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>>> {
+        let (gpio, pad) = self.into_inner();
+        gpio.into_pull_up_output(pad.into_gpio_pull_up())
+    }
+}
+
+impl<T, U> GpioPad<T, U> {
+    /// Unwraps the ownership structure, returning the GPIO signal and the pad.
+    #[inline]
+    pub fn into_inner(self) -> (T, U) {
+        (self.gpio, self.pad)
+    }
+}
+
+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> {
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        unsafe {
+            self.gpio.base.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));
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::RegisterBlock;

sophgo-hal/src/gpio.rs

@@ -1,6 +1,7 @@
 #![no_std]
 
 pub mod gpio;
+pub mod pad;
 
 use core::ops;
 
@@ -33,3 +34,24 @@ impl<A: BaseAddress> ops::Deref for GPIO<A> {
         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
+    }
+}