[rust, hal] Add the timer implementation

Signed-off-by: Douglas Reis <[email protected]>

Author: engdoreis

data/ibex.svd

@@ -283,7 +283,7 @@
       </interrupt>
     </peripheral>
     <peripheral>
-      <name>TIMER</name>
+      <name>TIMER0</name>
       <version>1</version>
       <description>Controls timer</description>
       <baseAddress>0x80002000</baseAddress>
@@ -295,18 +295,18 @@
       </addressBlock>
       <interrupt>
         <name>TIMER_IRQ_0</name>
-        <value>0</value>
+        <value>7</value>
       </interrupt>
       <registers>
         <register>
-          <name>MTIME</name>
-          <description>mtime</description>
+          <name>MTIMEL</name>
+          <description>mtime low</description>
           <addressOffset>0x0000</addressOffset>
           <resetValue>0x00000000</resetValue>
           <fields>
             <field>
               <name>VALUE</name>
-              <description>mtime low.</description>
+              <description>mtime low</description>
               <bitRange>[31:0]</bitRange>
               <access>read-write</access>
             </field>
@@ -320,21 +320,21 @@
           <fields>
             <field>
               <name>VALUE</name>
-              <description>mtime high.</description>
+              <description>mtime high</description>
               <bitRange>[31:0]</bitRange>
               <access>read-write</access>
             </field>
           </fields>
         </register>
         <register>
-          <name>MTIMECMP</name>
-          <description>mtime cmp</description>
+          <name>MTIMECMPL</name>
+          <description>mtime cmp low</description>
           <addressOffset>0x0008</addressOffset>
           <resetValue>0x00000000</resetValue>
           <fields>
             <field>
               <name>VALUE</name>
-              <description>mtime cmp.</description>
+              <description>mtime cmp low</description>
               <bitRange>[31:0]</bitRange>
               <access>read-write</access>
             </field>
@@ -348,7 +348,7 @@
           <fields>
             <field>
               <name>VALUE</name>
-              <description>mtime cmp high.</description>
+              <description>mtime cmp high</description>
               <bitRange>[31:0]</bitRange>
               <access>read-write</access>
             </field>

sw/rust/Cargo.lock

@@ -16,3 +16,5 @@ riscv-rt = "0.11.0"
 ibex-demo-system-hal = {path = "../../ibex-demo-system-hal"}
 embedded-hal = "0.2.7"
 smart-leds = "0.3.0"
+nb = "1.1.0"
+fugit = "0.3.7"

sw/rust/demo/pwm_hal/Cargo.toml

@@ -8,13 +8,14 @@
 extern crate panic_halt as _;
 
 use core::iter;
-use riscv::delay::McycleDelay;
+use embedded_hal::timer::CountDown;
 use riscv_rt::entry;
 
 use embedded_hal;
-use embedded_hal::{blocking::delay::DelayMs, PwmPin};
+use embedded_hal::PwmPin;
 
 use crate::hal::pac;
+use fugit::{ExtU32, RateExtU32};
 use ibex_demo_system_hal as hal;
 
 use smart_leds as leds;
@@ -61,9 +62,11 @@ where
 
 #[entry]
 fn main() -> ! {
-    let mut delay = McycleDelay::new(CPU_CLOCK_HZ);
     let p = pac::Peripherals::take().unwrap();
 
+    let timer = hal::timer::Timer::new(p.TIMER0, CPU_CLOCK_HZ.Hz());
+    let mut count_down = timer.new_count_down();
+
     let pwm0 = hal::pwm::Pwm::new(p.PWM0);
     let pwm1 = hal::pwm::Pwm::new(p.PWM1);
     let pwm2 = hal::pwm::Pwm::new(p.PWM2);
@@ -83,16 +86,18 @@ fn main() -> ! {
     let mut led3 = RgbLed::new(pwm9, pwm10, pwm11);
 
     let mut n: u8 = 128;
-
+    count_down.start(30u32.millis());
     loop {
-        delay.delay_ms(30);
-
-        let color = wheel(n);
-        n = n.wrapping_add(1);
-        led0.set_color(color);
-        led1.set_color(color);
-        led2.set_color(color);
-        led3.set_color(color);
+        if count_down.wait().is_ok() {
+            let color = wheel(n);
+            n = n.wrapping_add(1);
+            led0.set_color(color);
+            led1.set_color(color);
+            led2.set_color(color);
+            led3.set_color(color);
+
+            count_down.start(30u32.millis());
+        }
     }
 }
 

sw/rust/demo/pwm_hal/src/main.rs

@@ -11,6 +11,8 @@ edition = "2021"
 
 [dependencies]
 embedded-hal = { features = ["unproven"], version = "0.2.7" }
+fugit = "0.3.7"
 ibex-demo-system-pac = {path = "../ibex-demo-system-pac"}
 nb = "1.1.0"
 riscv = "0.10.1"
+void = { version = "1.0.2", default-features = false }

sw/rust/ibex-demo-system-hal/Cargo.toml

@@ -12,6 +12,7 @@ pub mod gpio;
 pub mod pwm;
 pub mod serial;
 pub mod spi;
+pub mod timer;
 pub mod utils;
 
 #[cfg(test)]

sw/rust/ibex-demo-system-hal/src/lib.rs

@@ -0,0 +1,123 @@
+use core::ops::Deref;
+use embedded_hal::timer;
+use fugit::{Hertz, NanosDurationU64};
+use ibex_demo_system_pac as pac;
+
+pub struct Timer<T: Deref<Target = pac::timer0::RegisterBlock>> {
+    device: T,
+    clock_rate: Hertz<u64>,
+}
+
+pub struct CountDown<'a, T: Deref<Target = pac::timer0::RegisterBlock>> {
+    timer: &'a Timer<T>,
+    timeout: Option<u64>,
+}
+
+impl<T: Deref<Target = pac::timer0::RegisterBlock>> Timer<T> {
+    pub fn new<H>(timer: T, clock_rate: H) -> Self
+    where
+        H: Into<Hertz<u64>>,
+    {
+        let mut timer = Self {
+            device: timer,
+            clock_rate: clock_rate.into(),
+        };
+        timer.set_counter(0);
+        timer.set_cmp(u64::MAX);
+        timer
+    }
+
+    pub fn new_count_down(&self) -> CountDown<'_, T> {
+        CountDown {
+            timer: self,
+            timeout: None,
+        }
+    }
+
+    pub fn get_counter(&self) -> u64 {
+        let mut timeh;
+        let mut timel;
+        loop {
+            timeh = self.device.mtimeh.read().value().bits();
+            timel = self.device.mtimel.read().value().bits();
+            if timeh == self.device.mtimeh.read().value().bits() {
+                break;
+            }
+        }
+        (timeh as u64) << 32 | (timel as u64)
+    }
+
+    pub fn set_cmp(&mut self, value: u64) {
+        self.device.mtimecmpl.write(|w| {
+            w.value().variant(u32::MAX);
+            w
+        });
+        self.device.mtimecmph.write(|w| {
+            w.value().variant((value >> 32) as u32);
+            w
+        });
+        self.device.mtimecmpl.write(|w| {
+            w.value().variant((value) as u32);
+            w
+        });
+    }
+
+    pub fn get_cmp(&self) -> u64 {
+        let mut comph;
+        let mut compl;
+        loop {
+            comph = self.device.mtimecmph.read().value().bits();
+            compl = self.device.mtimecmpl.read().value().bits();
+            if comph == self.device.mtimecmph.read().value().bits() {
+                break;
+            }
+        }
+        (comph as u64) << 32 | (compl as u64)
+    }
+
+    pub fn set_counter(&mut self, value: u64) {
+        self.device.mtimel.write(|w| {
+            w.value().variant(u32::MAX);
+            w
+        });
+        self.device.mtimeh.write(|w| {
+            w.value().variant((value >> 32) as u32);
+            w
+        });
+        self.device.mtimel.write(|w| {
+            w.value().variant((value) as u32);
+            w
+        });
+    }
+}
+
+impl<U: Deref<Target = pac::timer0::RegisterBlock>> timer::CountDown for CountDown<'_, U> {
+    type Time = NanosDurationU64;
+    fn start<T>(&mut self, count: T)
+    where
+        T: Into<Self::Time>,
+    {
+        let count = count.into().to_nanos();
+        let period: NanosDurationU64 = self.timer.clock_rate.into_duration();
+        let period = period.to_nanos();
+
+        self.timeout = Some((count / period).wrapping_add(self.timer.get_counter()));
+    }
+
+    fn wait(&mut self) -> nb::Result<(), void::Void> {
+        let Some(timeout) = self.timeout else { panic!("Countdown not started"); };
+
+        if self.timer.get_counter() < timeout {
+            return Err(nb::Error::WouldBlock);
+        }
+        Ok(())
+    }
+}
+
+impl<U: Deref<Target = pac::timer0::RegisterBlock>> timer::Cancel for CountDown<'_, U> {
+    type Error = super::utils::Error;
+    fn cancel(&mut self) -> Result<(), Self::Error> {
+        self.timeout = None;
+        Ok(())
+    }
+}