feat: restart tx

Author: AstrickHarren

esp-hal/src/dma/buffers.rs

@@ -1540,7 +1540,7 @@ impl DmaTxStreamBufView {
         let dma_start = self.descriptor_idx * chunk_size + self.descriptor_offset;
         let dma_end = truncate_by(dma_start + buf.len(), dma_size);
 
-        if dma_start < dma_end {
+        if dma_start <= dma_end {
             self.buf.buffer[dma_start..dma_end].copy_from_slice(buf);
         } else {
             self.buf.buffer[dma_start..].copy_from_slice(&buf[..dma_size - dma_start]);
@@ -1576,11 +1576,6 @@ impl DmaTxStreamBufView {
             }
         }
 
-        info!(
-            "self.descriptor_idx: {}, self.descriptor_offset: {}, dma_start: {}, dma_end: {}",
-            self.descriptor_idx, self.descriptor_offset, dma_start, dma_end
-        );
-
         bytes_to_fill
     }
 }

esp-hal/src/dma/mod.rs

@@ -2987,6 +2987,13 @@ pub(crate) mod asynch {
             {
                 self.tx.clear_out(DmaTxInterrupt::Done);
                 Poll::Ready(Ok(()))
+            } else if self
+                .tx
+                .pending_out_interrupts()
+                .contains(DmaTxInterrupt::TotalEof)
+            {
+                self.tx.clear_interrupts();
+                return Poll::Ready(Err(DmaError::Late));
             } else if self
                 .tx
                 .pending_out_interrupts()
@@ -2996,8 +3003,11 @@ pub(crate) mod asynch {
                 Poll::Ready(Err(DmaError::DescriptorError))
             } else {
                 self.tx.waker().register(cx.waker());
-                self.tx
-                    .listen_out(DmaTxInterrupt::Done | DmaTxInterrupt::DescriptorError);
+                self.tx.listen_out(
+                    DmaTxInterrupt::Done
+                        | DmaTxInterrupt::DescriptorError
+                        | DmaTxInterrupt::TotalEof,
+                );
                 Poll::Pending
             }
         }

esp-hal/src/i2s/master.rs

@@ -1806,11 +1806,10 @@ pub mod asynch {
         Async,
         dma::{
             DmaEligible,
-            ReadBuffer,
+            DmaTxBuffer,
             RxCircularState,
-            TxCircularState,
             WriteBuffer,
-            asynch::{DmaRxDoneChFuture, DmaRxFuture, DmaTxDoneChFuture, DmaTxFuture},
+            asynch::{DmaRxDoneChFuture, DmaRxFuture, DmaTxDoneChFuture},
         },
     };
 
@@ -1901,17 +1900,43 @@ pub mod asynch {
             Ok(self.state.push(&data[..to_send])?)
         }
 
-        /// Push bytes into the DMA buffer via the given closure.
-        /// The closure *must* return the actual number of bytes written.
-        /// The closure *might* get called with a slice which is smaller than
-        /// the total available buffer. Only useful for circular DMA
-        /// transfers
-        pub async fn push_with(
-            &mut self,
-            f: impl FnOnce(&mut [u8]) -> usize,
-        ) -> Result<usize, Error> {
-            let _avail = self.available().await;
-            Ok(self.state.push_with(f)?)
+        /// Checks if the DMA transfer is done.
+        pub fn is_done(&self) -> bool {
+            self.i2s_tx.tx_channel.is_done()
+        }
+
+        /// Stops and restarts the DMA transfer.
+        pub fn restart(self) -> Result<Self, Error> {
+            let (i2s, buf) = self.stop();
+            i2s.write(buf)
+        }
+
+        /// Checks if the DMA transfer has an error.
+        pub fn has_error(&self) -> bool {
+            self.i2s_tx.tx_channel.has_error()
+        }
+
+        /// Waits for any DMA process to be made.
+        pub async fn process(&mut self) -> Result<(), Error> {
+            DmaTxDoneChFuture::new(&mut self.i2s_tx.tx_channel).await?;
+            Ok(())
+        }
+
+        fn release(mut self) -> (I2sTx<'d, Async>, BUFFER::View) {
+            // SAFETY: Since forget is called on self, we know that self.i2s_tx and
+            // self.buffer_view won't be touched again.
+            let result = unsafe {
+                (
+                    ManuallyDrop::take(&mut self.i2s_tx),
+                    ManuallyDrop::take(&mut self.buffer_view),
+                )
+            };
+            core::mem::forget(self);
+            result
+        }
+
+        fn stop_peripheral(&mut self) {
+            self.i2s_tx.i2s.tx_stop();
         }
     }