add asm::nop, asm::delay, and delay.rs.

update assembly binaries.
update CHANGELOG.md

CHANGELOG.md

@@ -11,6 +11,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Add enums `Range`, `Permission` for PMP configuration
 - Add `set_pmp()` and `clear_pmp()` functions to pmpcfg(x) modules
 - Add struct `Pmpcsr` and is returned from `pmpcfgx::read()`
+- Add delay structure and methods using embedded-hal traits and Mcycle register
+- add asm::delay function for assembly-based busy-loops
+- add asm::nop, a wrapper for implementing a `nop` instruction
 
 ### Changed
 

Cargo.toml

@@ -18,6 +18,7 @@ targets = [
 [dependencies]
 bare-metal = "1.0.0"
 bit_field = "0.10.0"
+embedded-hal = "0.2.6"
 
 [build-dependencies]
 riscv-target = "0.1.2"

asm.S

@@ -1,5 +1,11 @@
 #include "asm.h"
 
+.section .text.__nop
+.global __nop
+__nop:
+    nop
+    ret
+
 .section .text.__ebreak
 .global __ebreak
 __ebreak:
@@ -24,6 +30,14 @@ __sfence_vma:
     sfence.vma a0, a1
     ret
 
+.section .text.__delay
+.global __delay
+__delay:
+    1:
+    addi a0, a0, -1
+    bne a0, zero, 1b
+    ret
+
 // User Trap Setup
 RW(0x000, ustatus)  // User status register
 RW(0x004, uie)      // User interrupt-enable register

src/asm.rs

@@ -25,6 +25,11 @@ macro_rules! instruction {
     )
 }
 
+instruction!(
+    /// `nop` instruction wrapper
+    ///
+    /// Generates a no-operation.  Useful to prevent delay loops from being optimized away.
+    , nop, "nop", __nop);
 instruction!(
     /// `EBREAK` instruction wrapper
     ///
@@ -73,3 +78,41 @@ pub unsafe fn sfence_vma(asid: usize, addr: usize) {
         () => unimplemented!(),
     }
 }
+
+/// Blocks the program for *at least* `cycles` CPU cycles.
+///
+/// This is implemented in assembly so its execution time is independent of the optimization
+/// level, however it is dependent on the specific architecture and core configuration.
+///
+/// NOTE that the delay can take much longer if interrupts are serviced during its execution
+/// and the execution time may vary with other factors. This delay is mainly useful for simple
+/// timer-less initialization of peripherals if and only if accurate timing is not essential. In
+/// any other case please use a more accurate method to produce a delay.
+#[inline]
+#[allow(unused_variables)]
+pub unsafe fn delay(cycles: u32) {
+    match () {
+        #[cfg(all(riscv, feature = "inline-asm"))]
+        () => {
+            let real_cyc = 1 + cycles / 2;
+            asm!(
+            "1:",
+            "addi {0}, {0}, -1",
+            "bne {0}, zero, 1b",
+            in(reg)
+            )
+        }
+
+        #[cfg(all(riscv, not(feature = "inline-asm")))]
+        () => {
+            extern "C" {
+                fn __delay(cycles: u32);
+            }
+
+            __delay(cycles);
+        }
+
+        #[cfg(not(riscv))]
+        () => unimplemented!(),
+    }
+}

src/delay.rs

@@ -0,0 +1,82 @@
+use crate::register::mcycle;
+use embedded_hal::blocking::delay::{DelayMs, DelayUs};
+
+/// Machine mode cycle counter (`mcycle`) as a delay provider
+#[derive(Copy, Clone)]
+pub struct McycleDelay {
+    ticks_second: u32,
+}
+
+impl McycleDelay {
+    /// Constructs the delay provider
+    pub fn new(ticks_second: u32) -> Self {
+        Self { ticks_second }
+    }
+}
+
+impl DelayUs<u64> for McycleDelay {
+    fn delay_us(&mut self, us: u64) {
+        let t0 = mcycle::read64();
+        let clock = (us * (self.ticks_second as u64)) / 1_000_000;
+        while mcycle::read64().wrapping_sub(t0) <= clock {}
+    }
+}
+
+impl DelayUs<u32> for McycleDelay {
+    #[inline(always)]
+    fn delay_us(&mut self, us: u32) {
+        self.delay_us(us as u64)
+    }
+}
+
+// Implemented for constructions like `delay.delay_us(50_000);`
+impl DelayUs<i32> for McycleDelay {
+    #[inline(always)]
+    fn delay_us(&mut self, us: i32) {
+        assert!(us >= 0);
+        self.delay_us(us as u32);
+    }
+}
+
+impl DelayUs<u16> for McycleDelay {
+    #[inline(always)]
+    fn delay_us(&mut self, us: u16) {
+        self.delay_us(us as u32)
+    }
+}
+
+impl DelayUs<u8> for McycleDelay {
+    #[inline(always)]
+    fn delay_us(&mut self, us: u8) {
+        self.delay_us(us as u32)
+    }
+}
+
+impl DelayMs<u32> for McycleDelay {
+    fn delay_ms(&mut self, ms: u32) {
+        self.delay_us((ms as u64) * 1000)
+    }
+}
+
+// Implemented for constructions like `delay.delay_ms(50_000);`
+impl DelayMs<i32> for McycleDelay {
+    #[inline(always)]
+    fn delay_ms(&mut self, ms: i32) {
+        assert!(ms >= 0);
+        self.delay_ms(ms as u32);
+    }
+}
+
+impl DelayMs<u16> for McycleDelay {
+    #[inline(always)]
+    fn delay_ms(&mut self, ms: u16) {
+        self.delay_ms(ms as u32)
+    }
+}
+
+impl DelayMs<u8> for McycleDelay {
+    #[inline(always)]
+    fn delay_ms(&mut self, ms: u8) {
+        self.delay_ms(ms as u32)
+    }
+}

src/lib.rs

@@ -18,10 +18,12 @@
 
 extern crate bare_metal;
 extern crate bit_field;
+extern crate embedded_hal;
 
 pub mod asm;
 pub mod interrupt;
 pub mod register;
+pub mod delay;
 
 #[macro_use]
 mod macros;