spi: Use new periph API, fix unsoundness in example

Author: astapleton

examples/spi-async-rtic.rs

@@ -3,9 +3,10 @@
 
 mod utilities;
 
+use embedded_dma::{ReadBuffer, WriteBuffer};
 use rtic::app;
 use stm32h5xx_hal::{
-    gpdma::{periph::DmaDuplex, DmaChannel0, DmaChannel1},
+    gpdma::{periph::DmaDuplex, DmaChannel0, DmaChannel1, Word},
     gpio::{Output, PA5},
     pac,
     prelude::*,
@@ -15,11 +16,51 @@ use stm32h5xx_hal::{
 use rtic_monotonics::systick::prelude::*;
 systick_monotonic!(Mono, 1000);
 
+// Buffer is used to manage a reference to a static buffer returned by the cortex_m::singleton!
+// macro and which can be with the DmaTransfer API (which requires passing ReadBuffer and
+// WriteBuffer implementations by value) and then used to access the buffer after the transfer has
+// completed.
+struct Buffer<T: Word + 'static, const N: usize> {
+    data: &'static mut [T; N],
+}
+
+impl<T, const N: usize> Buffer<T, N>
+where
+    T: Word + 'static,
+{
+    fn new(data: &'static mut [T; N]) -> Self {
+        Self { data }
+    }
+}
+
+unsafe impl<T, const N: usize> ReadBuffer for &mut Buffer<T, N>
+where
+    T: Word + 'static,
+{
+    type Word = T;
+
+    unsafe fn read_buffer(&self) -> (*const Self::Word, usize) {
+        (self.data.as_ptr(), N)
+    }
+}
+
+unsafe impl<T, const N: usize> WriteBuffer for &mut Buffer<T, N>
+where
+    T: Word + 'static,
+{
+    type Word = T;
+
+    unsafe fn write_buffer(&mut self) -> (*mut Self::Word, usize) {
+        (self.data.as_mut_ptr(), N)
+    }
+}
+
 #[app(device = pac, dispatchers = [USART1, USART2], peripherals = true)]
 mod app {
 
+    use core::cell::Cell;
+
     use cortex_m::singleton;
-    use embedded_dma::{ReadBuffer, WriteBuffer};
     use stm32h5::stm32h503::{GPDMA1, NVIC};
 
     use super::*;
@@ -34,8 +75,8 @@ mod app {
             pac::SPI2,
             DmaDuplex<pac::SPI2, u8, DmaChannel0<GPDMA1>, DmaChannel1<GPDMA1>>,
         >,
-        source: &'static mut [u8; 40],
-        dest: &'static mut [u8; 40],
+        source: Cell<Buffer<u8, 40>>,
+        dest: Cell<Buffer<u8, 40>>,
     }
 
     #[init]
@@ -86,15 +127,18 @@ mod app {
             NVIC::unmask(pac::interrupt::GPDMA1_CH1);
         };
 
+        let src = singleton!(: [u8; 40] = [0; 40]).unwrap();
+        let dest = singleton!(: [u8; 40] = [0; 40]).unwrap();
+
         tick::spawn().unwrap();
         spi_transfer::spawn().unwrap();
         (
             Shared {},
             Local {
                 led,
                 spi,
-                source: singleton!(: [u8; 40] = [0; 40]).unwrap(),
-                dest: singleton!(: [u8; 40] = [0; 40]).unwrap(),
+                source: Cell::new(Buffer::new(src)),
+                dest: Cell::new(Buffer::new(dest)),
             },
         )
     }
@@ -113,19 +157,19 @@ mod app {
     async fn spi_transfer(ctx: spi_transfer::Context) {
         loop {
             log::info!("Starting SPI transfer");
-            ctx.local.source.fill(*ctx.local.count as u8);
-            ctx.local.dest.fill(0);
 
-            let (src_ptr, src_len) = unsafe { ctx.local.source.read_buffer() };
-            let src = unsafe { core::slice::from_raw_parts(src_ptr, src_len) };
-            let (dest_ptr, dest_len) = unsafe { ctx.local.dest.write_buffer() };
-            let dest =
-                unsafe { core::slice::from_raw_parts_mut(dest_ptr, dest_len) };
+            let src = ctx.local.source.get_mut();
+            let dest = ctx.local.dest.get_mut();
+            src.data.fill(*ctx.local.count as u8);
+            dest.data.fill(0);
 
             *ctx.local.count += 1;
             ctx.local.spi.transfer_dma(src, dest).await.unwrap();
 
-            assert_eq!(*ctx.local.source, *ctx.local.dest);
+            assert_eq!(
+                *ctx.local.source.get_mut().data,
+                *ctx.local.dest.get_mut().data
+            );
             log::info!("Success!");
             Mono::delay(1000.millis()).await;
         }

src/spi/dma.rs

@@ -13,7 +13,7 @@ use futures_util::task::AtomicWaker;
 use crate::{
     gpdma::{
         config::DmaConfig,
-        periph::{DmaDuplex, DmaRx, DmaTx, RxAddr, TxAddr},
+        periph::{DmaDuplex, DmaRx, DmaTx, PeriphRxBuffer, PeriphTxBuffer, RxAddr, TxAddr},
         DmaChannel, DmaTransfer, Error as DmaError, Word as DmaWord,
     },
     interrupt,
@@ -231,7 +231,7 @@ where
     pub fn start_dma_read<'a, D>(
         &'a mut self,
         mut destination: D,
-    ) -> Result<DmaTransfer<'a, CH>, Error>
+    ) -> Result<DmaTransfer<'a, CH, PeriphRxBuffer<SPI, W>, D>, Error>
     where
         D: WriteBuffer<Word = W>,
     {
@@ -273,7 +273,7 @@ where
     pub fn start_dma_write<'a, S>(
         &'a mut self,
         source: S,
-    ) -> Result<DmaTransfer<'a, CH>, Error>
+    ) -> Result<DmaTransfer<'a, CH, S, PeriphTxBuffer<SPI, W>>, Error>
     where
         S: ReadBuffer<Word = W>,
     {
@@ -313,11 +313,13 @@ where
     TX: DmaChannel,
     RX: DmaChannel,
 {
+    #[allow(clippy::type_complexity)]
     pub fn start_dma_duplex_transfer<'a, S, D>(
         &'a mut self,
         source: S,
         mut destination: D,
-    ) -> Result<(DmaTransfer<'a, TX>, DmaTransfer<'a, RX>), Error>
+    ) -> Result<(DmaTransfer<'a, TX, S, PeriphTxBuffer<SPI, W>>,
+        DmaTransfer<'a, RX, PeriphRxBuffer<SPI, W>, D>), Error>
     where
         S: ReadBuffer<Word = W>,
         D: WriteBuffer<Word = W>,
@@ -363,6 +365,7 @@ where
         let (tx, rx) = self.start_dma_duplex_transfer(source, destination)?;
         let (tx, rx) = (tx.into_future(), rx.into_future());
         let results = join!(tx, rx);
+
         let result = results.0.and(results.1);
 
         self.finish_transfer_async(result).await