debugging rng start

Author: theonlytruealex

boards/nucleo_u545re_q/Makefile

@@ -22,6 +22,11 @@ flash-debug: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/debug/$(PLATFORM).elf
 flash: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
 	$(OPENOCD) $(OPENOCD_OPTIONS) -c "init; halt; stm32l4x mass_erase 0; program $< verify reset exit"
 
+.PHONY: flash-probe-rs
+flash-probe-rs: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
+		$(Q)probe-rs download --chip STM32U545RETx --allow-erase-all $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).elf
+		$(Q)probe-rs reset --chip STM32U545RETx
+
 .PHONY: program
 program:
 	tockloader install --openocd --board nucleo_u545re_q $(APP)

boards/nucleo_u545re_q/src/main.rs

@@ -8,9 +8,11 @@
 
 use kernel::component::Component;
 use kernel::debug::PanicResources;
-use kernel::deferred_call::DeferredCall;
+use kernel::deferred_call::{DeferredCall, DeferredCallClient};
 use kernel::hil::entropy::Entropy32;
 use kernel::platform::{KernelResources, SyscallDriverLookup};
+use kernel::utilities::registers::interfaces::Readable;
+use kernel::utilities::registers::interfaces::Writeable;
 use kernel::utilities::single_thread_value::SingleThreadValue;
 use kernel::{capabilities, debug};
 use kernel::{create_capability, static_init};
@@ -256,19 +258,6 @@ unsafe fn start() -> (
     );
 
     // 1. Import
-    use capsules_extra::test::rng::RngEntropy32Test;
-
-    // 2. Statically allocate the test struct (inside your component/board setup)
-    let rng_test = static_init!(
-        RngEntropy32Test<'static, stm32u545::entropy::Trng>,
-        RngEntropy32Test::new(trng)
-    );
-
-    // 3. Register the test as the driver's client
-    trng.set_client(rng_test);
-
-    // 4. Kick it off — call after the kernel loop is about to start
-    rng_test.run();
     // Symbols for linker
     extern "C" {
         /// Beginning of the ROM region containing app images.
@@ -300,7 +289,20 @@ unsafe fn start() -> (
         &capsules_system::process_policies::PanicFaultPolicy {},
         &create_capability!(capabilities::ProcessManagementCapability),
     );
+    use capsules_extra::test::rng::RngEntropy32Test;
+
+    // 2. Statically allocate the test struct (inside your component/board setup)
+    let rng_test = static_init!(
+        RngEntropy32Test<'static, stm32u545::entropy::Trng>,
+        RngEntropy32Test::new(trng)
+    );
 
+    // 3. Register the test as the driver's client
+    trng.set_client(rng_test);
+    trng.register();
+    // 4. Kick it off — call after the kernel loop is about to start
+    // // temporary diagnostic
+    rng_test.run();
     (board_kernel, platform, chip)
 }
 

chips/stm32u5xx/src/chip.rs

@@ -18,6 +18,7 @@ use crate::usart;
 use crate::{entropy, exti};
 
 use core::fmt::Write;
+use kernel::deferred_call::DeferredCallClient;
 use kernel::platform::chip::Chip;
 use kernel::platform::chip::InterruptService;
 
@@ -70,7 +71,7 @@ impl<'a> Stm32u5xxDefaultPeripherals<'a> {
         self.rcc.enable_usart1();
         self.rcc.enable_syscfg();
         self.rcc.enable_trng();
-        self.trng.init();
+        self.trng.register();
         self.rcc.set_usart1_source_pclk();
         // Link DMA to USART1
         let usart1_channel_tx = self.dma1.request_channel();

chips/stm32u5xx/src/entropy.rs

@@ -3,6 +3,7 @@
 // Copyright OxidOS Automotive 2026.
 
 use core::cell::Cell;
+use kernel::debug;
 
 use kernel::deferred_call::{DeferredCall, DeferredCallClient};
 use kernel::hil::entropy::{Client32, Continue, Entropy32};
@@ -17,7 +18,7 @@ register_structs! {
         /// control register
         (0x000 => cr: ReadWrite<u32, CR::Register>),
         /// status register
-        (0x004 => sr: ReadWrite<u32, SR::Register>),
+        (0x004 => pub sr: ReadWrite<u32, SR::Register>),
         /// data register
         (0x008 => dr: ReadOnly<u32>),
         (0x00C => nscr:  ReadWrite<u32, NSCR::Register>),
@@ -125,21 +126,26 @@ impl<'a> Trng<'a> {
         self.registers
             .cr
             .modify(CR::RNGEN::SET + CR::IE::SET + CR::CONDRST::CLEAR);
+        debug!("CR: {:02x?}", self.registers.cr.get());
     }
     fn send_data(&self) {
         let response = self
             .client
             .map(|client| client.entropy_available(&mut TrngIter(self), Ok(())));
         match response {
             Some(Continue::Done) | None => self.entropy_needed.set(false),
-            _ => {}
+            _ => {
+                self.deferred_call.set();
+            }
         }
     }
 
     pub fn handle_interrupt(&self) {
         let regs = self.registers;
         if regs.sr.any_matching_bits_set(SR::DRDY::SET) && self.entropy_needed.get() {
             self.send_data();
+        } else {
+            self.deferred_call.set();
         }
     }
 }
@@ -170,9 +176,16 @@ impl<'a> Entropy32<'a> for Trng<'a> {
 
 impl DeferredCallClient for Trng<'_> {
     fn handle_deferred_call(&self) {
+        debug!("got");
         if !self.entropy_needed.get() {
             return;
         }
+        debug!(
+            "CR: {:02x?} SR: {:02x?}, need: {}",
+            self.registers.cr.get(),
+            self.registers.sr.get(),
+            self.entropy_needed.get()
+        );
 
         if self.registers.sr.any_matching_bits_set(SR::DRDY::SET) {
             self.send_data();