lpc55-rng: Combine Lpc55Core and Lpc55Rng.

Implementing `BlockRngCore` for `Lpc55Core` got us an implementation of
RngCore for free. Unfortunately it cost us the ability to return errors.
This wasn't a good tradeoff. Better to implement `RngCore` directly.

Author: flihp

drv/lpc55-rng/src/main.rs

@@ -131,8 +131,7 @@ impl NotificationHandler for Lpc55RngServer {
 
 #[export_name = "main"]
 fn main() -> ! {
-    let rng = Lpc55Rng::new(Syscon::from(SYSCON.get_task_id()));
-    rng.init();
+    let rng = Lpc55Rng::new(&Syscon::from(SYSCON.get_task_id()));
 
     let threshold = 0x100000; // 1 MiB
     let mut rng = Lpc55RngServer::new(rng, threshold)

lib/lpc55-rng/src/lib.rs

@@ -5,75 +5,70 @@
 #![no_std]
 #![no_main]
 
+use core::{cmp, mem};
 use drv_lpc55_syscon_api::{Peripheral, Syscon};
 use drv_rng_api::RngError;
 use lpc55_pac::{pmc, rng, PMC, RNG};
-use rand_core::{
-    block::{BlockRng, BlockRngCore},
-    Error, RngCore,
-};
+use rand_core::{impls, Error, RngCore};
 
-struct Lpc55Core {
-    pmc: &'static pmc::RegisterBlock,
-    rng: &'static rng::RegisterBlock,
-    syscon: Syscon,
+/// The Lpc55Rng is a thin wrapper around the LPC55 hardware randome number
+/// generator (HRNG).
+pub struct Lpc55Rng {
+    pub pmc: &'static pmc::RegisterBlock,
+    pub rng: &'static rng::RegisterBlock,
 }
 
-impl Lpc55Core {
-    fn new(syscon: Syscon) -> Self {
-        Lpc55Core {
-            pmc: unsafe { &*PMC::ptr() },
-            rng: unsafe { &*RNG::ptr() },
-            syscon,
-        }
-    }
-}
-
-impl BlockRngCore for Lpc55Core {
-    type Item = u32;
-    type Results = [u32; 1];
-
-    fn generate(&mut self, results: &mut Self::Results) {
-        results[0] = self.rng.random_number.read().bits();
-    }
-}
-
-pub struct Lpc55Rng(BlockRng<Lpc55Core>);
-
 impl Lpc55Rng {
-    pub fn new(syscon: Syscon) -> Self {
-        Lpc55Rng(BlockRng::new(Lpc55Core::new(syscon)))
-    }
-
-    pub fn init(&self) {
-        self.0
-            .core
-            .pmc
-            .pdruncfg0
-            .modify(|_, w| w.pden_rng().poweredon());
+    /// Create a new Lpc55Rng instance after powering on, enabling the clocks
+    /// and reseting the underlying HRNG.
+    pub fn new(syscon: &Syscon) -> Self {
+        let pmc = unsafe { &*PMC::ptr() };
+        pmc.pdruncfg0.modify(|_, w| w.pden_rng().poweredon());
 
-        self.0.core.syscon.enable_clock(Peripheral::Rng);
+        syscon.enable_clock(Peripheral::Rng);
+        syscon.enter_reset(Peripheral::Rng);
+        syscon.leave_reset(Peripheral::Rng);
 
-        self.0.core.syscon.enter_reset(Peripheral::Rng);
-        self.0.core.syscon.leave_reset(Peripheral::Rng);
+        Lpc55Rng {
+            pmc,
+            rng: unsafe { &*RNG::ptr() },
+        }
     }
 }
 
 impl RngCore for Lpc55Rng {
+    /// Get the next 4 bytes from the HRNG.
     fn next_u32(&mut self) -> u32 {
-        self.0.next_u32()
+        impls::next_u32_via_fill(self)
     }
+
+    /// Get the next 8 bytes from the HRNG.
     fn next_u64(&mut self) -> u64 {
-        self.0.next_u64()
+        impls::next_u64_via_fill(self)
     }
+
+    /// Fill the provided buffer with output from the HRNG.
     fn fill_bytes(&mut self, bytes: &mut [u8]) {
-        self.0.fill_bytes(bytes)
+        self.try_fill_bytes(bytes).expect("fill_bytes")
     }
-    fn try_fill_bytes(&mut self, bytes: &mut [u8]) -> Result<(), Error> {
-        if self.0.core.pmc.pdruncfg0.read().pden_rng().bits() {
-            return Err(RngError::PoweredOff.into());
+
+    /// Fill the provided buffer with output from the HRNG. If the HRNG
+    /// can't service the request an error is returned.
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Error> {
+        let mut filled = 0;
+        while filled < dst.len() {
+            if self.pmc.pdruncfg0.read().pden_rng().bits() {
+                return Err(RngError::PoweredOff.into());
+            }
+
+            let src = self.rng.random_number.read().bits();
+            let len = cmp::min(mem::size_of_val(&src), dst[filled..].len());
+
+            dst[filled..filled + len]
+                .copy_from_slice(&src.to_le_bytes()[..len]);
+            filled += len;
         }
 
-        self.0.try_fill_bytes(bytes)
+        Ok(())
     }
 }