make min_stop_pause configurable

4 files changed, 35 insertions, 36 deletions

diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index be5552400..85606e7de 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -245,6 +245,10 @@ pub struct Config {
     /// 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.
@@ -300,6 +304,8 @@ impl Default for Config {
             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))]
@@ -632,6 +638,9 @@ fn init_hw(config: Config) -> Peripherals {
 
             #[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 9450b363f..597cedf86 100644
--- a/embassy-stm32/src/low_power.rs
+++ b/embassy-stm32/src/low_power.rs
@@ -134,8 +134,8 @@ foreach_interrupt! {
 }
 
 /// Reconfigure the RTC, if set.
-pub fn reconfigure_rtc(f: impl FnOnce(&mut Rtc)) {
-    get_driver().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.
@@ -212,12 +212,6 @@ impl Executor {
 
     pub(crate) unsafe fn on_wakeup_irq() {
         critical_section::with(|cs| {
-            if !get_driver().is_rtc_set(cs) {
-                trace!("low power: wakeup irq; rtc not set");
-
-                return;
-            }
-
             #[cfg(stm32wlex)]
             {
                 let extscr = crate::pac::PWR.extscr().read();
@@ -234,7 +228,7 @@ impl Executor {
                     }
                 }
             }
-            get_driver().resume_time();
+            get_driver().resume_time(cs);
             trace!("low power: resume");
         });
     }
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index 29e77ccc0..fa5b45e3c 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -334,8 +334,8 @@ trait SealedInstance {
 }
 
 #[cfg(feature = "low-power")]
-pub(crate) fn init_rtc(_cs: CriticalSection, config: RtcConfig) {
-    crate::time_driver::get_driver().set_rtc(Rtc::new_inner(config));
+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 152d3d22e..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,33 +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())
-        });
-    }
-
-    #[cfg(feature = "low-power")]
-    /// Has the rtc been set?
-    pub(crate) fn is_rtc_set(&self, cs: CriticalSection) -> bool {
-        self.rtc.borrow(cs).borrow().is_some()
+    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
@@ -440,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(())
@@ -466,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 {