feat: ping-pong buffers

3 files changed, 92 insertions, 16 deletions

diff --git a/embassy-stm32/src/dma/gpdma/linked_list.rs b/embassy-stm32/src/dma/gpdma/linked_list.rs
index 7de9a1441..3d2114282 100644
--- a/embassy-stm32/src/dma/gpdma/linked_list.rs
+++ b/embassy-stm32/src/dma/gpdma/linked_list.rs
@@ -156,6 +156,15 @@ impl LinearItem {
     fn unlink(&mut self) {
         self.llr = regs::ChLlr(0).0;
     }
+
+    /// The item's transfer count in number of words.
+    fn transfer_count(&self) -> usize {
+        let br1 = regs::ChBr1(self.br1);
+        let tr1 = regs::ChTr1(self.tr1);
+        let word_size: WordSize = tr1.ddw().into();
+
+        br1.bndt() as usize / word_size.bytes()
+    }
 }
 
 /// A table of linked list items.
@@ -173,6 +182,7 @@ impl<const ITEM_COUNT: usize> Table<ITEM_COUNT> {
         Self { items }
     }
 
+    /// Link the table as given by the run mode.
     pub fn link(&mut self, run_mode: RunMode) {
         if matches!(run_mode, RunMode::Once | RunMode::Repeat) {
             self.link_sequential();
@@ -183,11 +193,21 @@ impl<const ITEM_COUNT: usize> Table<ITEM_COUNT> {
         }
     }
 
-    /// The number of linked list items.s
+    /// The number of linked list items.
     pub fn len(&self) -> usize {
         self.items.len()
     }
 
+    /// The total transfer count of the table in number of words.
+    pub fn transfer_count(&self) -> usize {
+        let mut count = 0;
+        for item in self.items {
+            count += item.transfer_count() as usize
+        }
+
+        count
+    }
+
     /// Link items of given indices together: first -> second.
     pub fn link_indices(&mut self, first: usize, second: usize) {
         assert!(first < self.len());
diff --git a/embassy-stm32/src/dma/gpdma/mod.rs b/embassy-stm32/src/dma/gpdma/mod.rs
index f65048d1f..1d2811ab4 100644
--- a/embassy-stm32/src/dma/gpdma/mod.rs
+++ b/embassy-stm32/src/dma/gpdma/mod.rs
@@ -94,15 +94,31 @@ impl From<vals::Dw> for WordSize {
     }
 }
 
+pub(crate) struct LLiState {
+    /// The number of linked-list items.
+    count: AtomicUsize,
+    /// The index of the current linked-list item.
+    index: AtomicUsize,
+    /// The total transfer count of all linked-list items in number of words.
+    transfer_count: AtomicUsize,
+}
+
 pub(crate) struct ChannelState {
     waker: AtomicWaker,
     complete_count: AtomicUsize,
+    lli_state: LLiState,
 }
 
 impl ChannelState {
     pub(crate) const NEW: Self = Self {
         waker: AtomicWaker::new(),
         complete_count: AtomicUsize::new(0),
+
+        lli_state: LLiState {
+            count: AtomicUsize::new(0),
+            index: AtomicUsize::new(0),
+            transfer_count: AtomicUsize::new(0),
+        },
     };
 }
 
@@ -161,7 +177,25 @@ impl AnyChannel {
 
         if sr.tcf() {
             ch.fcr().write(|w| w.set_tcf(true));
-            state.complete_count.fetch_add(1, Ordering::Release);
+
+            let lli_count = state.lli_state.count.load(Ordering::Relaxed);
+            let complete = if lli_count > 0 {
+                let next_lli_index = state.lli_state.index.load(Ordering::Relaxed) + 1;
+                let complete = next_lli_index >= lli_count;
+
+                state
+                    .lli_state
+                    .index
+                    .store(if complete { 0 } else { next_lli_index }, Ordering::Relaxed);
+
+                complete
+            } else {
+                true
+            };
+
+            if complete {
+                state.complete_count.fetch_add(1, Ordering::Release);
+            }
         }
 
         if sr.suspf() {
@@ -242,6 +276,11 @@ impl AnyChannel {
             w.set_dteie(true);
             w.set_suspie(true);
         });
+
+        let state = &STATE[self.id as usize];
+        state.lli_state.count.store(0, Ordering::Relaxed);
+        state.lli_state.index.store(0, Ordering::Relaxed);
+        state.lli_state.transfer_count.store(0, Ordering::Relaxed)
     }
 
     unsafe fn configure_linked_list<const ITEM_COUNT: usize>(
@@ -286,6 +325,14 @@ impl AnyChannel {
             w.set_dteie(true);
             w.set_suspie(true);
         });
+
+        let state = &STATE[self.id as usize];
+        state.lli_state.count.store(ITEM_COUNT, Ordering::Relaxed);
+        state.lli_state.index.store(0, Ordering::Relaxed);
+        state
+            .lli_state
+            .transfer_count
+            .store(table.transfer_count(), Ordering::Relaxed)
     }
 
     fn start(&self) {
diff --git a/embassy-stm32/src/dma/gpdma/ringbuffered.rs b/embassy-stm32/src/dma/gpdma/ringbuffered.rs
index fd0a98e23..65ba00b3a 100644
--- a/embassy-stm32/src/dma/gpdma/ringbuffered.rs
+++ b/embassy-stm32/src/dma/gpdma/ringbuffered.rs
@@ -22,7 +22,19 @@ struct DmaCtrlImpl<'a>(PeripheralRef<'a, AnyChannel>);
 
 impl<'a> DmaCtrl for DmaCtrlImpl<'a> {
     fn get_remaining_transfers(&self) -> usize {
-        self.0.get_remaining_transfers() as _
+        let state = &STATE[self.0.id as usize];
+        let current_remaining = self.0.get_remaining_transfers() as usize;
+
+        let lli_count = state.lli_state.count.load(Ordering::Relaxed);
+
+        if lli_count > 0 {
+            let lli_index = state.lli_state.index.load(Ordering::Relaxed);
+            let single_transfer_count = state.lli_state.transfer_count.load(Ordering::Relaxed) / lli_count;
+
+            (lli_count - lli_index - 1) * single_transfer_count + current_remaining
+        } else {
+            current_remaining
+        }
     }
 
     fn reset_complete_count(&mut self) -> usize {
@@ -56,7 +68,7 @@ impl BufferHalf {
 pub struct ReadableRingBuffer<'a, W: Word> {
     channel: PeripheralRef<'a, AnyChannel>,
     ringbuf: ReadableDmaRingBuffer<'a, W>,
-    table: Table<1>,
+    table: Table<2>,
     user_buffer_half: BufferHalf,
 }
 
@@ -78,12 +90,10 @@ impl<'a, W: Word> ReadableRingBuffer<'a, W> {
         options.half_transfer_ir = true;
         options.complete_transfer_ir = true;
 
-        // let items = [
-        //     LinearItem::new_read(request, peri_addr, &mut buffer[..half_len], options),
-        //     LinearItem::new_read(request, peri_addr, &mut buffer[half_len..], options),
-        // ];
-        let items = [LinearItem::new_read(request, peri_addr, buffer, options)];
-
+        let items = [
+            LinearItem::new_read(request, peri_addr, &mut buffer[..half_len], options),
+            LinearItem::new_read(request, peri_addr, &mut buffer[half_len..], options),
+        ];
         let table = Table::new(items);
 
         let this = Self {
@@ -209,7 +219,7 @@ impl<'a, W: Word> Drop for ReadableRingBuffer<'a, W> {
 pub struct WritableRingBuffer<'a, W: Word> {
     channel: PeripheralRef<'a, AnyChannel>,
     ringbuf: WritableDmaRingBuffer<'a, W>,
-    table: Table<1>,
+    table: Table<2>,
     user_buffer_half: BufferHalf,
 }
 
@@ -231,11 +241,10 @@ impl<'a, W: Word> WritableRingBuffer<'a, W> {
         options.half_transfer_ir = true;
         options.complete_transfer_ir = true;
 
-        // let items = [
-        //     LinearItem::new_write(request, &mut buffer[..half_len], peri_addr, options),
-        //     LinearItem::new_write(request, &mut buffer[half_len..], peri_addr, options),
-        // ];
-        let items = [LinearItem::new_write(request, buffer, peri_addr, options)];
+        let items = [
+            LinearItem::new_write(request, &mut buffer[..half_len], peri_addr, options),
+            LinearItem::new_write(request, &mut buffer[half_len..], peri_addr, options),
+        ];
         let table = Table::new(items);
 
         let this = Self {