fix: read transfer not starting properly

Author: AstrickHarren

esp-hal/src/dma/buffers.rs

@@ -1535,7 +1535,7 @@ impl DmaTxStreamBufView {
         }
 
         fn truncate_by(n: usize, by: usize) -> usize {
-            (n >= by).then_some(n - by).unwrap_or(n)
+            (n >= by).then(|| n - by).unwrap_or(n)
         }
 
         let n_chunks = self.buf.descriptors.len();

esp-hal/src/dma/mod.rs

@@ -2530,60 +2530,6 @@ pub(crate) mod dma_private {
     }
 }
 
-/// DMA transaction for TX only transfers
-///
-/// # Safety
-///
-/// Never use [core::mem::forget] on an in-progress transfer
-#[non_exhaustive]
-#[must_use]
-pub struct DmaTransferTx<'a, I>
-where
-    I: dma_private::DmaSupportTx,
-{
-    instance: &'a mut I,
-}
-
-impl<'a, I> DmaTransferTx<'a, I>
-where
-    I: dma_private::DmaSupportTx,
-{
-    #[cfg_attr(esp32c2, allow(dead_code))]
-    pub(crate) fn new(instance: &'a mut I) -> Self {
-        Self { instance }
-    }
-
-    /// Wait for the transfer to finish.
-    pub fn wait(self) -> Result<(), DmaError> {
-        self.instance.peripheral_wait_dma(false, true);
-
-        if self
-            .instance
-            .tx()
-            .pending_out_interrupts()
-            .contains(DmaTxInterrupt::DescriptorError)
-        {
-            Err(DmaError::DescriptorError)
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Check if the transfer is finished.
-    pub fn is_done(&mut self) -> bool {
-        self.instance.tx().is_done()
-    }
-}
-
-impl<I> Drop for DmaTransferTx<'_, I>
-where
-    I: dma_private::DmaSupportTx,
-{
-    fn drop(&mut self) {
-        self.instance.peripheral_wait_dma(true, false);
-    }
-}
-
 /// DMA transaction for RX only transfers
 ///
 /// # Safety
@@ -2598,37 +2544,6 @@ where
     instance: &'a mut I,
 }
 
-impl<'a, I> DmaTransferRx<'a, I>
-where
-    I: dma_private::DmaSupportRx,
-{
-    #[cfg_attr(esp32c2, allow(dead_code))]
-    pub(crate) fn new(instance: &'a mut I) -> Self {
-        Self { instance }
-    }
-
-    /// Wait for the transfer to finish.
-    pub fn wait(self) -> Result<(), DmaError> {
-        self.instance.peripheral_wait_dma(true, false);
-
-        if self
-            .instance
-            .rx()
-            .pending_in_interrupts()
-            .contains(DmaRxInterrupt::DescriptorError)
-        {
-            Err(DmaError::DescriptorError)
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Check if the transfer is finished.
-    pub fn is_done(&mut self) -> bool {
-        self.instance.rx().is_done()
-    }
-}
-
 impl<I> Drop for DmaTransferRx<'_, I>
 where
     I: dma_private::DmaSupportRx,
@@ -2832,63 +2747,6 @@ pub(crate) mod asynch {
 
     use super::*;
 
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct DmaTxFuture<'a, CH>
-    where
-        CH: DmaTxChannel,
-    {
-        pub(crate) tx: &'a mut ChannelTx<Async, CH>,
-    }
-
-    impl<'a, CH> DmaTxFuture<'a, CH>
-    where
-        CH: DmaTxChannel,
-    {
-        #[cfg_attr(esp32c2, allow(dead_code))]
-        pub fn new(tx: &'a mut ChannelTx<Async, CH>) -> Self {
-            Self { tx }
-        }
-    }
-
-    impl<CH> core::future::Future for DmaTxFuture<'_, CH>
-    where
-        CH: DmaTxChannel,
-    {
-        type Output = Result<(), DmaError>;
-
-        fn poll(
-            self: core::pin::Pin<&mut Self>,
-            cx: &mut core::task::Context<'_>,
-        ) -> Poll<Self::Output> {
-            if self.tx.is_done() {
-                self.tx.clear_interrupts();
-                Poll::Ready(Ok(()))
-            } else if self
-                .tx
-                .pending_out_interrupts()
-                .contains(DmaTxInterrupt::DescriptorError)
-            {
-                self.tx.clear_interrupts();
-                Poll::Ready(Err(DmaError::DescriptorError))
-            } else {
-                self.tx.waker().register(cx.waker());
-                self.tx
-                    .listen_out(DmaTxInterrupt::TotalEof | DmaTxInterrupt::DescriptorError);
-                Poll::Pending
-            }
-        }
-    }
-
-    impl<CH> Drop for DmaTxFuture<'_, CH>
-    where
-        CH: DmaTxChannel,
-    {
-        fn drop(&mut self) {
-            self.tx
-                .unlisten_out(DmaTxInterrupt::TotalEof | DmaTxInterrupt::DescriptorError);
-        }
-    }
-
     #[must_use = "futures do nothing unless you `.await` or poll them"]
     pub struct DmaRxFuture<'a, CH>
     where

esp-hal/src/i2s/master.rs

@@ -428,6 +428,7 @@ where
         self.i2s.reset_tx();
 
         // Enable corresponding interrupts if needed
+        self.i2s.listen(I2sInterrupt::TxDone);
 
         // configure DMA outlink
         unsafe {
@@ -476,6 +477,7 @@ where
     pub fn read<'t, RXBUF>(
         mut self,
         mut buf: RXBUF,
+        chunk_size: usize,
     ) -> Result<I2sReadDmaTransfer<'d, Dm, RXBUF>, Error>
     where
         RXBUF: DmaRxBuffer,
@@ -488,6 +490,7 @@ where
         self.i2s.reset_rx();
 
         // Enable corresponding interrupts if needed
+        self.i2s.listen(I2sInterrupt::RxDone);
 
         // configure DMA inlink
         unsafe {
@@ -498,10 +501,11 @@ where
         self.rx_channel.start_transfer()?;
 
         // start: set I2S_RX_START
-        self.i2s.rx_start();
+        self.i2s.rx_start(chunk_size);
         Ok(I2sReadDmaTransfer {
             i2s_rx: ManuallyDrop::new(self),
             buffer_view: ManuallyDrop::new(buf.into_view()),
+            chunk_size,
         })
     }
 }
@@ -548,7 +552,7 @@ impl<'d, Dm: DriverMode, BUFFER: DmaTxBuffer> I2sWriteDmaTransfer<'d, Dm, BUFFER
 
     /// Checks if the DMA transfer is done.
     pub fn is_done(&self) -> bool {
-        self.i2s_tx.tx_channel.is_done()
+        self.i2s_tx.i2s.interrupts().contains(I2sInterrupt::TxDone)
     }
 
     /// Stops and restarts the DMA transfer.
@@ -583,6 +587,7 @@ impl<'d, Dm: DriverMode, BUFFER: DmaTxBuffer> I2sWriteDmaTransfer<'d, Dm, BUFFER
 /// An in-progress async circular DMA read transfer.
 pub struct I2sReadDmaTransfer<'d, Dm: DriverMode, BUFFER: DmaRxBuffer> {
     i2s_rx: ManuallyDrop<I2sRx<'d, Dm>>,
+    chunk_size: usize,
     buffer_view: ManuallyDrop<BUFFER::View>,
 }
 
@@ -622,13 +627,14 @@ impl<'d, Dm: DriverMode, BUFFER: DmaRxBuffer> I2sReadDmaTransfer<'d, Dm, BUFFER>
 
     /// Returns true if the transfer is done.
     pub fn is_done(&self) -> bool {
-        self.i2s_rx.rx_channel.is_done()
+        self.i2s_rx.i2s.interrupts().contains(I2sInterrupt::RxDone)
     }
 
     /// Stops and restarts the DMA transfer.
     pub fn restart(self) -> Result<Self, Error> {
+        let chunk_size = self.chunk_size;
         let (i2s, buf) = self.stop();
-        i2s.read(buf)
+        i2s.read(buf, chunk_size)
     }
 
     /// Checks if the transfer has an error.
@@ -1466,7 +1472,11 @@ mod private {
             });
         }
 
-        fn rx_start(&self) {
+        fn rx_start(&self, len: usize) {
+            let len = len - 1;
+            self.regs()
+                .rxeof_num()
+                .write(|w| unsafe { w.rx_eof_num().bits(len as u16) });
             self.regs().rx_conf().modify(|_, w| w.rx_start().set_bit());
         }
 
@@ -1816,8 +1826,6 @@ pub mod asynch {
     impl<BUFFER: DmaRxBuffer> I2sReadDmaTransfer<'_, Async, BUFFER> {
         /// Waits for DMA process to be made and additional room to be
         /// available.
-        ///
-        /// Returns [crate::dma::DmaError::Late] if DMA is already completed.
         pub async fn wait_for_available(&mut self) -> Result<(), Error> {
             DmaRxDoneChFuture::new(&mut self.i2s_rx.rx_channel).await?;
             Ok(())