nrf/rng: make available on all chips, use Instance trait, switch to new interrupt binding.

1 files changed, 122 insertions, 71 deletions

diff --git a/embassy-nrf/src/rng.rs b/embassy-nrf/src/rng.rs
index b0b3a8eb8..a5602248d 100644
--- a/embassy-nrf/src/rng.rs
+++ b/embassy-nrf/src/rng.rs
@@ -1,83 +1,48 @@
 //! Random Number Generator (RNG) driver.
 
+#![macro_use]
+
 use core::future::poll_fn;
+use core::marker::PhantomData;
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 use core::task::Poll;
 
+use embassy_cortex_m::interrupt::Interrupt;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::interrupt::InterruptExt;
-use crate::peripherals::RNG;
-use crate::{interrupt, pac, Peripheral};
-
-impl RNG {
-    fn regs() -> &'static pac::rng::RegisterBlock {
-        unsafe { &*pac::RNG::ptr() }
-    }
-}
-
-static STATE: State = State {
-    ptr: AtomicPtr::new(ptr::null_mut()),
-    end: AtomicPtr::new(ptr::null_mut()),
-    waker: AtomicWaker::new(),
-};
+use crate::{interrupt, Peripheral};
 
-struct State {
-    ptr: AtomicPtr<u8>,
-    end: AtomicPtr<u8>,
-    waker: AtomicWaker,
+/// Interrupt handler.
+pub struct InterruptHandler<T: Instance> {
+    _phantom: PhantomData<T>,
 }
 
-/// A wrapper around an nRF RNG peripheral.
-///
-/// It has a non-blocking API, and a blocking api through `rand`.
-pub struct Rng<'d> {
-    irq: PeripheralRef<'d, interrupt::RNG>,
-}
-
-impl<'d> Rng<'d> {
-    /// Creates a new RNG driver from the `RNG` peripheral and interrupt.
-    ///
-    /// SAFETY: The future returned from `fill_bytes` must not have its lifetime end without running its destructor,
-    /// e.g. using `mem::forget`.
-    ///
-    /// The synchronous API is safe.
-    pub fn new(_rng: impl Peripheral<P = RNG> + 'd, irq: impl Peripheral<P = interrupt::RNG> + 'd) -> Self {
-        into_ref!(irq);
-
-        let this = Self { irq };
+impl<T: Instance> interrupt::Handler<T::Interrupt> for InterruptHandler<T> {
+    unsafe fn on_interrupt() {
+        let s = T::state();
+        let r = T::regs();
 
-        this.stop();
-        this.disable_irq();
-
-        this.irq.set_handler(Self::on_interrupt);
-        this.irq.unpend();
-        this.irq.enable();
-
-        this
-    }
-
-    fn on_interrupt(_: *mut ()) {
         // Clear the event.
-        RNG::regs().events_valrdy.reset();
+        r.events_valrdy.reset();
 
         // Mutate the slice within a critical section,
         // so that the future isn't dropped in between us loading the pointer and actually dereferencing it.
         let (ptr, end) = critical_section::with(|_| {
-            let ptr = STATE.ptr.load(Ordering::Relaxed);
+            let ptr = s.ptr.load(Ordering::Relaxed);
             // We need to make sure we haven't already filled the whole slice,
             // in case the interrupt fired again before the executor got back to the future.
-            let end = STATE.end.load(Ordering::Relaxed);
+            let end = s.end.load(Ordering::Relaxed);
             if !ptr.is_null() && ptr != end {
                 // If the future was dropped, the pointer would have been set to null,
                 // so we're still good to mutate the slice.
                 // The safety contract of `Rng::new` means that the future can't have been dropped
                 // without calling its destructor.
                 unsafe {
-                    *ptr = RNG::regs().value.read().value().bits();
+                    *ptr = r.value.read().value().bits();
                 }
             }
             (ptr, end)
@@ -90,15 +55,15 @@ impl<'d> Rng<'d> {
         }
 
         let new_ptr = unsafe { ptr.add(1) };
-        match STATE
+        match s
             .ptr
             .compare_exchange(ptr, new_ptr, Ordering::Relaxed, Ordering::Relaxed)
         {
             Ok(_) => {
-                let end = STATE.end.load(Ordering::Relaxed);
+                let end = s.end.load(Ordering::Relaxed);
                 // It doesn't matter if `end` was changed under our feet, because then this will just be false.
                 if new_ptr == end {
-                    STATE.waker.wake();
+                    s.waker.wake();
                 }
             }
             Err(_) => {
@@ -107,21 +72,53 @@ impl<'d> Rng<'d> {
             }
         }
     }
+}
+
+/// A wrapper around an nRF RNG peripheral.
+///
+/// It has a non-blocking API, and a blocking api through `rand`.
+pub struct Rng<'d, T: Instance> {
+    _peri: PeripheralRef<'d, T>,
+}
+
+impl<'d, T: Instance> Rng<'d, T> {
+    /// Creates a new RNG driver from the `RNG` peripheral and interrupt.
+    ///
+    /// SAFETY: The future returned from `fill_bytes` must not have its lifetime end without running its destructor,
+    /// e.g. using `mem::forget`.
+    ///
+    /// The synchronous API is safe.
+    pub fn new(
+        rng: impl Peripheral<P = T> + 'd,
+        _irq: impl interrupt::Binding<T::Interrupt, InterruptHandler<T>> + 'd,
+    ) -> Self {
+        into_ref!(rng);
+
+        let this = Self { _peri: rng };
+
+        this.stop();
+        this.disable_irq();
+
+        unsafe { T::Interrupt::steal() }.unpend();
+        unsafe { T::Interrupt::steal() }.enable();
+
+        this
+    }
 
     fn stop(&self) {
-        RNG::regs().tasks_stop.write(|w| unsafe { w.bits(1) })
+        T::regs().tasks_stop.write(|w| unsafe { w.bits(1) })
     }
 
     fn start(&self) {
-        RNG::regs().tasks_start.write(|w| unsafe { w.bits(1) })
+        T::regs().tasks_start.write(|w| unsafe { w.bits(1) })
     }
 
     fn enable_irq(&self) {
-        RNG::regs().intenset.write(|w| w.valrdy().set());
+        T::regs().intenset.write(|w| w.valrdy().set());
     }
 
     fn disable_irq(&self) {
-        RNG::regs().intenclr.write(|w| w.valrdy().clear());
+        T::regs().intenclr.write(|w| w.valrdy().clear());
     }
 
     /// Enable or disable the RNG's bias correction.
@@ -131,7 +128,7 @@ impl<'d> Rng<'d> {
     ///
     /// Defaults to disabled.
     pub fn set_bias_correction(&self, enable: bool) {
-        RNG::regs().config.write(|w| w.dercen().bit(enable))
+        T::regs().config.write(|w| w.dercen().bit(enable))
     }
 
     /// Fill the buffer with random bytes.
@@ -140,11 +137,13 @@ impl<'d> Rng<'d> {
             return; // Nothing to fill
         }
 
+        let s = T::state();
+
         let range = dest.as_mut_ptr_range();
         // Even if we've preempted the interrupt, it can't preempt us again,
         // so we don't need to worry about the order we write these in.
-        STATE.ptr.store(range.start, Ordering::Relaxed);
-        STATE.end.store(range.end, Ordering::Relaxed);
+        s.ptr.store(range.start, Ordering::Relaxed);
+        s.end.store(range.end, Ordering::Relaxed);
 
         self.enable_irq();
         self.start();
@@ -154,16 +153,16 @@ impl<'d> Rng<'d> {
             self.disable_irq();
 
             // The interrupt is now disabled and can't preempt us anymore, so the order doesn't matter here.
-            STATE.ptr.store(ptr::null_mut(), Ordering::Relaxed);
-            STATE.end.store(ptr::null_mut(), Ordering::Relaxed);
+            s.ptr.store(ptr::null_mut(), Ordering::Relaxed);
+            s.end.store(ptr::null_mut(), Ordering::Relaxed);
         });
 
         poll_fn(|cx| {
-            STATE.waker.register(cx.waker());
+            s.waker.register(cx.waker());
 
             // The interrupt will never modify `end`, so load it first and then get the most up-to-date `ptr`.
-            let end = STATE.end.load(Ordering::Relaxed);
-            let ptr = STATE.ptr.load(Ordering::Relaxed);
+            let end = s.end.load(Ordering::Relaxed);
+            let ptr = s.ptr.load(Ordering::Relaxed);
 
             if ptr == end {
                 // We're done.
@@ -183,7 +182,7 @@ impl<'d> Rng<'d> {
         self.start();
 
         for byte in dest.iter_mut() {
-            let regs = RNG::regs();
+            let regs = T::regs();
             while regs.events_valrdy.read().bits() == 0 {}
             regs.events_valrdy.reset();
             *byte = regs.value.read().value().bits();
@@ -193,13 +192,16 @@ impl<'d> Rng<'d> {
     }
 }
 
-impl<'d> Drop for Rng<'d> {
+impl<'d, T: Instance> Drop for Rng<'d, T> {
     fn drop(&mut self) {
-        self.irq.disable()
+        self.stop();
+        let s = T::state();
+        s.ptr.store(ptr::null_mut(), Ordering::Relaxed);
+        s.end.store(ptr::null_mut(), Ordering::Relaxed);
     }
 }
 
-impl<'d> rand_core::RngCore for Rng<'d> {
+impl<'d, T: Instance> rand_core::RngCore for Rng<'d, T> {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.blocking_fill_bytes(dest);
     }
@@ -223,4 +225,53 @@ impl<'d> rand_core::RngCore for Rng<'d> {
     }
 }
 
-impl<'d> rand_core::CryptoRng for Rng<'d> {}
+impl<'d, T: Instance> rand_core::CryptoRng for Rng<'d, T> {}
+
+pub(crate) mod sealed {
+    use super::*;
+
+    /// Peripheral static state
+    pub struct State {
+        pub ptr: AtomicPtr<u8>,
+        pub end: AtomicPtr<u8>,
+        pub waker: AtomicWaker,
+    }
+
+    impl State {
+        pub const fn new() -> Self {
+            Self {
+                ptr: AtomicPtr::new(ptr::null_mut()),
+                end: AtomicPtr::new(ptr::null_mut()),
+                waker: AtomicWaker::new(),
+            }
+        }
+    }
+
+    pub trait Instance {
+        fn regs() -> &'static crate::pac::rng::RegisterBlock;
+        fn state() -> &'static State;
+    }
+}
+
+/// RNG peripheral instance.
+pub trait Instance: Peripheral<P = Self> + sealed::Instance + 'static + Send {
+    /// Interrupt for this peripheral.
+    type Interrupt: Interrupt;
+}
+
+macro_rules! impl_rng {
+    ($type:ident, $pac_type:ident, $irq:ident) => {
+        impl crate::rng::sealed::Instance for peripherals::$type {
+            fn regs() -> &'static crate::pac::rng::RegisterBlock {
+                unsafe { &*pac::$pac_type::ptr() }
+            }
+            fn state() -> &'static crate::rng::sealed::State {
+                static STATE: crate::rng::sealed::State = crate::rng::sealed::State::new();
+                &STATE
+            }
+        }
+        impl crate::rng::Instance for peripherals::$type {
+            type Interrupt = crate::interrupt::$irq;
+        }
+    };
+}