Add IRQ-driven buffered USART implementation for STM32 v2 usart (#356)

* Add IRQ-driven buffered USART implementation for STM32 v2 usart

* Implementation based on nRF UARTE, but simplified to not use DMA to
  avoid complex interaction between DMA and USART.
* Implementation of AsyncBufRead and AsyncWrite traits
* Some unit tests to ring buffer
* Update polyfill version
* Update sub module to get usart IRQ fix

embassy-stm32/Cargo.toml

@@ -23,7 +23,7 @@ sdio-host = { version = "0.5.0" }
 embedded-sdmmc = { git = "https://github.com/thalesfragoso/embedded-sdmmc-rs", branch = "async", optional = true }
 critical-section = "0.2.1"
 bare-metal = "1.0.0"
-atomic-polyfill = "0.1.2"
+atomic-polyfill = "0.1.3"
 stm32-metapac = { version = "0.1.0", path = "../stm32-metapac", features = ["rt"] }
 vcell = { version = "0.1.3", optional = true }
 

embassy-stm32/src/usart/mod.rs

@@ -8,6 +8,7 @@ pub use _version::*;
 
 use crate::gpio::Pin;
 use crate::rcc::RccPeripheral;
+use embassy::interrupt::Interrupt;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum DataBits {
@@ -100,7 +101,9 @@ pub(crate) mod sealed {
     }
 }
 
-pub trait Instance: sealed::Instance + RccPeripheral {}
+pub trait Instance: sealed::Instance + RccPeripheral {
+    type Interrupt: Interrupt;
+}
 pub trait RxPin<T: Instance>: sealed::RxPin<T> {}
 pub trait TxPin<T: Instance>: sealed::TxPin<T> {}
 pub trait CtsPin<T: Instance>: sealed::CtsPin<T> {}
@@ -109,15 +112,18 @@ pub trait CkPin<T: Instance>: sealed::CkPin<T> {}
 pub trait RxDma<T: Instance>: sealed::RxDma<T> + dma::Channel {}
 pub trait TxDma<T: Instance>: sealed::TxDma<T> + dma::Channel {}
 
-crate::pac::peripherals!(
-    (usart, $inst:ident) => {
+crate::pac::interrupts!(
+    ($inst:ident, usart, $block:ident, $signal_name:ident, $irq:ident) => {
         impl sealed::Instance for peripherals::$inst {
             fn regs(&self) -> crate::pac::usart::Usart {
                 crate::pac::$inst
             }
         }
 
-        impl Instance for peripherals::$inst {}
+        impl Instance for peripherals::$inst {
+            type Interrupt = crate::interrupt::$irq;
+        }
+
     };
 );
 

embassy-stm32/src/usart/v2.rs

@@ -1,6 +1,12 @@
+use atomic_polyfill::{compiler_fence, Ordering};
 use core::future::Future;
 use core::marker::PhantomData;
-use embassy::util::Unborrow;
+use core::pin::Pin;
+use core::task::Context;
+use core::task::Poll;
+use embassy::util::{Unborrow, WakerRegistration};
+use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
+use embassy_hal_common::ring_buffer::RingBuffer;
 use embassy_hal_common::unborrow;
 use futures::TryFutureExt;
 
@@ -12,7 +18,6 @@ pub struct Uart<'d, T: Instance, TxDma = NoDma, RxDma = NoDma> {
     inner: T,
     phantom: PhantomData<&'d mut T>,
     tx_dma: TxDma,
-    #[allow(dead_code)]
     rx_dma: RxDma,
 }
 
@@ -153,25 +158,226 @@ impl<'d, T: Instance, RxDma> embedded_hal::blocking::serial::Write<u8>
 }
 
 // rustfmt::skip because intellij removes the 'where' claus on the associated type.
-#[rustfmt::skip]
 impl<'d, T: Instance, TxDma, RxDma> embassy_traits::uart::Write for Uart<'d, T, TxDma, RxDma>
-    where TxDma: crate::usart::TxDma<T>
+where
+    TxDma: crate::usart::TxDma<T>,
 {
-    type WriteFuture<'a> where Self: 'a = impl Future<Output = Result<(), embassy_traits::uart::Error>> + 'a;
+    // rustfmt::skip because rustfmt removes the 'where' claus on the associated type.
+    #[rustfmt::skip]
+    type WriteFuture<'a> where Self: 'a = impl Future<Output = Result<(), embassy_traits::uart::Error>> +'a;
 
     fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> {
-        self.write_dma(buf).map_err(|_| embassy_traits::uart::Error::Other)
+        self.write_dma(buf)
+            .map_err(|_| embassy_traits::uart::Error::Other)
     }
 }
 
-// rustfmt::skip because intellij removes the 'where' claus on the associated type.
-#[rustfmt::skip]
 impl<'d, T: Instance, TxDma, RxDma> embassy_traits::uart::Read for Uart<'d, T, TxDma, RxDma>
-    where RxDma: crate::usart::RxDma<T>
+where
+    RxDma: crate::usart::RxDma<T>,
 {
+    // rustfmt::skip because rustfmt removes the 'where' claus on the associated type.
+    #[rustfmt::skip]
     type ReadFuture<'a> where Self: 'a = impl Future<Output = Result<(), embassy_traits::uart::Error>> + 'a;
 
     fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> {
-        self.read_dma(buf).map_err(|_| embassy_traits::uart::Error::Other)
+        self.read_dma(buf)
+            .map_err(|_| embassy_traits::uart::Error::Other)
+    }
+}
+
+pub struct State<'d, T: Instance>(StateStorage<StateInner<'d, T>>);
+impl<'d, T: Instance> State<'d, T> {
+    pub fn new() -> Self {
+        Self(StateStorage::new())
+    }
+}
+
+pub struct StateInner<'d, T: Instance> {
+    uart: Uart<'d, T, NoDma, NoDma>,
+    phantom: PhantomData<&'d mut T>,
+
+    rx_waker: WakerRegistration,
+    rx: RingBuffer<'d>,
+
+    tx_waker: WakerRegistration,
+    tx: RingBuffer<'d>,
+}
+
+unsafe impl<'d, T: Instance> Send for StateInner<'d, T> {}
+unsafe impl<'d, T: Instance> Sync for StateInner<'d, T> {}
+
+pub struct BufferedUart<'d, T: Instance> {
+    inner: PeripheralMutex<'d, StateInner<'d, T>>,
+}
+
+impl<'d, T: Instance> Unpin for BufferedUart<'d, T> {}
+
+impl<'d, T: Instance> BufferedUart<'d, T> {
+    pub unsafe fn new(
+        state: &'d mut State<'d, T>,
+        uart: Uart<'d, T, NoDma, NoDma>,
+        irq: impl Unborrow<Target = T::Interrupt> + 'd,
+        tx_buffer: &'d mut [u8],
+        rx_buffer: &'d mut [u8],
+    ) -> BufferedUart<'d, T> {
+        unborrow!(irq);
+
+        let r = uart.inner.regs();
+        r.cr1().modify(|w| {
+            w.set_rxneie(true);
+            w.set_idleie(true);
+        });
+
+        Self {
+            inner: PeripheralMutex::new_unchecked(irq, &mut state.0, move || StateInner {
+                uart,
+                phantom: PhantomData,
+                tx: RingBuffer::new(tx_buffer),
+                tx_waker: WakerRegistration::new(),
+
+                rx: RingBuffer::new(rx_buffer),
+                rx_waker: WakerRegistration::new(),
+            }),
+        }
+    }
+}
+
+impl<'d, T: Instance> StateInner<'d, T>
+where
+    Self: 'd,
+{
+    fn on_rx(&mut self) {
+        let r = self.uart.inner.regs();
+        unsafe {
+            let sr = r.isr().read();
+            if sr.pe() {
+                r.icr().write(|w| {
+                    w.set_pe(true);
+                });
+                trace!("Parity error");
+            } else if sr.fe() {
+                r.icr().write(|w| {
+                    w.set_fe(true);
+                });
+                trace!("Framing error");
+            } else if sr.nf() {
+                r.icr().write(|w| {
+                    w.set_nf(true);
+                });
+                trace!("Noise error");
+            } else if sr.ore() {
+                r.icr().write(|w| {
+                    w.set_ore(true);
+                });
+                trace!("Overrun error");
+            } else if sr.rxne() {
+                let buf = self.rx.push_buf();
+                if buf.is_empty() {
+                    self.rx_waker.wake();
+                } else {
+                    buf[0] = r.rdr().read().0 as u8;
+                    self.rx.push(1);
+                }
+            } else if sr.idle() {
+                r.icr().write(|w| {
+                    w.set_idle(true);
+                });
+                self.rx_waker.wake();
+            };
+        }
+    }
+
+    fn on_tx(&mut self) {
+        let r = self.uart.inner.regs();
+        unsafe {
+            if r.isr().read().txe() {
+                let buf = self.tx.pop_buf();
+                if !buf.is_empty() {
+                    r.cr1().modify(|w| {
+                        w.set_txeie(true);
+                    });
+                    r.tdr().write_value(regs::Dr(buf[0].into()));
+                    self.tx.pop(1);
+                    self.tx_waker.wake();
+                } else {
+                    // Disable interrupt until we have something to transmit again
+                    r.cr1().modify(|w| {
+                        w.set_txeie(false);
+                    });
+                }
+            }
+        }
+    }
+}
+
+impl<'d, T: Instance> PeripheralState for StateInner<'d, T>
+where
+    Self: 'd,
+{
+    type Interrupt = T::Interrupt;
+    fn on_interrupt(&mut self) {
+        self.on_rx();
+        self.on_tx();
+    }
+}
+
+impl<'d, T: Instance> embassy::io::AsyncBufRead for BufferedUart<'d, T> {
+    fn poll_fill_buf(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<&[u8], embassy::io::Error>> {
+        self.inner.with(|state| {
+            compiler_fence(Ordering::SeqCst);
+
+            // We have data ready in buffer? Return it.
+            let buf = state.rx.pop_buf();
+            if !buf.is_empty() {
+                let buf: &[u8] = buf;
+                // Safety: buffer lives as long as uart
+                let buf: &[u8] = unsafe { core::mem::transmute(buf) };
+                return Poll::Ready(Ok(buf));
+            }
+
+            state.rx_waker.register(cx.waker());
+            Poll::<Result<&[u8], embassy::io::Error>>::Pending
+        })
+    }
+    fn consume(mut self: Pin<&mut Self>, amt: usize) {
+        let signal = self.inner.with(|state| {
+            let full = state.rx.is_full();
+            state.rx.pop(amt);
+            full
+        });
+        if signal {
+            self.inner.pend();
+        }
+    }
+}
+
+impl<'d, T: Instance> embassy::io::AsyncWrite for BufferedUart<'d, T> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, embassy::io::Error>> {
+        let (poll, empty) = self.inner.with(|state| {
+            let empty = state.tx.is_empty();
+            let tx_buf = state.tx.push_buf();
+            if tx_buf.is_empty() {
+                state.tx_waker.register(cx.waker());
+                return (Poll::Pending, empty);
+            }
+
+            let n = core::cmp::min(tx_buf.len(), buf.len());
+            tx_buf[..n].copy_from_slice(&buf[..n]);
+            state.tx.push(n);
+
+            (Poll::Ready(Ok(n)), empty)
+        });
+        if empty {
+            self.inner.pend();
+        }
+        poll
     }
 }