Merge pull request #4838 from embassy-rs/lp2

stm32/low-power: cleanup and improve

17 files changed, 164 insertions, 168 deletions

diff --git a/embassy-stm32/CHANGELOG.md b/embassy-stm32/CHANGELOG.md
index b7d22da39..ee76a5d1b 100644
--- a/embassy-stm32/CHANGELOG.md
+++ b/embassy-stm32/CHANGELOG.md
@@ -43,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - adc: consolidate ringbuffer
 - feat: Added RTC low-power support for STM32WLEx ([#4716](https://github.com/embassy-rs/embassy/pull/4716))
 - fix: Correct STM32WBA VREFBUFTRIM values
+- low_power: remove stop_with rtc and initialize in init if low-power feature enabled.
 
 ## 0.4.0 - 2025-08-26
 
diff --git a/embassy-stm32/src/adc/v3.rs b/embassy-stm32/src/adc/v3.rs
index 62c2da557..170b08a25 100644
--- a/embassy-stm32/src/adc/v3.rs
+++ b/embassy-stm32/src/adc/v3.rs
@@ -463,7 +463,7 @@ impl<'d, T: Instance> Adc<'d, T> {
         );
 
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
 
         // Ensure no conversions are ongoing and ADC is enabled.
         Self::cancel_conversions();
diff --git a/embassy-stm32/src/exti.rs b/embassy-stm32/src/exti.rs
index 12600d4eb..2f5c3406a 100644
--- a/embassy-stm32/src/exti.rs
+++ b/embassy-stm32/src/exti.rs
@@ -71,7 +71,7 @@ unsafe fn on_irq() {
     }
 
     #[cfg(feature = "low-power")]
-    crate::low_power::on_wakeup_irq();
+    crate::low_power::Executor::on_wakeup_irq();
 }
 
 struct BitIter(u32);
diff --git a/embassy-stm32/src/i2c/v2.rs b/embassy-stm32/src/i2c/v2.rs
index 6f2d03bd1..ba9590013 100644
--- a/embassy-stm32/src/i2c/v2.rs
+++ b/embassy-stm32/src/i2c/v2.rs
@@ -73,7 +73,7 @@ pub(crate) unsafe fn on_interrupt<T: Instance>() {
     // restore the clocks to their last configured state as
     // much is lost in STOP modes
     #[cfg(all(feature = "low-power", stm32wlex))]
-    crate::low_power::on_wakeup_irq();
+    crate::low_power::Executor::on_wakeup_irq();
 
     let regs = T::info().regs;
     let isr = regs.isr().read();
@@ -820,7 +820,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// Write.
     pub async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> {
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
         if write.is_empty() {
             self.write_internal(address.into(), write, true, timeout)
@@ -836,7 +836,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// The buffers are concatenated in a single write transaction.
     pub async fn write_vectored(&mut self, address: Address, write: &[&[u8]]) -> Result<(), Error> {
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if write.is_empty() {
@@ -861,7 +861,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// Read.
     pub async fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Error> {
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if buffer.is_empty() {
@@ -875,7 +875,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// Write, restart, read.
     pub async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if write.is_empty() {
@@ -902,7 +902,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// [transaction contract]: embedded_hal_1::i2c::I2c::transaction
     pub async fn transaction(&mut self, addr: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
         #[cfg(all(feature = "low-power", stm32wlex))]
-        let _device_busy = crate::low_power::DeviceBusy::new();
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let _ = addr;
         let _ = operations;
         todo!()
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index dbf0fe620..85606e7de 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -241,6 +241,14 @@ pub struct Config {
     /// RCC config.
     pub rcc: rcc::Config,
 
+    #[cfg(feature = "low-power")]
+    /// RTC config
+    pub rtc: rtc::RtcConfig,
+
+    #[cfg(feature = "low-power")]
+    /// Minimum time to stop
+    pub min_stop_pause: embassy_time::Duration,
+
     /// Enable debug during sleep and stop.
     ///
     /// May increase power consumption. Defaults to true.
@@ -294,6 +302,10 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             rcc: Default::default(),
+            #[cfg(feature = "low-power")]
+            rtc: Default::default(),
+            #[cfg(feature = "low-power")]
+            min_stop_pause: embassy_time::Duration::from_millis(250),
             #[cfg(dbgmcu)]
             enable_debug_during_sleep: true,
             #[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba))]
@@ -623,6 +635,12 @@ fn init_hw(config: Config) -> Peripherals {
             exti::init(cs);
 
             rcc::init_rcc(cs, config.rcc);
+
+            #[cfg(feature = "low-power")]
+            crate::rtc::init_rtc(cs, config.rtc);
+
+            #[cfg(feature = "low-power")]
+            crate::time_driver::get_driver().set_min_stop_pause(cs, config.min_stop_pause);
         }
 
         p
diff --git a/embassy-stm32/src/low_power.rs b/embassy-stm32/src/low_power.rs
index cde3153f6..597cedf86 100644
--- a/embassy-stm32/src/low_power.rs
+++ b/embassy-stm32/src/low_power.rs
@@ -41,10 +41,6 @@
 //!     config.enable_debug_during_sleep = false;
 //!     let p = embassy_stm32::init(config);
 //!
-//!     // give the RTC to the executor...
-//!     let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
-//!     embassy_stm32::low_power::stop_with_rtc(rtc);
-//!
 //!     // your application here...
 //! }
 //! ```
@@ -57,10 +53,11 @@ use core::marker::PhantomData;
 use core::sync::atomic::{Ordering, compiler_fence};
 
 use cortex_m::peripheral::SCB;
+use critical_section::CriticalSection;
 use embassy_executor::*;
 
 use crate::interrupt;
-use crate::time_driver::{RtcDriver, get_driver};
+use crate::time_driver::get_driver;
 
 const THREAD_PENDER: usize = usize::MAX;
 
@@ -68,46 +65,59 @@ use crate::rtc::Rtc;
 
 static mut EXECUTOR: Option<Executor> = None;
 
-#[cfg(stm32wlex)]
-pub(crate) use self::busy::DeviceBusy;
-#[cfg(stm32wlex)]
-mod busy {
-    use core::sync::atomic::{AtomicU32, Ordering};
+/// Prevent the device from going into the stop mode if held
+pub struct DeviceBusy(StopMode);
 
-    // Count of devices blocking STOP
-    static STOP_BLOCKED: AtomicU32 = AtomicU32::new(0);
+impl DeviceBusy {
+    /// Create a new DeviceBusy with stop1.
+    pub fn new_stop1() -> Self {
+        Self::new(StopMode::Stop1)
+    }
 
-    /// Check if STOP1 is blocked.
-    pub(crate) fn stop_blocked() -> bool {
-        STOP_BLOCKED.load(Ordering::SeqCst) > 0
+    /// Create a new DeviceBusy with stop2.
+    pub fn new_stop2() -> Self {
+        Self::new(StopMode::Stop2)
     }
 
-    /// When ca device goes busy it will construct one of these where it will be dropped when the device goes idle.
-    pub(crate) struct DeviceBusy {}
+    /// Create a new DeviceBusy.
+    pub fn new(stop_mode: StopMode) -> Self {
+        critical_section::with(|_| unsafe {
+            match stop_mode {
+                StopMode::Stop1 => {
+                    crate::rcc::REFCOUNT_STOP1 += 1;
+                }
+                StopMode::Stop2 => {
+                    crate::rcc::REFCOUNT_STOP2 += 1;
+                }
+            }
+        });
 
-    impl DeviceBusy {
-        /// Create a new DeviceBusy.
-        pub(crate) fn new() -> Self {
-            STOP_BLOCKED.fetch_add(1, Ordering::SeqCst);
-            trace!("low power: device busy: Stop:{}", STOP_BLOCKED.load(Ordering::SeqCst));
-            Self {}
-        }
+        Self(stop_mode)
     }
+}
 
-    impl Drop for DeviceBusy {
-        fn drop(&mut self) {
-            STOP_BLOCKED.fetch_sub(1, Ordering::SeqCst);
-            trace!("low power: device idle: Stop:{}", STOP_BLOCKED.load(Ordering::SeqCst));
-        }
+impl Drop for DeviceBusy {
+    fn drop(&mut self) {
+        critical_section::with(|_| unsafe {
+            match self.0 {
+                StopMode::Stop1 => {
+                    crate::rcc::REFCOUNT_STOP1 -= 1;
+                }
+                StopMode::Stop2 => {
+                    crate::rcc::REFCOUNT_STOP2 -= 1;
+                }
+            }
+        });
     }
 }
+
 #[cfg(not(stm32u0))]
 foreach_interrupt! {
     (RTC, rtc, $block:ident, WKUP, $irq:ident) => {
         #[interrupt]
         #[allow(non_snake_case)]
         unsafe fn $irq() {
-            EXECUTOR.as_mut().unwrap().on_wakeup_irq();
+            Executor::on_wakeup_irq();
         }
     };
 }
@@ -118,27 +128,14 @@ foreach_interrupt! {
         #[interrupt]
         #[allow(non_snake_case)]
         unsafe fn $irq() {
-            EXECUTOR.as_mut().unwrap().on_wakeup_irq();
+            Executor::on_wakeup_irq();
         }
     };
 }
 
-#[allow(dead_code)]
-pub(crate) unsafe fn on_wakeup_irq() {
-    if EXECUTOR.is_some() {
-        trace!("low power: wakeup irq");
-        EXECUTOR.as_mut().unwrap().on_wakeup_irq();
-    }
-}
-
-/// Configure STOP mode with RTC.
-pub fn stop_with_rtc(rtc: Rtc) {
-    unsafe { EXECUTOR.as_mut().unwrap() }.stop_with_rtc(rtc)
-}
-
 /// Reconfigure the RTC, if set.
-pub fn reconfigure_rtc(f: impl FnOnce(&mut Rtc)) {
-    unsafe { EXECUTOR.as_mut().unwrap() }.reconfigure_rtc(f);
+pub fn reconfigure_rtc<R>(f: impl FnOnce(&mut Rtc) -> R) -> R {
+    get_driver().reconfigure_rtc(f)
 }
 
 /// Get whether the core is ready to enter the given stop mode.
@@ -146,11 +143,11 @@ pub fn reconfigure_rtc(f: impl FnOnce(&mut Rtc)) {
 /// This will return false if some peripheral driver is in use that
 /// prevents entering the given stop mode.
 pub fn stop_ready(stop_mode: StopMode) -> bool {
-    match unsafe { EXECUTOR.as_mut().unwrap() }.stop_mode() {
+    critical_section::with(|cs| match Executor::stop_mode(cs) {
         Some(StopMode::Stop2) => true,
         Some(StopMode::Stop1) => stop_mode == StopMode::Stop1,
         None => false,
-    }
+    })
 }
 
 /// Available Stop modes.
@@ -193,7 +190,6 @@ pub struct Executor {
     inner: raw::Executor,
     not_send: PhantomData<*mut ()>,
     scb: SCB,
-    time_driver: &'static RtcDriver,
 }
 
 impl Executor {
@@ -206,7 +202,6 @@ impl Executor {
                 inner: raw::Executor::new(THREAD_PENDER as *mut ()),
                 not_send: PhantomData,
                 scb: cortex_m::Peripherals::steal().SCB,
-                time_driver: get_driver(),
             });
 
             let executor = EXECUTOR.as_mut().unwrap();
@@ -215,54 +210,33 @@ impl Executor {
         })
     }
 
-    unsafe fn on_wakeup_irq(&mut self) {
-        #[cfg(stm32wlex)]
-        {
-            let extscr = crate::pac::PWR.extscr().read();
-            if extscr.c1stop2f() || extscr.c1stopf() {
-                // when we wake from any stop mode we need to re-initialize the rcc
-                crate::rcc::apply_resume_config();
-                if extscr.c1stop2f() {
-                    // when we wake from STOP2, we need to re-initialize the time driver
-                    critical_section::with(|cs| crate::time_driver::init_timer(cs));
-                    // reset the refcounts for STOP2 and STOP1 (initializing the time driver will increment one of them for the timer)
-                    // and given that we just woke from STOP2, we can reset them
-                    crate::rcc::REFCOUNT_STOP2 = 0;
-                    crate::rcc::REFCOUNT_STOP1 = 0;
+    pub(crate) unsafe fn on_wakeup_irq() {
+        critical_section::with(|cs| {
+            #[cfg(stm32wlex)]
+            {
+                let extscr = crate::pac::PWR.extscr().read();
+                if extscr.c1stop2f() || extscr.c1stopf() {
+                    // when we wake from any stop mode we need to re-initialize the rcc
+                    crate::rcc::apply_resume_config();
+                    if extscr.c1stop2f() {
+                        // when we wake from STOP2, we need to re-initialize the time driver
+                        crate::time_driver::init_timer(cs);
+                        // reset the refcounts for STOP2 and STOP1 (initializing the time driver will increment one of them for the timer)
+                        // and given that we just woke from STOP2, we can reset them
+                        crate::rcc::REFCOUNT_STOP2 = 0;
+                        crate::rcc::REFCOUNT_STOP1 = 0;
+                    }
                 }
             }
-        }
-        self.time_driver.resume_time();
-        trace!("low power: resume");
-    }
-
-    pub(self) fn stop_with_rtc(&mut self, rtc: Rtc) {
-        self.time_driver.set_rtc(rtc);
-        self.time_driver.reconfigure_rtc(|rtc| rtc.enable_wakeup_line());
-
-        trace!("low power: stop with rtc configured");
-    }
-
-    pub(self) fn reconfigure_rtc(&mut self, f: impl FnOnce(&mut Rtc)) {
-        self.time_driver.reconfigure_rtc(f);
-    }
-
-    fn stop1_ok_to_enter(&self) -> bool {
-        #[cfg(stm32wlex)]
-        if self::busy::stop_blocked() {
-            return false;
-        }
-        unsafe { crate::rcc::REFCOUNT_STOP1 == 0 }
-    }
-
-    fn stop2_ok_to_enter(&self) -> bool {
-        self.stop1_ok_to_enter() && unsafe { crate::rcc::REFCOUNT_STOP2 == 0 }
+            get_driver().resume_time(cs);
+            trace!("low power: resume");
+        });
     }
 
-    fn stop_mode(&self) -> Option<StopMode> {
-        if self.stop2_ok_to_enter() {
+    fn stop_mode(_cs: CriticalSection) -> Option<StopMode> {
+        if unsafe { crate::rcc::REFCOUNT_STOP2 == 0 && crate::rcc::REFCOUNT_STOP1 == 0 } {
             Some(StopMode::Stop2)
-        } else if self.stop1_ok_to_enter() {
+        } else if unsafe { crate::rcc::REFCOUNT_STOP1 == 0 } {
             Some(StopMode::Stop1)
         } else {
             None
@@ -291,14 +265,14 @@ impl Executor {
 
         compiler_fence(Ordering::SeqCst);
 
-        let stop_mode = self.stop_mode();
+        let stop_mode = critical_section::with(|cs| Self::stop_mode(cs));
 
         if stop_mode.is_none() {
             trace!("low power: not ready to stop");
             return;
         }
 
-        if self.time_driver.pause_time().is_err() {
+        if get_driver().pause_time().is_err() {
             trace!("low power: failed to pause time");
             return;
         }
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index bc6df528b..fa5b45e3c 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -8,6 +8,8 @@ mod low_power;
 use core::cell::Cell;
 
 #[cfg(feature = "low-power")]
+use critical_section::CriticalSection;
+#[cfg(feature = "low-power")]
 use embassy_sync::blocking_mutex::Mutex;
 #[cfg(feature = "low-power")]
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
@@ -44,11 +46,18 @@ pub enum RtcError {
 }
 
 /// Provides immutable access to the current time of the RTC.
+#[derive(Clone)]
 pub struct RtcTimeProvider {
     _private: (),
 }
 
 impl RtcTimeProvider {
+    #[cfg(feature = "low-power")]
+    /// Create a new RTC time provider instance.
+    pub fn new(_rtc: Peri<'static, RTC>) -> Self {
+        Self { _private: () }
+    }
+
     /// Return the current datetime.
     ///
     /// # Errors
@@ -145,8 +154,13 @@ pub enum RtcCalibrationCyclePeriod {
 }
 
 impl Rtc {
+    #[cfg(not(feature = "low-power"))]
     /// Create a new RTC instance.
     pub fn new(_rtc: Peri<'static, RTC>, rtc_config: RtcConfig) -> Self {
+        Self::new_inner(rtc_config)
+    }
+
+    pub(self) fn new_inner(rtc_config: RtcConfig) -> Self {
         #[cfg(not(any(stm32l0, stm32f3, stm32l1, stm32f0, stm32f2)))]
         crate::rcc::enable_and_reset::<RTC>();
 
@@ -169,6 +183,9 @@ impl Rtc {
             while now == this.time_provider().read(|_, _, ss| Ok(ss)).unwrap() {}
         }
 
+        #[cfg(feature = "low-power")]
+        this.enable_wakeup_line();
+
         this
     }
 
@@ -315,3 +332,10 @@ trait SealedInstance {
 
     // fn apply_config(&mut self, rtc_config: RtcConfig);
 }
+
+#[cfg(feature = "low-power")]
+pub(crate) fn init_rtc(cs: CriticalSection, config: RtcConfig) {
+    crate::time_driver::get_driver().set_rtc(cs, Rtc::new_inner(config));
+
+    trace!("low power: stop with rtc configured");
+}
diff --git a/embassy-stm32/src/time_driver.rs b/embassy-stm32/src/time_driver.rs
index 4956d1f68..1941788e8 100644
--- a/embassy-stm32/src/time_driver.rs
+++ b/embassy-stm32/src/time_driver.rs
@@ -216,6 +216,9 @@ pub(crate) struct RtcDriver {
     alarm: Mutex<CriticalSectionRawMutex, AlarmState>,
     #[cfg(feature = "low-power")]
     rtc: Mutex<CriticalSectionRawMutex, RefCell<Option<Rtc>>>,
+    #[cfg(feature = "low-power")]
+    /// The minimum pause time beyond which the executor will enter a low-power state.
+    min_stop_pause: Mutex<CriticalSectionRawMutex, Cell<embassy_time::Duration>>,
     /// Saved count for the timer (its value is lost when entering STOP2)
     #[cfg(all(feature = "low-power", stm32wlex))]
     saved_count: AtomicU16,
@@ -227,6 +230,8 @@ embassy_time_driver::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
     alarm: Mutex::const_new(CriticalSectionRawMutex::new(), AlarmState::new()),
     #[cfg(feature = "low-power")]
     rtc: Mutex::const_new(CriticalSectionRawMutex::new(), RefCell::new(None)),
+    #[cfg(feature = "low-power")]
+    min_stop_pause: Mutex::const_new(CriticalSectionRawMutex::new(), Cell::new(embassy_time::Duration::from_millis(0))),
     #[cfg(all(feature = "low-power", stm32wlex))]
     saved_count: AtomicU16::new(0),
     queue: Mutex::new(RefCell::new(Queue::new()))
@@ -400,27 +405,26 @@ impl RtcDriver {
     }
 
     /*
-        Low-power public functions: all create a critical section
+        Low-power public functions: all create or require a critical section
     */
     #[cfg(feature = "low-power")]
-    /// Set the rtc but panic if it's already been set
-    pub(crate) fn set_rtc(&self, mut rtc: Rtc) {
-        critical_section::with(|cs| {
-            rtc.stop_wakeup_alarm(cs);
-
-            assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none())
-        });
+    pub(crate) fn set_min_stop_pause(&self, cs: CriticalSection, min_stop_pause: embassy_time::Duration) {
+        self.min_stop_pause.borrow(cs).replace(min_stop_pause);
     }
 
     #[cfg(feature = "low-power")]
     /// Set the rtc but panic if it's already been set
-    pub(crate) fn reconfigure_rtc(&self, f: impl FnOnce(&mut Rtc)) {
-        critical_section::with(|cs| f(self.rtc.borrow(cs).borrow_mut().as_mut().unwrap()));
+    pub(crate) fn set_rtc(&self, cs: CriticalSection, mut rtc: Rtc) {
+        rtc.stop_wakeup_alarm(cs);
+
+        assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none());
     }
 
     #[cfg(feature = "low-power")]
-    /// The minimum pause time beyond which the executor will enter a low-power state.
-    pub(crate) const MIN_STOP_PAUSE: embassy_time::Duration = embassy_time::Duration::from_millis(250);
+    /// Reconfigure the rtc
+    pub(crate) fn reconfigure_rtc<R>(&self, f: impl FnOnce(&mut Rtc) -> R) -> R {
+        critical_section::with(|cs| f(self.rtc.borrow(cs).borrow_mut().as_mut().unwrap()))
+    }
 
     #[cfg(feature = "low-power")]
     /// Pause the timer if ready; return err if not
@@ -434,9 +438,9 @@ impl RtcDriver {
             self.stop_wakeup_alarm(cs);
 
             let time_until_next_alarm = self.time_until_next_alarm(cs);
-            if time_until_next_alarm < Self::MIN_STOP_PAUSE {
+            if time_until_next_alarm < self.min_stop_pause.borrow(cs).get() {
                 trace!(
-                    "time_until_next_alarm < Self::MIN_STOP_PAUSE ({})",
+                    "time_until_next_alarm < self.min_stop_pause ({})",
                     time_until_next_alarm
                 );
                 Err(())
@@ -460,18 +464,16 @@ impl RtcDriver {
 
     #[cfg(feature = "low-power")]
     /// Resume the timer with the given offset
-    pub(crate) fn resume_time(&self) {
+    pub(crate) fn resume_time(&self, cs: CriticalSection) {
         if regs_gp16().cr1().read().cen() {
             // Time isn't currently stopped
 
             return;
         }
 
-        critical_section::with(|cs| {
-            self.stop_wakeup_alarm(cs);
+        self.stop_wakeup_alarm(cs);
 
-            regs_gp16().cr1().modify(|w| w.set_cen(true));
-        })
+        regs_gp16().cr1().modify(|w| w.set_cen(true));
     }
 
     fn set_alarm(&self, cs: CriticalSection, timestamp: u64) -> bool {
@@ -543,7 +545,7 @@ impl Driver for RtcDriver {
 }
 
 #[cfg(feature = "low-power")]
-pub(crate) fn get_driver() -> &'static RtcDriver {
+pub(crate) const fn get_driver() -> &'static RtcDriver {
     &DRIVER
 }
 
diff --git a/embassy-stm32/src/timer/mod.rs b/embassy-stm32/src/timer/mod.rs
index b09bc7166..804d1ef37 100644
--- a/embassy-stm32/src/timer/mod.rs
+++ b/embassy-stm32/src/timer/mod.rs
@@ -399,7 +399,7 @@ pub struct UpdateInterruptHandler<T: CoreInstance> {
 impl<T: CoreInstance> interrupt::typelevel::Handler<T::UpdateInterrupt> for UpdateInterruptHandler<T> {
     unsafe fn on_interrupt() {
         #[cfg(feature = "low-power")]
-        crate::low_power::on_wakeup_irq();
+        crate::low_power::Executor::on_wakeup_irq();
 
         let regs = crate::pac::timer::TimCore::from_ptr(T::regs());
 
@@ -429,7 +429,7 @@ impl<T: GeneralInstance1Channel> interrupt::typelevel::Handler<T::CaptureCompare
 {
     unsafe fn on_interrupt() {
         #[cfg(feature = "low-power")]
-        crate::low_power::on_wakeup_irq();
+        crate::low_power::Executor::on_wakeup_irq();
 
         let regs = crate::pac::timer::TimGp16::from_ptr(T::regs());
 
diff --git a/examples/stm32h5/src/bin/stop.rs b/examples/stm32h5/src/bin/stop.rs
index 2026d8f99..caebc9daf 100644
--- a/examples/stm32h5/src/bin/stop.rs
+++ b/examples/stm32h5/src/bin/stop.rs
@@ -9,7 +9,6 @@ use embassy_executor::Spawner;
 use embassy_stm32::gpio::{AnyPin, Level, Output, Speed};
 use embassy_stm32::low_power::Executor;
 use embassy_stm32::rcc::{HSIPrescaler, LsConfig};
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::{Config, Peri};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
@@ -36,10 +35,6 @@ async fn async_main(spawner: Spawner) {
     // config.enable_debug_during_sleep = false;
     let p = embassy_stm32::init(config);
 
-    // give the RTC to the executor...
-    let rtc = Rtc::new(p.RTC, RtcConfig::default());
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     spawner.spawn(unwrap!(blinky(p.PB4.into())));
     spawner.spawn(unwrap!(timeout()));
 }
diff --git a/examples/stm32l5/src/bin/stop.rs b/examples/stm32l5/src/bin/stop.rs
index 7662dbfa8..3d119f90f 100644
--- a/examples/stm32l5/src/bin/stop.rs
+++ b/examples/stm32l5/src/bin/stop.rs
@@ -6,7 +6,6 @@ use embassy_executor::Spawner;
 use embassy_stm32::gpio::{AnyPin, Level, Output, Speed};
 use embassy_stm32::low_power::Executor;
 use embassy_stm32::rcc::LsConfig;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::{Config, Peri};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
@@ -27,10 +26,6 @@ async fn async_main(spawner: Spawner) {
     // config.enable_debug_during_sleep = false;
     let p = embassy_stm32::init(config);
 
-    // give the RTC to the executor...
-    let rtc = Rtc::new(p.RTC, RtcConfig::default());
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     spawner.spawn(unwrap!(blinky(p.PC7.into())));
     spawner.spawn(unwrap!(timeout()));
 }
diff --git a/examples/stm32wle5/src/bin/adc.rs b/examples/stm32wle5/src/bin/adc.rs
index ff1a5fa16..8b830a1e6 100644
--- a/examples/stm32wle5/src/bin/adc.rs
+++ b/examples/stm32wle5/src/bin/adc.rs
@@ -7,7 +7,6 @@ use defmt_rtt as _;
 use embassy_executor::Spawner;
 use embassy_stm32::adc::{Adc, SampleTime};
 use embassy_stm32::low_power::Executor;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
 use panic_probe as _;
 use static_cell::StaticCell;
@@ -71,11 +70,6 @@ async fn async_main(_spawner: Spawner) {
         defmt_serial::defmt_serial(SERIAL.init(uart));
     }
 
-    // give the RTC to the low_power executor...
-    let rtc_config = RtcConfig::default();
-    let rtc = Rtc::new(p.RTC, rtc_config);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     info!("Hello World!");
 
     let mut adc = Adc::new(p.ADC1);
diff --git a/examples/stm32wle5/src/bin/blinky.rs b/examples/stm32wle5/src/bin/blinky.rs
index 1191a1157..b2745fdaf 100644
--- a/examples/stm32wle5/src/bin/blinky.rs
+++ b/examples/stm32wle5/src/bin/blinky.rs
@@ -7,7 +7,6 @@ use defmt_rtt as _;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_stm32::low_power::Executor;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
 use panic_probe as _;
 use static_cell::StaticCell;
@@ -69,11 +68,6 @@ async fn async_main(_spawner: Spawner) {
         defmt_serial::defmt_serial(SERIAL.init(uart));
     }
 
-    // give the RTC to the low_power executor...
-    let rtc_config = RtcConfig::default();
-    let rtc = Rtc::new(p.RTC, rtc_config);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     info!("Hello World!");
 
     let mut led = Output::new(p.PB5, Level::High, Speed::Low);
diff --git a/examples/stm32wle5/src/bin/button_exti.rs b/examples/stm32wle5/src/bin/button_exti.rs
index f07f9724d..db1bff0be 100644
--- a/examples/stm32wle5/src/bin/button_exti.rs
+++ b/examples/stm32wle5/src/bin/button_exti.rs
@@ -8,7 +8,6 @@ use embassy_executor::Spawner;
 use embassy_stm32::exti::ExtiInput;
 use embassy_stm32::gpio::Pull;
 use embassy_stm32::low_power::Executor;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use panic_probe as _;
 use static_cell::StaticCell;
 
@@ -71,11 +70,6 @@ async fn async_main(_spawner: Spawner) {
         defmt_serial::defmt_serial(SERIAL.init(uart));
     }
 
-    // give the RTC to the low_power executor...
-    let rtc_config = RtcConfig::default();
-    let rtc = Rtc::new(p.RTC, rtc_config);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     info!("Hello World!");
 
     let mut button = ExtiInput::new(p.PA0, p.EXTI0, Pull::Up);
diff --git a/examples/stm32wle5/src/bin/i2c.rs b/examples/stm32wle5/src/bin/i2c.rs
index af07f911e..c31c673c9 100644
--- a/examples/stm32wle5/src/bin/i2c.rs
+++ b/examples/stm32wle5/src/bin/i2c.rs
@@ -7,7 +7,6 @@ use defmt_rtt as _;
 use embassy_executor::Spawner;
 use embassy_stm32::i2c::I2c;
 use embassy_stm32::low_power::Executor;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::time::Hertz;
 use embassy_stm32::{bind_interrupts, i2c, peripherals};
 use embassy_time::{Duration, Timer};
@@ -78,11 +77,6 @@ async fn async_main(_spawner: Spawner) {
         defmt_serial::defmt_serial(SERIAL.init(uart));
     }
 
-    // give the RTC to the low_power executor...
-    let rtc_config = RtcConfig::default();
-    let rtc = Rtc::new(p.RTC, rtc_config);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     info!("Hello World!");
     let en3v3 = embassy_stm32::gpio::Output::new(
         p.PA9,
diff --git a/tests/stm32/src/bin/rtc.rs b/tests/stm32/src/bin/rtc.rs
index 5fe98d807..5c80eb250 100644
--- a/tests/stm32/src/bin/rtc.rs
+++ b/tests/stm32/src/bin/rtc.rs
@@ -9,10 +9,14 @@ use chrono::{NaiveDate, NaiveDateTime};
 use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
+#[cfg(feature = "stop")]
+use embassy_stm32::low_power::reconfigure_rtc;
 use embassy_stm32::rcc::LsConfig;
+#[cfg(feature = "stop")]
+use embassy_stm32::rtc::RtcTimeProvider;
+#[cfg(not(feature = "stop"))]
 use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = config();
@@ -26,14 +30,26 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
+    #[cfg(not(feature = "stop"))]
     let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
 
+    #[cfg(feature = "stop")]
+    let time_provider = RtcTimeProvider::new(p.RTC);
+
+    #[cfg(not(feature = "stop"))]
     rtc.set_datetime(now.into()).expect("datetime not set");
 
+    #[cfg(feature = "stop")]
+    reconfigure_rtc(|rtc| rtc.set_datetime(now.into()).expect("datetime not set"));
+
     info!("Waiting 5 seconds");
     Timer::after_millis(5000).await;
 
+    #[cfg(not(feature = "stop"))]
     let then: NaiveDateTime = rtc.now().unwrap().into();
+    #[cfg(feature = "stop")]
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
+
     let seconds = (then - now).num_seconds();
 
     info!("measured = {}", seconds);
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index 73580f0f2..a9dbac676 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -10,9 +10,8 @@ use common::*;
 use cortex_m_rt::entry;
 use embassy_executor::Spawner;
 use embassy_stm32::Config;
-use embassy_stm32::low_power::{Executor, StopMode, stop_ready, stop_with_rtc};
+use embassy_stm32::low_power::{Executor, StopMode, reconfigure_rtc, stop_ready};
 use embassy_stm32::rcc::LsConfig;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
 
 #[entry]
@@ -57,7 +56,7 @@ async fn async_main(spawner: Spawner) {
         config.rcc.hsi = Some(HSIPrescaler::DIV4); // 64 MHz HSI will need a /4
     }
 
-    let p = init_with_config(config);
+    let _p = init_with_config(config);
     info!("Hello World!");
 
     let now = NaiveDate::from_ymd_opt(2020, 5, 15)
@@ -65,11 +64,7 @@ async fn async_main(spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
-
-    rtc.set_datetime(now.into()).expect("datetime not set");
-
-    stop_with_rtc(rtc);
+    reconfigure_rtc(|rtc| rtc.set_datetime(now.into()).expect("datetime not set"));
 
     spawner.spawn(task_1().unwrap());
     spawner.spawn(task_2().unwrap());