From 37fd0c7bce19d4618669a29bdd01945fb477eea6 Mon Sep 17 00:00:00 2001 From: Dario Nieuwenhuis Date: Sat, 27 Sep 2025 21:19:13 +0200 Subject: nrf/rng: erase instance generics --- embassy-nrf/src/rng.rs | 56 +++++++++++++++++++++++++++----------------------- 1 file 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 interrupt::typelevel::Handler 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, +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(_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( + _rng: Peri<'d, T>, _irq: impl interrupt::typelevel::Binding> + '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 { -- cgit