Synchronize with main branch

7 files changed, 54 insertions, 23 deletions

diff --git a/embassy-stm32/CHANGELOG.md b/embassy-stm32/CHANGELOG.md
index 7311ea683..6e6a07037 100644
--- a/embassy-stm32/CHANGELOG.md
+++ b/embassy-stm32/CHANGELOG.md
@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased - ReleaseDate
 
+- fix: Fixed ADC4 enable() for WBA
+- feat: allow use of anyadcchannel for adc4
+- fix: fix incorrect logic for buffered usart transmission complete.
 - feat: add poll_for methods to exti
 - feat: implement stop for stm32wb.
 - change: rework hsem and add HIL test for some chips.
diff --git a/embassy-stm32/src/adc/adc4.rs b/embassy-stm32/src/adc/adc4.rs
index 499fc2093..472eb46fd 100644
--- a/embassy-stm32/src/adc/adc4.rs
+++ b/embassy-stm32/src/adc/adc4.rs
@@ -113,10 +113,26 @@ foreach_adc!(
             }
 
             fn enable() {
+                let cr_initial = ADC4::regs().cr().read();
+                let isr_initial = ADC4::regs().isr().read();
+
+                if cr_initial.aden() && isr_initial.adrdy() {
+                    return;
+                }
+
+                if cr_initial.aden() || cr_initial.adstart() {
+                    if cr_initial.adstart() {
+                        ADC4::regs().cr().modify(|w| w.set_adstp(true));
+                        while ADC4::regs().cr().read().adstart() {}
+                    }
+
+                    ADC4::regs().cr().modify(|w| w.set_addis(true));
+                    while ADC4::regs().cr().read().aden() {}
+                }
+
                 ADC4::regs().isr().write(|w| w.set_adrdy(true));
                 ADC4::regs().cr().modify(|w| w.set_aden(true));
                 while !ADC4::regs().isr().read().adrdy() {}
-                ADC4::regs().isr().write(|w| w.set_adrdy(true));
             }
 
             fn start() {
diff --git a/embassy-stm32/src/adc/mod.rs b/embassy-stm32/src/adc/mod.rs
index 74648cc21..755cb78c2 100644
--- a/embassy-stm32/src/adc/mod.rs
+++ b/embassy-stm32/src/adc/mod.rs
@@ -436,9 +436,9 @@ pub struct AnyAdcChannel<T> {
     is_differential: bool,
     _phantom: PhantomData<T>,
 }
-impl_peripheral!(AnyAdcChannel<T: Instance>);
-impl<T: Instance> AdcChannel<T> for AnyAdcChannel<T> {}
-impl<T: Instance> SealedAdcChannel<T> for AnyAdcChannel<T> {
+impl_peripheral!(AnyAdcChannel<T: AnyInstance>);
+impl<T: AnyInstance> AdcChannel<T> for AnyAdcChannel<T> {}
+impl<T: AnyInstance> SealedAdcChannel<T> for AnyAdcChannel<T> {
     fn channel(&self) -> u8 {
         self.channel
     }
diff --git a/embassy-stm32/src/adc/ringbuffered.rs b/embassy-stm32/src/adc/ringbuffered.rs
index a56f8ca0b..5437866d3 100644
--- a/embassy-stm32/src/adc/ringbuffered.rs
+++ b/embassy-stm32/src/adc/ringbuffered.rs
@@ -49,8 +49,6 @@ impl<'d, T: Instance + AnyInstance> RingBufferedAdc<'d, T> {
     }
 
     pub fn stop(&mut self) {
-        T::stop();
-
         self.ring_buf.request_pause();
 
         compiler_fence(Ordering::SeqCst);
@@ -161,7 +159,7 @@ impl<'d, T: Instance + AnyInstance> RingBufferedAdc<'d, T> {
                     return Ok(len);
                 }
                 Err(_) => {
-                    self.stop();
+                    self.ring_buf.request_pause();
 
                     return Err(OverrunError);
                 }
diff --git a/embassy-stm32/src/hsem/mod.rs b/embassy-stm32/src/hsem/mod.rs
index 5f1ed9b09..e62de0454 100644
--- a/embassy-stm32/src/hsem/mod.rs
+++ b/embassy-stm32/src/hsem/mod.rs
@@ -293,8 +293,13 @@ impl<T: Instance> HardwareSemaphore<T> {
 }
 
 #[cfg(all(stm32wb, feature = "low-power"))]
-pub(crate) fn init_hsem(_cs: CriticalSection) {
-    rcc::enable_and_reset::<crate::peripherals::HSEM>();
+pub(crate) fn init_hsem(cs: CriticalSection) {
+    rcc::enable_and_reset_with_cs::<crate::peripherals::HSEM>(cs);
+
+    unsafe {
+        crate::rcc::REFCOUNT_STOP1 = 0;
+        crate::rcc::REFCOUNT_STOP2 = 0;
+    }
 }
 
 struct State {
diff --git a/embassy-stm32/src/low_power.rs b/embassy-stm32/src/low_power.rs
index 15478eed4..9de49c867 100644
--- a/embassy-stm32/src/low_power.rs
+++ b/embassy-stm32/src/low_power.rs
@@ -50,7 +50,7 @@ use critical_section::CriticalSection;
 use embassy_executor::*;
 
 use crate::interrupt;
-use crate::rcc::{REFCOUNT_STOP1, REFCOUNT_STOP2};
+use crate::rcc::{RCC_CONFIG, REFCOUNT_STOP1, REFCOUNT_STOP2};
 use crate::time_driver::get_driver;
 
 const THREAD_PENDER: usize = usize::MAX;
@@ -147,17 +147,17 @@ pub enum StopMode {
     Stop2,
 }
 
-#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wlex, stm32u0))]
+#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wb, stm32wlex, stm32u0))]
 use crate::pac::pwr::vals::Lpms;
 
-#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wlex, stm32u0))]
+#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wb, stm32wlex, stm32u0))]
 impl Into<Lpms> for StopMode {
     fn into(self) -> Lpms {
         match self {
             StopMode::Stop1 => Lpms::STOP1,
-            #[cfg(not(stm32wba))]
+            #[cfg(not(any(stm32wb, stm32wba)))]
             StopMode::Stop2 => Lpms::STOP2,
-            #[cfg(stm32wba)]
+            #[cfg(any(stm32wb, stm32wba))]
             StopMode::Stop2 => Lpms::STOP1, // TODO: WBA has no STOP2?
         }
     }
@@ -201,7 +201,7 @@ impl Executor {
             {
                 use crate::pac::rcc::vals::Sw;
                 use crate::pac::{PWR, RCC};
-                use crate::rcc::{RCC_CONFIG, init as init_rcc};
+                use crate::rcc::init as init_rcc;
 
                 let extscr = PWR.extscr().read();
                 if extscr.c1stop2f() || extscr.c1stopf() {
@@ -237,13 +237,15 @@ impl Executor {
             trace!("low power: stop 1");
             Some(StopMode::Stop1)
         } else {
-            trace!("low power: not ready to stop");
+            trace!("low power: not ready to stop (refcount_stop1: {})", unsafe {
+                REFCOUNT_STOP1
+            });
             None
         }
     }
 
     #[cfg(all(stm32wb, feature = "low-power"))]
-    fn configure_stop_stm32wb(&self, _stop_mode: StopMode) -> Result<(), ()> {
+    fn configure_stop_stm32wb(&self, _cs: CriticalSection) -> Result<(), ()> {
         use core::task::Poll;
 
         use embassy_futures::poll_once;
@@ -252,14 +254,20 @@ impl Executor {
         use crate::pac::rcc::vals::{Smps, Sw};
         use crate::pac::{PWR, RCC};
 
+        trace!("low power: trying to get sem3");
+
         let sem3_mutex = match poll_once(HardwareSemaphoreChannel::<crate::peripherals::HSEM>::new(3).lock(0)) {
             Poll::Pending => None,
             Poll::Ready(mutex) => Some(mutex),
         }
         .ok_or(())?;
 
+        trace!("low power: got sem3");
+
         let sem4_mutex = HardwareSemaphoreChannel::<crate::peripherals::HSEM>::new(4).try_lock(0);
         if let Some(sem4_mutex) = sem4_mutex {
+            trace!("low power: got sem4");
+
             if PWR.extscr().read().c2ds() {
                 drop(sem4_mutex);
             } else {
@@ -295,11 +303,11 @@ impl Executor {
     }
 
     #[allow(unused_variables)]
-    fn configure_stop(&self, stop_mode: StopMode) -> Result<(), ()> {
+    fn configure_stop(&self, _cs: CriticalSection, stop_mode: StopMode) -> Result<(), ()> {
         #[cfg(all(stm32wb, feature = "low-power"))]
-        self.configure_stop_stm32wb(stop_mode)?;
+        self.configure_stop_stm32wb(_cs)?;
 
-        #[cfg(any(stm32l4, stm32l5, stm32u5, stm32u0, stm32wba, stm32wlex))]
+        #[cfg(any(stm32l4, stm32l5, stm32u5, stm32u0, stm32wb, stm32wba, stm32wlex))]
         crate::pac::PWR.cr1().modify(|m| m.set_lpms(stop_mode.into()));
         #[cfg(stm32h5)]
         crate::pac::PWR.pmcr().modify(|v| {
@@ -322,9 +330,10 @@ impl Executor {
         compiler_fence(Ordering::SeqCst);
 
         critical_section::with(|cs| {
+            let _ = unsafe { RCC_CONFIG }?;
             let stop_mode = Self::stop_mode(cs)?;
-            let _ = get_driver().pause_time(cs).ok()?;
-            self.configure_stop(stop_mode).ok()?;
+            get_driver().pause_time(cs).ok()?;
+            self.configure_stop(cs, stop_mode).ok()?;
 
             Some(())
         })
diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs
index 69c3a740f..26d2b8991 100644
--- a/embassy-stm32/src/usart/buffered.rs
+++ b/embassy-stm32/src/usart/buffered.rs
@@ -87,7 +87,7 @@ unsafe fn on_interrupt(r: Regs, state: &'static State) {
     // With `usart_v4` hardware FIFO is enabled and Transmission complete (TC)
     // indicates that all bytes are pushed out from the FIFO.
     // For other usart variants it shows that last byte from the buffer was just sent.
-    if sr_val.tc() {
+    if sr_val.tc() && r.cr1().read().tcie() {
         // For others it is cleared above with `clear_interrupt_flags`.
         #[cfg(any(usart_v1, usart_v2))]
         sr(r).modify(|w| w.set_tc(false));