test: use macros for creating DMA tx stream buffers

Author: AstrickHarren

esp-hal/src/dma/buffers.rs

@@ -1431,7 +1431,7 @@ impl DmaRxStreamBufView {
 
 /// DMA Streaming Transmit Buffer.
 ///
-/// This is symmetric implementation to [DmaTxStreamBuf], used for continuously
+/// This is symmetric implementation to [DmaRxStreamBuf], used for continuously
 /// streaming data to a peripheral's FIFO.
 ///
 /// The list starts out like so `A(full) -> B(full) -> C(full) -> D(full) -> NULL`.
@@ -1448,7 +1448,7 @@ impl DmaRxStreamBufView {
 /// - `C(empty) -> D(full)  -> A(full)  -> B(full) -> NULL`
 /// - `D(full)  -> A(full)  -> B(full)  -> C(full) -> NULL`
 ///
-/// If all the descriptors fill up, the [DmaTxInterrupt::TotalEof] interrupt will fire and DMA
+/// If all the descriptors run out, the [DmaTxInterrupt::TotalEof] interrupt will fire and DMA
 /// will stop writing, at which point it is up to you to resume/restart the transfer.
 pub struct DmaTxStreamBuf {
     descriptors: &'static mut [DmaDescriptor],
@@ -1506,15 +1506,26 @@ impl DmaTxStreamBuf {
         (self.descriptors, self.buffer)
     }
 
-    /// Fill the buffer with the given data before DMA transfer starts.
+    /// Push the buffer with the given data before DMA transfer starts.
     ///
     /// Otherwise the streaming buffer will transfer garbage data to
     /// DMA so that CPU has enough time to fill the buffer after transfer starts.
-    pub fn fill(&mut self, data: &[u8]) -> usize {
-        let n = self.buffer.len().min(data.len());
-        self.buffer[..n].copy_from_slice(&data[..n]);
-        self.pre_filled = Some(n);
-        n
+    pub fn push(&mut self, data: &[u8]) -> usize {
+        self.push_with(|buf| {
+            let len = buf.len().min(data.len());
+            buf[..len].copy_from_slice(&data[..len]);
+            len
+        })
+    }
+
+    /// Push the buffer with the given data before DMA transfer starts.
+    ///
+    /// Returns the number of bytes filled.
+    pub fn push_with(&mut self, f: impl FnOnce(&mut [u8]) -> usize) -> usize {
+        let start = self.pre_filled.unwrap_or(0);
+        let bytes_pushed = f(&mut self.buffer[start..]);
+        self.pre_filled = Some(start + bytes_pushed);
+        bytes_pushed
     }
 }
 
@@ -1555,7 +1566,7 @@ unsafe impl DmaTxBuffer for DmaTxStreamBuf {
             descriptor_idx: 0,
             descriptor_offset: 0,
         };
-        view.update_state(pre_filled);
+        view.advance(pre_filled);
         view
     }
 
@@ -1591,12 +1602,12 @@ impl DmaTxStreamBufView {
         let dma_end = (dma_start + self.available_bytes()).min(self.buf.buffer.len());
         let bytes_pushed = f(&mut self.buf.buffer[dma_start..dma_end]);
 
-        self.update_state(bytes_pushed);
+        self.advance(bytes_pushed);
         bytes_pushed
     }
 
-    /// Updates the view state on pushed with `bytes_pushed` many bytes.
-    fn update_state(&mut self, bytes_pushed: usize) {
+    /// Advances the first `n` bytes from the available data
+    fn advance(&mut self, bytes_pushed: usize) {
         let mut bytes_filled = 0;
         for d in (self.descriptor_idx..self.buf.descriptors.len()).chain(core::iter::once(0)) {
             let desc = &mut self.buf.descriptors[d];

esp-hal/src/dma/mod.rs

@@ -77,30 +77,6 @@ use crate::{
     system::Cpu,
 };
 
-trait Word: crate::private::Sealed {}
-
-macro_rules! impl_word {
-    ($w:ty) => {
-        impl $crate::private::Sealed for $w {}
-        impl Word for $w {}
-    };
-}
-
-impl_word!(u8);
-impl_word!(u16);
-impl_word!(u32);
-impl_word!(i8);
-impl_word!(i16);
-impl_word!(i32);
-
-impl<W, const S: usize> crate::private::Sealed for [W; S] where W: Word {}
-
-impl<W, const S: usize> crate::private::Sealed for &[W; S] where W: Word {}
-
-impl<W> crate::private::Sealed for &[W] where W: Word {}
-
-impl<W> crate::private::Sealed for &mut [W] where W: Word {}
-
 bitfield::bitfield! {
     /// DMA descriptor flags.
     #[derive(Clone, Copy, PartialEq, Eq)]

esp-hal/src/i2s/master.rs

@@ -76,10 +76,9 @@
 //! ```rust, no_run
 //! # {before_snippet}
 //! # use esp_hal::i2s::master::{I2s, Channels, DataFormat, Config};
-//! # use esp_hal::dma_buffers_chunk_size;
-//! # use esp_hal::dma::DmaRxStreamBuf;
+//! # use esp_hal::dma_rx_stream_buffer;
 //! # {dma_channel}
-//! let (mut rx_buffer, rx_descriptors, _, _) = dma_buffers_chunk_size!(4 * 4092, 0, 4092);
+//! let rx_buffer = dma_rx_stream_buffer!(4 * 4092);
 //!
 //! let i2s = I2s::new(
 //!     peripherals.I2S0,
@@ -97,10 +96,7 @@
 //!     .with_din(peripherals.GPIO5)
 //!     .build();
 //!
-//! let mut transfer = i2s_rx.read(
-//!     DmaRxStreamBuf::new(rx_descriptors, rx_buffer).unwrap(),
-//!     4092,
-//! )?;
+//! let mut transfer = i2s_rx.read(rx_buffer, 4092)?;
 //!
 //! loop {
 //!     let avail = transfer.available_bytes();
@@ -172,15 +168,6 @@ pub(crate) const I2S_LL_MCLK_DIVIDER_BIT_WIDTH: usize = 9;
 
 pub(crate) const I2S_LL_MCLK_DIVIDER_MAX: usize = (1 << I2S_LL_MCLK_DIVIDER_BIT_WIDTH) - 1;
 
-/// Data types that the I2S peripheral can work with.
-pub trait AcceptedWord: crate::private::Sealed {}
-impl AcceptedWord for u8 {}
-impl AcceptedWord for u16 {}
-impl AcceptedWord for u32 {}
-impl AcceptedWord for i8 {}
-impl AcceptedWord for i16 {}
-impl AcceptedWord for i32 {}
-
 /// I2S Error
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

hil-test/src/bin/embassy_interrupt_spi_dma.rs

@@ -57,12 +57,10 @@ async fn interrupt_driven_task(spi: esp_hal::spi::master::SpiDma<'static, Blocki
 #[cfg(not(any(esp32, esp32s2, esp32s3)))]
 #[embassy_executor::task]
 async fn interrupt_driven_task(i2s_tx: esp_hal::i2s::master::I2s<'static, Blocking>) {
-    use esp_hal::{dma::DmaTxStreamBuf, dma_buffers_chunk_size};
-    let (_, _, tx_buffer, tx_descriptors) = dma_buffers_chunk_size!(128, 128, 128 / 3);
+    use esp_hal::dma_tx_stream_buffer;
+    let mut buf = dma_tx_stream_buffer!(128, 128 / 3);
 
     let mut i2s_tx = i2s_tx.into_async().i2s_tx.build();
-    let mut buf = DmaTxStreamBuf::new(tx_descriptors, tx_buffer).unwrap();
-
     loop {
         let mut buffer: [u8; 8] = [0; 8];
 

hil-test/src/bin/i2s.rs

@@ -13,7 +13,7 @@
 use esp_hal::{
     Async,
     delay::Delay,
-    dma::{DmaDescriptor, DmaTxStreamBuf},
+    dma::DmaTxStreamBuf,
     gpio::{AnyPin, NoPin, Pin},
     i2s::master::{Channels, Config, DataFormat, I2s, I2sTx},
     peripherals::I2S0,
@@ -57,19 +57,16 @@ impl Iterator for SampleSource {
 }
 
 #[embassy_executor::task]
-async fn writer(
-    tx_buffer: &'static mut [u8],
-    tx_descriptors: &'static mut [DmaDescriptor],
-    i2s_tx: I2sTx<'static, Async>,
-) {
+async fn writer(mut tx_buffer: DmaTxStreamBuf, i2s_tx: I2sTx<'static, Async>) {
     let mut samples = SampleSource::new();
-    for b in tx_buffer.iter_mut() {
-        *b = samples.next().unwrap();
-    }
+    tx_buffer.push_with(|buf| {
+        for b in buf.iter_mut() {
+            *b = samples.next().unwrap();
+        }
+        buf.len()
+    });
 
-    let mut tx_transfer = i2s_tx
-        .write(DmaTxStreamBuf::new(tx_descriptors, tx_buffer).unwrap())
-        .unwrap();
+    let mut tx_transfer = i2s_tx.write(tx_buffer).unwrap();
 
     loop {
         while tx_transfer.available_bytes() == 0 {
@@ -102,7 +99,12 @@ fn enable_loopback() {
 
 #[embedded_test::tests(default_timeout = 3, executor = hil_test::Executor::new())]
 mod tests {
-    use esp_hal::{dma::DmaRxStreamBuf, dma_buffers_chunk_size};
+    use esp_hal::{
+        dma::DmaRxStreamBuf,
+        dma_buffers_chunk_size,
+        dma_rx_stream_buffer,
+        dma_tx_stream_buffer,
+    };
 
     use super::*;
 
@@ -140,8 +142,8 @@ mod tests {
         let spawner = unsafe { embassy_executor::Spawner::for_current_executor().await };
 
         // We need more than 3 descriptors for continuous transfer to work
-        let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) =
-            esp_hal::dma_buffers_chunk_size!(BUFFER_SIZE, BUFFER_SIZE, BUFFER_SIZE / 3);
+        let rx_buffer = dma_rx_stream_buffer!(BUFFER_SIZE, BUFFER_SIZE / 3);
+        let tx_buffer = dma_tx_stream_buffer!(BUFFER_SIZE, BUFFER_SIZE / 3);
 
         let i2s = I2s::new(
             ctx.i2s,
@@ -172,13 +174,8 @@ mod tests {
 
         enable_loopback();
 
-        let mut rx_transfer = i2s_rx
-            .read(
-                DmaRxStreamBuf::new(rx_descriptors, rx_buffer).unwrap(),
-                BUFFER_SIZE,
-            )
-            .unwrap();
-        spawner.must_spawn(writer(tx_buffer, tx_descriptors, i2s_tx));
+        let mut rx_transfer = i2s_rx.read(rx_buffer, BUFFER_SIZE).unwrap();
+        spawner.must_spawn(writer(tx_buffer, i2s_tx));
 
         let mut sample_idx = 0;
         let mut samples = SampleSource::new();

qa-test/src/bin/embassy_i2s_sound.rs

@@ -87,7 +87,7 @@ async fn main(_spawner: Spawner) {
     let data =
         unsafe { core::slice::from_raw_parts(&SINE as *const _ as *const u8, SINE.len() * 2) };
 
-    let mut buffer = dma_loop_buffer!(64);
+    let mut buffer = dma_loop_buffer!(128);
     buffer.copy_from_slice(data);
 
     println!("Start");