nrf/rng: erase instance generics

1 files changed, 30 insertions, 26 deletions

diff --git a/embassy-nrf/src/rng.rs b/embassy-nrf/src/rng.rs
index 9d3130e6e..8070c1afe 100644
--- a/embassy-nrf/src/rng.rs
+++ b/embassy-nrf/src/rng.rs
@@ -56,21 +56,23 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
 /// 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, M: Mode> {
-    _peri: Peri<'d, T>,
-    _phantom: PhantomData<M>,
+pub struct Rng<'d, M: Mode> {
+    r: pac::rng::Rng,
+    state: &'static State,
+    _phantom: PhantomData<(&'d (), M)>,
 }
 
-impl<'d, T: Instance> Rng<'d, T, Blocking> {
+impl<'d> Rng<'d, Blocking> {
     /// 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_blocking(rng: Peri<'d, T>) -> Self {
+    pub fn new_blocking<T: Instance>(_rng: Peri<'d, T>) -> Self {
         let this = Self {
-            _peri: rng,
+            r: T::regs(),
+            state: T::state(),
             _phantom: PhantomData,
         };
 
@@ -80,19 +82,20 @@ impl<'d, T: Instance> Rng<'d, T, Blocking> {
     }
 }
 
-impl<'d, T: Instance> Rng<'d, T, Async> {
+impl<'d> Rng<'d, Async> {
     /// 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: Peri<'d, T>,
+    pub fn new<T: Instance>(
+        _rng: Peri<'d, T>,
         _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'd,
     ) -> Self {
         let this = Self {
-            _peri: rng,
+            r: T::regs(),
+            state: T::state(),
             _phantom: PhantomData,
         };
 
@@ -106,11 +109,11 @@ impl<'d, T: Instance> Rng<'d, T, Async> {
     }
 
     fn enable_irq(&self) {
-        T::regs().intenset().write(|w| w.set_valrdy(true));
+        self.r.intenset().write(|w| w.set_valrdy(true));
     }
 
     fn disable_irq(&self) {
-        T::regs().intenclr().write(|w| w.set_valrdy(true));
+        self.r.intenclr().write(|w| w.set_valrdy(true));
     }
 
     /// Fill the buffer with random bytes.
@@ -120,10 +123,11 @@ impl<'d, T: Instance> Rng<'d, T, Async> {
         }
 
         let range = dest.as_mut_ptr_range();
+        let state = self.state;
         // 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.
         critical_section::with(|cs| {
-            let mut state = T::state().borrow_mut(cs);
+            let mut state = state.borrow_mut(cs);
             state.ptr = range.start;
             state.end = range.end;
         });
@@ -136,7 +140,7 @@ impl<'d, T: Instance> Rng<'d, T, Async> {
             self.disable_irq();
 
             critical_section::with(|cs| {
-                let mut state = T::state().borrow_mut(cs);
+                let mut state = state.borrow_mut(cs);
                 state.ptr = ptr::null_mut();
                 state.end = ptr::null_mut();
             });
@@ -144,7 +148,7 @@ impl<'d, T: Instance> Rng<'d, T, Async> {
 
         poll_fn(|cx| {
             critical_section::with(|cs| {
-                let mut s = T::state().borrow_mut(cs);
+                let mut s = state.borrow_mut(cs);
                 s.waker.register(cx.waker());
                 if s.ptr == s.end {
                     // We're done.
@@ -161,13 +165,13 @@ impl<'d, T: Instance> Rng<'d, T, Async> {
     }
 }
 
-impl<'d, T: Instance, M: Mode> Rng<'d, T, M> {
+impl<'d, M: Mode> Rng<'d, M> {
     fn stop(&self) {
-        T::regs().tasks_stop().write_value(1)
+        self.r.tasks_stop().write_value(1)
     }
 
     fn start(&self) {
-        T::regs().tasks_start().write_value(1)
+        self.r.tasks_start().write_value(1)
     }
 
     /// Enable or disable the RNG's bias correction.
@@ -177,7 +181,7 @@ impl<'d, T: Instance, M: Mode> Rng<'d, T, M> {
     ///
     /// Defaults to disabled.
     pub fn set_bias_correction(&self, enable: bool) {
-        T::regs().config().write(|w| w.set_dercen(enable))
+        self.r.config().write(|w| w.set_dercen(enable))
     }
 
     /// Fill the buffer with random bytes, blocking version.
@@ -185,7 +189,7 @@ impl<'d, T: Instance, M: Mode> Rng<'d, T, M> {
         self.start();
 
         for byte in dest.iter_mut() {
-            let regs = T::regs();
+            let regs = self.r;
             while regs.events_valrdy().read() == 0 {}
             regs.events_valrdy().write_value(0);
             *byte = regs.value().read().value();
@@ -210,18 +214,18 @@ impl<'d, T: Instance, M: Mode> Rng<'d, T, M> {
     }
 }
 
-impl<'d, T: Instance, M: Mode> Drop for Rng<'d, T, M> {
+impl<'d, M: Mode> Drop for Rng<'d, M> {
     fn drop(&mut self) {
         self.stop();
         critical_section::with(|cs| {
-            let mut state = T::state().borrow_mut(cs);
+            let mut state = self.state.borrow_mut(cs);
             state.ptr = ptr::null_mut();
             state.end = ptr::null_mut();
         });
     }
 }
 
-impl<'d, T: Instance, M: Mode> rand_core_06::RngCore for Rng<'d, T, M> {
+impl<'d, M: Mode> rand_core_06::RngCore for Rng<'d, M> {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.blocking_fill_bytes(dest);
     }
@@ -237,9 +241,9 @@ impl<'d, T: Instance, M: Mode> rand_core_06::RngCore for Rng<'d, T, M> {
     }
 }
 
-impl<'d, T: Instance, M: Mode> rand_core_06::CryptoRng for Rng<'d, T, M> {}
+impl<'d, M: Mode> rand_core_06::CryptoRng for Rng<'d, M> {}
 
-impl<'d, T: Instance, M: Mode> rand_core_09::RngCore for Rng<'d, T, M> {
+impl<'d, M: Mode> rand_core_09::RngCore for Rng<'d, M> {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.blocking_fill_bytes(dest);
     }
@@ -251,7 +255,7 @@ impl<'d, T: Instance, M: Mode> rand_core_09::RngCore for Rng<'d, T, M> {
     }
 }
 
-impl<'d, T: Instance, M: Mode> rand_core_09::CryptoRng for Rng<'d, T, M> {}
+impl<'d, M: Mode> rand_core_09::CryptoRng for Rng<'d, M> {}
 
 /// Peripheral static state
 pub(crate) struct State {