13 files changed, 220 insertions, 131 deletions

diff --git a/embassy-mcxa/src/dma.rs b/embassy-mcxa/src/dma.rs
index 8d519d99b..b68f55e65 100644
--- a/embassy-mcxa/src/dma.rs
+++ b/embassy-mcxa/src/dma.rs
@@ -1924,7 +1924,7 @@ impl Iterator for TransferErrorRawIter {
 
         for (mask, var) in TransferErrorRaw::MAP {
             // If the bit is set...
-            if self.0 | mask != 0 {
+            if self.0 & mask != 0 {
                 // clear the bit
                 self.0 &= !mask;
                 // and return the answer
diff --git a/embassy-mcxa/src/reset_reason.rs b/embassy-mcxa/src/reset_reason.rs
index f9a9ce096..1787690a7 100644
--- a/embassy-mcxa/src/reset_reason.rs
+++ b/embassy-mcxa/src/reset_reason.rs
@@ -6,45 +6,158 @@
 
 /// Reads the most recent reset reason from the Core Mode Controller
 /// (CMC).
-pub fn reset_reason() -> ResetReason {
+pub fn reset_reason() -> ResetReasonRaw {
     let regs = unsafe { &*crate::pac::Cmc::steal() };
+    let srs = regs.srs().read().bits();
+    ResetReasonRaw(srs)
+}
+
+/// Raw reset reason bits. Can be queried or all reasons can be iterated over
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug)]
+pub struct ResetReasonRaw(u32);
+
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug)]
+pub struct ResetReasonRawIter(u32);
+
+impl ResetReasonRaw {
+    const MAP: &[(u32, ResetReason)] = &[
+        (1 << 0, ResetReason::WakeUp),
+        (1 << 1, ResetReason::Por),
+        (1 << 2, ResetReason::VoltageDetect),
+        (1 << 4, ResetReason::Warm),
+        (1 << 5, ResetReason::Fatal),
+        (1 << 8, ResetReason::Pin),
+        (1 << 9, ResetReason::Dap),
+        (1 << 10, ResetReason::ResetAckTimeout),
+        (1 << 11, ResetReason::LowPowerAckTimeout),
+        (1 << 12, ResetReason::SystemClockGeneration),
+        (1 << 13, ResetReason::Wwdt0),
+        (1 << 14, ResetReason::Software),
+        (1 << 15, ResetReason::Lockup),
+        (1 << 26, ResetReason::Cdog0),
+        (1 << 27, ResetReason::Cdog1),
+        (1 << 28, ResetReason::Jtag),
+    ];
+
+    /// Convert to an iterator of contained reset reasons
+    pub fn into_iter(self) -> ResetReasonRawIter {
+        ResetReasonRawIter(self.0)
+    }
+
+    /// Wake up
+    #[inline]
+    pub fn is_wakeup(&self) -> bool {
+        (self.0 & (1 << 0)) != 0
+    }
+
+    /// Power-on Reset
+    #[inline]
+    pub fn is_por(&self) -> bool {
+        (self.0 & (1 << 1)) != 0
+    }
+
+    /// Voltage detect
+    #[inline]
+    pub fn is_voltage_detect(&self) -> bool {
+        (self.0 & (1 << 2)) != 0
+    }
+
+    /// Warm
+    #[inline]
+    pub fn is_warm(&self) -> bool {
+        (self.0 & (1 << 4)) != 0
+    }
+
+    /// Fatal
+    #[inline]
+    pub fn is_fatal(&self) -> bool {
+        (self.0 & (1 << 5)) != 0
+    }
+
+    /// Pin
+    #[inline]
+    pub fn is_pin(&self) -> bool {
+        (self.0 & (1 << 8)) != 0
+    }
+
+    /// DAP
+    #[inline]
+    pub fn is_dap(&self) -> bool {
+        (self.0 & (1 << 9)) != 0
+    }
+
+    /// Reset ack timeout
+    #[inline]
+    pub fn is_reset_ack_timeout(&self) -> bool {
+        (self.0 & (1 << 10)) != 0
+    }
+
+    /// Low power ack timeout
+    #[inline]
+    pub fn is_low_power_ack_timeout(&self) -> bool {
+        (self.0 & (1 << 11)) != 0
+    }
+
+    /// System clock generation
+    #[inline]
+    pub fn is_system_clock_generation(&self) -> bool {
+        (self.0 & (1 << 12)) != 0
+    }
+
+    /// Watchdog 0
+    #[inline]
+    pub fn is_watchdog0(&self) -> bool {
+        (self.0 & (1 << 13)) != 0
+    }
+
+    /// Software
+    pub fn is_software(&self) -> bool {
+        (self.0 & (1 << 14)) != 0
+    }
+
+    /// Lockup
+    pub fn is_lockup(&self) -> bool {
+        (self.0 & (1 << 15)) != 0
+    }
+
+    /// Code watchdog 0
+    pub fn is_code_watchdog0(&self) -> bool {
+        (self.0 & (1 << 26)) != 0
+    }
+
+    /// Code watchdog 1
+    pub fn is_code_watchdog1(&self) -> bool {
+        (self.0 & (1 << 27)) != 0
+    }
+
+    /// JTAG
+    pub fn is_jtag(&self) -> bool {
+        (self.0 & (1 << 28)) != 0
+    }
+}
 
-    let srs = regs.srs().read();
-
-    if srs.wakeup().is_enabled() {
-        ResetReason::WakeUp
-    } else if srs.por().bit_is_set() {
-        ResetReason::Por
-    } else if srs.vd().bit_is_set() {
-        ResetReason::VoltageDetect
-    } else if srs.warm().bit_is_set() {
-        ResetReason::Warm
-    } else if srs.fatal().bit_is_set() {
-        ResetReason::Fatal
-    } else if srs.pin().bit_is_set() {
-        ResetReason::Pin
-    } else if srs.dap().bit_is_set() {
-        ResetReason::Dap
-    } else if srs.rstack().bit_is_set() {
-        ResetReason::ResetAckTimeout
-    } else if srs.lpack().bit_is_set() {
-        ResetReason::LowPowerAckTimeout
-    } else if srs.scg().bit_is_set() {
-        ResetReason::SystemClockGeneration
-    } else if srs.wwdt0().bit_is_set() {
-        ResetReason::Wwdt0
-    } else if srs.sw().bit_is_set() {
-        ResetReason::Software
-    } else if srs.lockup().bit_is_set() {
-        ResetReason::Lockup
-    } else if srs.cdog0().bit_is_set() {
-        ResetReason::Cdog0
-    } else if srs.cdog1().bit_is_set() {
-        ResetReason::Cdog1
-    } else if srs.jtag().bit_is_set() {
-        ResetReason::Jtag
-    } else {
-        ResetReason::Tamper
+impl Iterator for ResetReasonRawIter {
+    type Item = ResetReason;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.0 == 0 {
+            return None;
+        }
+
+        for (mask, var) in ResetReasonRaw::MAP {
+            // If the bit is set...
+            if self.0 & mask != 0 {
+                // clear the bit
+                self.0 &= !mask;
+                // and return the answer
+                return Some(*var);
+            }
+        }
+
+        // Shouldn't happen, but oh well.
+        None
     }
 }
 
diff --git a/embassy-nrf/CHANGELOG.md b/embassy-nrf/CHANGELOG.md
index 0d7bfb5f0..921835417 100644
--- a/embassy-nrf/CHANGELOG.md
+++ b/embassy-nrf/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- bugfix: avoid hang if calling now() before syscounter is enabled on nrf54
+
 ## 0.9.0 - 2025-12-15
 
 - changed: apply trimming values from FICR.TRIMCNF on nrf53/54l
diff --git a/embassy-nrf/src/time_driver.rs b/embassy-nrf/src/time_driver.rs
index 35f65bd64..21d94cc30 100644
--- a/embassy-nrf/src/time_driver.rs
+++ b/embassy-nrf/src/time_driver.rs
@@ -79,6 +79,10 @@ fn calc_now(period: u32, counter: u32) -> u64 {
 #[cfg(feature = "_grtc")]
 fn syscounter() -> u64 {
     let r = rtc();
+    if !r.mode().read().syscounteren() {
+        return 0;
+    }
+
     r.syscounter(0).active().write(|w| w.set_active(true));
     loop {
         let countl: u32 = r.syscounter(0).syscounterl().read();
diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 880df5f33..ce6fabc6b 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -241,7 +241,7 @@ log = ["dep:log"]
 chrono = ["dep:chrono"]
 
 exti = []
-low-power = [ "dep:embassy-executor", "time" ]
+low-power = [ "dep:embassy-executor", "time", "chrono" ]
 low-power-pender = [ "low-power" ]
 low-power-debug-with-sleep = [ "low-power" ]
 
diff --git a/embassy-stm32/src/rcc/l.rs b/embassy-stm32/src/rcc/l.rs
index 0d668103c..a1dfefd15 100644
--- a/embassy-stm32/src/rcc/l.rs
+++ b/embassy-stm32/src/rcc/l.rs
@@ -385,6 +385,11 @@ pub(crate) unsafe fn init(config: Config) {
         while !RCC.extcfgr().read().c2hpref() {}
     }
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/u5.rs b/embassy-stm32/src/rcc/u5.rs
index 47cc29c6f..c8c3e4adb 100644
--- a/embassy-stm32/src/rcc/u5.rs
+++ b/embassy-stm32/src/rcc/u5.rs
@@ -467,6 +467,11 @@ pub(crate) unsafe fn init(config: Config) {
     let lse = config.ls.lse.map(|l| l.frequency);
     let lsi = config.ls.lsi.then_some(LSI_FREQ);
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/wba.rs b/embassy-stm32/src/rcc/wba.rs
index 2528996d5..4ab3067bc 100644
--- a/embassy-stm32/src/rcc/wba.rs
+++ b/embassy-stm32/src/rcc/wba.rs
@@ -269,6 +269,11 @@ pub(crate) unsafe fn init(config: Config) {
 
     let lsi = config.ls.lsi.then_some(LSI_FREQ);
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rtc/low_power.rs b/embassy-stm32/src/rtc/low_power.rs
index f049d6b12..cd5cea081 100644
--- a/embassy-stm32/src/rtc/low_power.rs
+++ b/embassy-stm32/src/rtc/low_power.rs
@@ -1,64 +1,12 @@
-#[cfg(feature = "time")]
-use embassy_time::{Duration, TICK_HZ};
+use chrono::{DateTime, NaiveDateTime, TimeDelta, Utc};
+use embassy_time::{Duration, Instant, TICK_HZ};
 
-use super::{DateTimeError, Rtc, RtcError, bcd2_to_byte};
+use super::Rtc;
 use crate::interrupt::typelevel::Interrupt;
 use crate::pac::rtc::vals::Wucksel;
 use crate::peripherals::RTC;
 use crate::rtc::{RtcTimeProvider, SealedInstance};
 
-/// Represents an instant in time that can be substracted to compute a duration
-pub(super) struct RtcInstant {
-    /// 0..59
-    second: u8,
-    /// 0..256
-    subsecond: u16,
-}
-
-impl RtcInstant {
-    #[cfg(not(rtc_v2_f2))]
-    const fn from(second: u8, subsecond: u16) -> Result<Self, DateTimeError> {
-        if second > 59 {
-            Err(DateTimeError::InvalidSecond)
-        } else {
-            Ok(Self { second, subsecond })
-        }
-    }
-}
-
-#[cfg(feature = "defmt")]
-impl defmt::Format for RtcInstant {
-    fn format(&self, fmt: defmt::Formatter) {
-        defmt::write!(
-            fmt,
-            "{}:{}",
-            self.second,
-            RTC::regs().prer().read().prediv_s() - self.subsecond,
-        )
-    }
-}
-
-#[cfg(feature = "time")]
-impl core::ops::Sub for RtcInstant {
-    type Output = embassy_time::Duration;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        let second = if self.second < rhs.second {
-            self.second + 60
-        } else {
-            self.second
-        };
-
-        let psc = RTC::regs().prer().read().prediv_s() as u32;
-
-        let self_ticks = second as u32 * (psc + 1) + (psc - self.subsecond as u32);
-        let other_ticks = rhs.second as u32 * (psc + 1) + (psc - rhs.subsecond as u32);
-        let rtc_ticks = self_ticks - other_ticks;
-
-        Duration::from_ticks(((rtc_ticks * TICK_HZ as u32) / (psc + 1)) as u64)
-    }
-}
-
 fn wucksel_compute_min(val: u32) -> (Wucksel, u32) {
     *[
         (Wucksel::DIV2, 2),
@@ -72,22 +20,15 @@ fn wucksel_compute_min(val: u32) -> (Wucksel, u32) {
 }
 
 impl Rtc {
-    /// Return the current instant.
-    fn instant(&self) -> Result<RtcInstant, RtcError> {
-        RtcTimeProvider::new().read(|_, tr, ss| {
-            let second = bcd2_to_byte((tr.st(), tr.su()));
+    pub(super) fn calc_epoch(&self) -> DateTime<Utc> {
+        let now: NaiveDateTime = RtcTimeProvider::new().now().unwrap().into();
 
-            RtcInstant::from(second, ss).map_err(RtcError::InvalidDateTime)
-        })
+        now.and_utc() - TimeDelta::microseconds(Instant::now().as_micros().try_into().unwrap())
     }
 
     /// start the wakeup alarm and with a duration that is as close to but less than
     /// the requested duration, and record the instant the wakeup alarm was started
-    pub(crate) fn start_wakeup_alarm(
-        &mut self,
-        requested_duration: embassy_time::Duration,
-        cs: critical_section::CriticalSection,
-    ) {
+    pub(crate) fn start_wakeup_alarm(&mut self, requested_duration: embassy_time::Duration) {
         // Panic if the rcc mod knows we're not using low-power rtc
         #[cfg(any(rcc_wb, rcc_f4, rcc_f410))]
         unsafe { crate::rcc::get_freqs() }.rtc.to_hertz().unwrap();
@@ -122,27 +63,19 @@ impl Rtc {
             regs.cr().modify(|w| w.set_wutie(true));
         });
 
-        let instant = self.instant().unwrap();
         trace!(
-            "rtc: start wakeup alarm for {} ms (psc: {}, ticks: {}) at {}",
+            "rtc: start wakeup alarm for {} ms (psc: {}, ticks: {})",
             Duration::from_ticks(rtc_ticks as u64 * TICK_HZ * prescaler as u64 / rtc_hz).as_millis(),
             prescaler as u32,
             rtc_ticks,
-            instant,
         );
-
-        assert!(self.stop_time.borrow(cs).replace(Some(instant)).is_none())
     }
 
     /// stop the wakeup alarm and return the time elapsed since `start_wakeup_alarm`
     /// was called, otherwise none
-    pub(crate) fn stop_wakeup_alarm(
-        &mut self,
-        cs: critical_section::CriticalSection,
-    ) -> Option<embassy_time::Duration> {
-        let instant = self.instant().unwrap();
+    pub(crate) fn stop_wakeup_alarm(&mut self) -> embassy_time::Instant {
         if RTC::regs().cr().read().wute() {
-            trace!("rtc: stop wakeup alarm at {}", instant);
+            trace!("rtc: stop wakeup alarm");
 
             self.write(false, |regs| {
                 regs.cr().modify(|w| w.set_wutie(false));
@@ -166,10 +99,13 @@ impl Rtc {
             });
         }
 
-        self.stop_time.borrow(cs).take().map(|stop_time| instant - stop_time)
+        let datetime: NaiveDateTime = RtcTimeProvider::new().now().expect("failed to read now").into();
+        let offset = datetime.and_utc() - self.epoch;
+
+        Instant::from_micros(offset.num_microseconds().unwrap().try_into().unwrap())
     }
 
-    pub(crate) fn enable_wakeup_line(&self) {
+    pub(super) fn enable_wakeup_line(&mut self) {
         <RTC as crate::rtc::SealedInstance>::WakeupInterrupt::unpend();
         unsafe { <RTC as crate::rtc::SealedInstance>::WakeupInterrupt::enable() };
 
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index e88bd7ab2..94ba13ae1 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -5,7 +5,7 @@ mod datetime;
 mod low_power;
 
 #[cfg(feature = "low-power")]
-use core::cell::{Cell, RefCell, RefMut};
+use core::cell::{RefCell, RefMut};
 #[cfg(feature = "low-power")]
 use core::ops;
 
@@ -163,7 +163,7 @@ impl<'a> ops::DerefMut for RtcBorrow<'a> {
 /// RTC driver.
 pub struct Rtc {
     #[cfg(feature = "low-power")]
-    stop_time: Mutex<CriticalSectionRawMutex, Cell<Option<low_power::RtcInstant>>>,
+    epoch: chrono::DateTime<chrono::Utc>,
     _private: (),
 }
 
@@ -225,7 +225,7 @@ impl Rtc {
 
         let mut this = Self {
             #[cfg(feature = "low-power")]
-            stop_time: Mutex::const_new(CriticalSectionRawMutex::new(), Cell::new(None)),
+            epoch: chrono::DateTime::from_timestamp_secs(0).unwrap(),
             _private: (),
         };
 
@@ -243,7 +243,10 @@ impl Rtc {
         }
 
         #[cfg(feature = "low-power")]
-        this.enable_wakeup_line();
+        {
+            this.enable_wakeup_line();
+            this.epoch = this.calc_epoch();
+        }
 
         this
     }
@@ -293,6 +296,11 @@ impl Rtc {
             });
         });
 
+        #[cfg(feature = "low-power")]
+        {
+            self.epoch = self.calc_epoch();
+        }
+
         Ok(())
     }
 
diff --git a/embassy-stm32/src/time_driver.rs b/embassy-stm32/src/time_driver.rs
index ed5d902bd..59ec58575 100644
--- a/embassy-stm32/src/time_driver.rs
+++ b/embassy-stm32/src/time_driver.rs
@@ -251,8 +251,8 @@ impl RtcDriver {
 
     #[cfg(feature = "low-power")]
     /// Add the given offset to the current time
-    fn add_time(&self, offset: embassy_time::Duration, cs: CriticalSection) {
-        let (period, counter) = calc_period_counter(self.now() + offset.as_ticks());
+    fn set_time(&self, instant: u64, cs: CriticalSection) {
+        let (period, counter) = calc_period_counter(core::cmp::max(self.now(), instant));
 
         self.period.store(period, Ordering::SeqCst);
         regs_gp16().cnt().write(|w| w.set_cnt(counter));
@@ -269,10 +269,17 @@ impl RtcDriver {
     #[cfg(feature = "low-power")]
     /// Stop the wakeup alarm, if enabled, and add the appropriate offset
     fn stop_wakeup_alarm(&self, cs: CriticalSection) {
-        if !regs_gp16().cr1().read().cen()
-            && let Some(offset) = self.rtc.borrow(cs).borrow_mut().as_mut().unwrap().stop_wakeup_alarm(cs)
-        {
-            self.add_time(offset, cs);
+        if !regs_gp16().cr1().read().cen() {
+            self.set_time(
+                self.rtc
+                    .borrow(cs)
+                    .borrow_mut()
+                    .as_mut()
+                    .unwrap()
+                    .stop_wakeup_alarm()
+                    .as_ticks(),
+                cs,
+            );
         }
     }
 
@@ -287,7 +294,7 @@ impl RtcDriver {
     #[cfg(feature = "low-power")]
     /// Set the rtc but panic if it's already been set
     pub(crate) fn set_rtc(&self, cs: CriticalSection, mut rtc: Rtc) {
-        rtc.stop_wakeup_alarm(cs);
+        rtc.stop_wakeup_alarm();
 
         assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none());
     }
@@ -310,7 +317,7 @@ impl RtcDriver {
                 .borrow_mut()
                 .as_mut()
                 .unwrap()
-                .start_wakeup_alarm(time_until_next_alarm, cs);
+                .start_wakeup_alarm(time_until_next_alarm);
 
             regs_gp16().cr1().modify(|w| w.set_cen(false));
             // save the count for the timer as its lost in STOP2 for stm32wlex
diff --git a/examples/mcxa/src/bin/reset-reason.rs b/examples/mcxa/src/bin/reset-reason.rs
index c244fbe04..2d48a92b1 100644
--- a/examples/mcxa/src/bin/reset-reason.rs
+++ b/examples/mcxa/src/bin/reset-reason.rs
@@ -11,5 +11,7 @@ async fn main(_spawner: Spawner) {
     let config = Config::default();
     let _p = hal::init(config);
 
-    defmt::info!("Reset Reason: '{}'", reset_reason());
+    for reason in reset_reason().into_iter() {
+        defmt::info!("Reset Reason: '{}'", reason);
+    }
 }
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index 83c375bc5..75dacbe7e 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -60,10 +60,12 @@ async fn async_main(spawner: Spawner) {
 
     let (rtc, _time_provider) = Rtc::new(p.RTC);
 
+    info!("set datetime");
     critical_section::with(|cs| {
         rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
     });
 
+    info!("spawn");
     spawner.spawn(task_1().unwrap());
     spawner.spawn(task_2().unwrap());
 }