stm32/dma: add AnyChannel, add support for BDMA on H7.

1 files changed, 0 insertions, 122 deletions

diff --git a/embassy-stm32/src/dcmi.rs b/embassy-stm32/src/dcmi.rs
index 4d02284b2..826b04a4b 100644
--- a/embassy-stm32/src/dcmi.rs
+++ b/embassy-stm32/src/dcmi.rs
@@ -394,19 +394,7 @@ where
 
     /// This method starts the capture and finishes when both the dma transfer and DCMI finish the frame transfer.
     /// The implication is that the input buffer size must be exactly the size of the captured frame.
-    ///
-    /// Note that when `buffer.len() > 0xffff` the capture future requires some real-time guarantees to be upheld
-    /// (must be polled fast enough so the buffers get switched before data is overwritten).
-    /// It is therefore recommended that it is run on higher priority executor.
     pub async fn capture(&mut self, buffer: &mut [u32]) -> Result<(), Error> {
-        if buffer.len() <= 0xffff {
-            return self.capture_small(buffer).await;
-        } else {
-            return self.capture_giant(buffer).await;
-        }
-    }
-
-    async fn capture_small(&mut self, buffer: &mut [u32]) -> Result<(), Error> {
         let r = self.inner.regs();
         let src = r.dr().as_ptr() as *mut u32;
         let request = self.dma.request();
@@ -441,116 +429,6 @@ where
 
         result
     }
-
-    #[cfg(not(dma))]
-    async fn capture_giant(&mut self, _buffer: &mut [u32]) -> Result<(), Error> {
-        panic!("capturing to buffers larger than 0xffff is only supported on DMA for now, not on BDMA or GPDMA.");
-    }
-
-    #[cfg(dma)]
-    async fn capture_giant(&mut self, buffer: &mut [u32]) -> Result<(), Error> {
-        use crate::dma::TransferOptions;
-
-        let data_len = buffer.len();
-        let chunk_estimate = data_len / 0xffff;
-
-        let mut chunks = chunk_estimate + 1;
-        while data_len % chunks != 0 {
-            chunks += 1;
-        }
-
-        let chunk_size = data_len / chunks;
-
-        let mut remaining_chunks = chunks - 2;
-
-        let mut m0ar = buffer.as_mut_ptr();
-        let mut m1ar = unsafe { buffer.as_mut_ptr().add(chunk_size) };
-
-        let channel = &mut self.dma;
-        let request = channel.request();
-
-        let r = self.inner.regs();
-        let src = r.dr().as_ptr() as *mut u32;
-
-        let mut transfer = unsafe {
-            crate::dma::DoubleBuffered::new_read(
-                &mut self.dma,
-                request,
-                src,
-                m0ar,
-                m1ar,
-                chunk_size,
-                TransferOptions::default(),
-            )
-        };
-
-        let mut last_chunk_set_for_transfer = false;
-        let mut buffer0_last_accessible = false;
-        let dma_result = poll_fn(|cx| {
-            transfer.set_waker(cx.waker());
-
-            let buffer0_currently_accessible = transfer.is_buffer0_accessible();
-
-            // check if the accessible buffer changed since last poll
-            if buffer0_last_accessible == buffer0_currently_accessible {
-                return Poll::Pending;
-            }
-            buffer0_last_accessible = !buffer0_last_accessible;
-
-            if remaining_chunks != 0 {
-                if remaining_chunks % 2 == 0 && buffer0_currently_accessible {
-                    m0ar = unsafe { m0ar.add(2 * chunk_size) };
-                    unsafe { transfer.set_buffer0(m0ar) }
-                    remaining_chunks -= 1;
-                } else if !buffer0_currently_accessible {
-                    m1ar = unsafe { m1ar.add(2 * chunk_size) };
-                    unsafe { transfer.set_buffer1(m1ar) };
-                    remaining_chunks -= 1;
-                }
-            } else {
-                if buffer0_currently_accessible {
-                    unsafe { transfer.set_buffer0(buffer.as_mut_ptr()) }
-                } else {
-                    unsafe { transfer.set_buffer1(buffer.as_mut_ptr()) }
-                }
-                if last_chunk_set_for_transfer {
-                    transfer.request_stop();
-                    return Poll::Ready(());
-                }
-                last_chunk_set_for_transfer = true;
-            }
-            Poll::Pending
-        });
-
-        Self::clear_interrupt_flags();
-        Self::enable_irqs();
-
-        let result = poll_fn(|cx| {
-            STATE.waker.register(cx.waker());
-
-            let ris = crate::pac::DCMI.ris().read();
-            if ris.err_ris() {
-                crate::pac::DCMI.icr().write(|r| r.set_err_isc(true));
-                Poll::Ready(Err(Error::PeripheralError))
-            } else if ris.ovr_ris() {
-                crate::pac::DCMI.icr().write(|r| r.set_ovr_isc(true));
-                Poll::Ready(Err(Error::Overrun))
-            } else if ris.frame_ris() {
-                crate::pac::DCMI.icr().write(|r| r.set_frame_isc(true));
-                Poll::Ready(Ok(()))
-            } else {
-                Poll::Pending
-            }
-        });
-
-        Self::toggle(true);
-
-        let (_, result) = embassy_futures::join::join(dma_result, result).await;
-
-        Self::toggle(false);
-
-        result
-    }
 }
 
 mod sealed {