fix: simplify

2 files changed, 5 insertions, 73 deletions

diff --git a/embassy-stm32/src/dma/gpdma/ringbuffered.rs b/embassy-stm32/src/dma/gpdma/ringbuffered.rs
index 88ec666dc..f9d77ab73 100644
--- a/embassy-stm32/src/dma/gpdma/ringbuffered.rs
+++ b/embassy-stm32/src/dma/gpdma/ringbuffered.rs
@@ -1,6 +1,7 @@
 //! GPDMA ring buffer implementation.
 //!
-//! FIXME: add request_pause functionality?
+//! FIXME: Add request_pause functionality?
+//! FIXME: Stop the DMA, if a user does not queue new transfers (chain of linked-list items ends automatically).
 use core::future::poll_fn;
 use core::sync::atomic::{fence, Ordering};
 use core::task::Waker;
@@ -257,23 +258,9 @@ impl<'a, W: Word> WritableRingBuffer<'a, W> {
 
     /// Write an exact number of elements to the ringbuffer.
     pub async fn write_exact(&mut self, buffer: &[W]) -> Result<usize, Error> {
-        // return self
-        //     .ringbuf
-        //     .write_exact(&mut DmaCtrlImpl(self.channel.reborrow()), buffer)
-        //     .await;
-
-        let mut remaining_cap = 0;
-        let mut written_len = 0;
-
-        while written_len < buffer.len() {
-            (written_len, remaining_cap) = self
-                .ringbuf
-                .write_half(&mut DmaCtrlImpl(self.channel.reborrow()), buffer)
-                .await?;
-            // info!("Written: {}/{}", written_len, buffer.len());
-        }
-
-        Ok(remaining_cap)
+        self.ringbuf
+            .write_exact(&mut DmaCtrlImpl(self.channel.reborrow()), buffer)
+            .await
     }
 
     /// Wait for any ring buffer write error.
diff --git a/embassy-stm32/src/dma/ringbuffer/mod.rs b/embassy-stm32/src/dma/ringbuffer/mod.rs
index 8d00d822d..2d61204a2 100644
--- a/embassy-stm32/src/dma/ringbuffer/mod.rs
+++ b/embassy-stm32/src/dma/ringbuffer/mod.rs
@@ -216,15 +216,6 @@ impl<'a, W: Word> WritableDmaRingBuffer<'a, W> {
         }
     }
 
-    /// The buffer half that is in use by the DMA.
-    fn dma_half(&self) -> BufferHalf {
-        if self.read_index.as_index(self.cap(), 0) < self.cap() / 2 {
-            BufferHalf::First
-        } else {
-            BufferHalf::Second
-        }
-    }
-
     /// Reset the ring buffer to its initial state. The buffer after the reset will be full.
     pub fn reset(&mut self, dma: &mut impl DmaCtrl) {
         dma.reset_complete_count();
@@ -325,52 +316,6 @@ impl<'a, W: Word> WritableDmaRingBuffer<'a, W> {
         .await
     }
 
-    /// Write the user's current buffer half - not used by the DMA.
-    ///
-    /// Returns a tuple of the written length, and the remaining write capacity in the buffer.
-    #[allow(dead_code)]
-    pub async fn write_half(&mut self, dma: &mut impl DmaCtrl, buffer: &[W]) -> Result<(usize, usize), Error> {
-        let mut written_len = 0;
-        let buffer_len = buffer.len();
-
-        poll_fn(|cx| {
-            dma.set_waker(cx.waker());
-
-            let dma_half = self.dma_half();
-            // let user_half = self.user_half();
-
-            // if dma_half == user_half {
-            //     info!("ups");
-            //     return Poll::Ready(Err(Error::Overrun));
-            // }
-
-            let write_index = self.write_index.as_index(self.cap(), 0);
-            let target_write_len = match dma_half {
-                BufferHalf::First => self.cap().saturating_sub(write_index),
-                BufferHalf::Second => (self.cap() / 2).saturating_sub(write_index),
-            };
-            let write_end_index = (target_write_len + written_len).min(buffer_len);
-
-            // info!(
-            //     "buf_len: {}, write_len: {}, write_index: {}",
-            //     buffer_len, target_write_len, write_index
-            // );
-
-            match self.write(dma, &buffer[written_len..write_end_index]) {
-                Ok((len, remaining)) => {
-                    written_len += len;
-                    if written_len == write_end_index {
-                        Poll::Ready(Ok((written_len, remaining)))
-                    } else {
-                        Poll::Pending
-                    }
-                }
-                Err(e) => Poll::Ready(Err(e)),
-            }
-        })
-        .await
-    }
-
     fn write_raw(&mut self, dma: &mut impl DmaCtrl, buf: &[W]) -> Result<(usize, usize), Error> {
         let writable = self.len(dma)?.min(buf.len());
         for i in 0..writable {