Fixes, simpler dma example

- Use stack allocated buffers for dma example,
- fix wait_for_transfer_complete/wait_for_half_transfer_complete
- remove clock sync delays

Author: astapleton

examples/dma.rs

@@ -4,8 +4,6 @@
 
 mod utilities;
 
-use core::mem::MaybeUninit;
-
 use cortex_m_rt::entry;
 use cortex_m_semihosting::debug;
 use stm32h5xx_hal::{
@@ -14,114 +12,6 @@ use stm32h5xx_hal::{
     prelude::*,
 };
 
-static mut SOURCE_BYTES: MaybeUninit<[u8; 40]> = MaybeUninit::uninit();
-static mut DEST_BYTES: MaybeUninit<[u8; 40]> = MaybeUninit::zeroed();
-static mut DEST_HALF_WORDS: MaybeUninit<[u16; 20]> = MaybeUninit::uninit();
-static mut SOURCE_WORDS: MaybeUninit<[u32; 10]> = MaybeUninit::uninit();
-static mut DEST_WORDS: MaybeUninit<[u32; 10]> = MaybeUninit::uninit();
-
-fn u8_to_u8_sequential() -> (&'static [u8; 40], &'static mut [u8; 40]) {
-    let buf: &mut [MaybeUninit<u8>; 40] = unsafe {
-        &mut *(core::ptr::addr_of_mut!(SOURCE_BYTES)
-            as *mut [MaybeUninit<u8>; 40])
-    };
-
-    for (i, value) in buf.iter_mut().enumerate() {
-        unsafe {
-            value.as_mut_ptr().write(i as u8);
-        }
-    }
-    #[allow(static_mut_refs)] // TODO: Fix this
-    let src = unsafe { SOURCE_BYTES.assume_init_ref() };
-
-    let dest =
-        unsafe { (*core::ptr::addr_of_mut!(DEST_BYTES)).assume_init_mut() };
-
-    dest.fill(0);
-
-    (src, dest)
-}
-
-fn u32_to_u32_transform() -> (&'static [u32; 10], &'static mut [u32; 10]) {
-    let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
-        &mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
-            as *mut [MaybeUninit<u32>; 10])
-    };
-
-    buf.fill(MaybeUninit::new(0x12345678));
-
-    #[allow(static_mut_refs)] // TODO: Fix this
-    let src = unsafe { SOURCE_WORDS.assume_init_ref() };
-
-    let dest =
-        unsafe { (*core::ptr::addr_of_mut!(DEST_WORDS)).assume_init_mut() };
-
-    dest.fill(0);
-    (src, dest)
-}
-
-fn u32_to_u16_truncate() -> (&'static [u32; 10], &'static mut [u16; 20]) {
-    let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
-        &mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
-            as *mut [MaybeUninit<u32>; 10])
-    };
-
-    buf.fill(MaybeUninit::new(0x12345678));
-
-    #[allow(static_mut_refs)] // TODO: Fix this
-    let src = unsafe { SOURCE_WORDS.assume_init_ref() };
-
-    let dest = unsafe {
-        (*core::ptr::addr_of_mut!(DEST_HALF_WORDS)).assume_init_mut()
-    };
-
-    dest.fill(0);
-    (src, dest)
-}
-
-fn u32_to_u8_unpack() -> (&'static [u32; 10], &'static mut [u8; 40]) {
-    let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
-        &mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
-            as *mut [MaybeUninit<u32>; 10])
-    };
-
-    buf.fill(MaybeUninit::new(0x12345678));
-
-    #[allow(static_mut_refs)] // TODO: Fix this
-    let src = unsafe { SOURCE_WORDS.assume_init_ref() };
-
-    let dest =
-        unsafe { (*core::ptr::addr_of_mut!(DEST_BYTES)).assume_init_mut() };
-
-    dest.fill(0);
-    (src, dest)
-}
-
-fn u8_to_u32_pack() -> (&'static [u8; 40], &'static mut [u32; 10]) {
-    let buf: &mut [MaybeUninit<u8>; 40] = unsafe {
-        &mut *(core::ptr::addr_of_mut!(SOURCE_BYTES)
-            as *mut [MaybeUninit<u8>; 40])
-    };
-
-    for chunk in buf.chunks_mut(4) {
-        unsafe {
-            chunk[0].as_mut_ptr().write(0x78);
-            chunk[1].as_mut_ptr().write(0x56);
-            chunk[2].as_mut_ptr().write(0x34);
-            chunk[3].as_mut_ptr().write(0x12);
-        }
-    }
-
-    #[allow(static_mut_refs)] // TODO: Fix this
-    let src = unsafe { SOURCE_BYTES.assume_init_ref() };
-
-    let dest =
-        unsafe { (*core::ptr::addr_of_mut!(DEST_WORDS)).assume_init_mut() };
-
-    dest.fill(0);
-    (src, dest)
-}
-
 #[entry]
 fn main() -> ! {
     utilities::logger::init();
@@ -137,66 +27,85 @@ fn main() -> ! {
 
     let channels = dp.GPDMA1.channels(ccdr.peripheral.GPDMA1);
 
-    let (source_buf, dest_buf) = u8_to_u8_sequential();
+    // u8 to u8
+    log::info!("u8 to u8 transfer");
+    let src: [u8; 40] = core::array::from_fn(|i| i as u8);
+    let dest = &mut [0u8; 40];
 
     let channel = channels.0;
     let config = DmaConfig::new();
-    let transfer =
-        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
+    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    assert_eq!(source_buf, dest_buf);
+    assert_eq!(src, *dest, "u8 to u8 transfer failed");
 
-    let (source_buf, dest_buf) = u32_to_u32_transform();
+    // u32 to u32 with data transform
+    log::info!("u32 to u32 with data transform");
+    let src = [0x12345678u32; 10];
+    let dest = &mut [0u32; 10];
     let config = DmaConfig::new().with_data_transform(
         DataTransform::builder()
             .swap_destination_half_words()
             .swap_destination_half_word_byte_order(),
     );
 
-    let transfer =
-        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
+    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    let expected = [0x78563412; 10];
-    assert_eq!(expected, *dest_buf);
+    assert_eq!(
+        [0x78563412; 10], *dest,
+        "u32 to u32 with data transform failed"
+    );
 
-    let (source_buf, dest_buf) = u32_to_u16_truncate();
+    // u32 to u16 with truncate
+    log::info!("u32 to u16 with truncate");
+    let src = [0x12345678u32; 10];
+    let dest = &mut [0u16; 20];
     let config = DmaConfig::new().with_data_transform(
         DataTransform::builder().left_align_right_truncate(),
     );
-    let transfer =
-        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
+    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    let expected = [0x1234; 10];
-    assert_eq!(expected, (*dest_buf)[0..10]);
+    assert_eq!(
+        [0x1234; 10],
+        (*dest)[0..10],
+        "u32 to u16 with truncate failed"
+    );
+    assert_eq!([0; 10], (*dest)[10..20], "u32 to u16 with truncate failed");
 
-    let (source_buf, dest_buf) = u32_to_u8_unpack();
+    // u32 to u8 with unpack
+    log::info!("u32 to u8 with unpack");
+    let src = [0x12345678u32; 10];
+    let dest = &mut [0u8; 40];
     let config =
         DmaConfig::new().with_data_transform(DataTransform::builder().unpack());
-    let transfer =
-        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
+    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
     let expected = [0x78, 0x56, 0x34, 0x12];
-    assert_eq!(expected, (*dest_buf)[0..4]);
-    assert_eq!(expected, (*dest_buf)[36..40]);
-
-    let (source_buf, dest_buf) = u8_to_u32_pack();
+    assert_eq!(expected, (*dest)[0..4], "u32 to u8 unpack failed");
+    assert_eq!(expected, (*dest)[36..40], "u32 to u8 unpack failed");
+
+    // u8 to u32 with pack
+    log::info!("u8 to u32 with pack");
+    let mut src = [0u8; 40];
+    let dest = &mut [0u32; 10];
+    for chunk in src.chunks_mut(4) {
+        chunk.copy_from_slice(&[0x78, 0x56, 0x34, 0x12]);
+    }
     let config =
         DmaConfig::new().with_data_transform(DataTransform::builder().pack());
-    let transfer =
-        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
+    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    let expected = [0x12345678; 10];
-    assert_eq!(expected, (*dest_buf));
-    assert_eq!(expected, (*dest_buf));
+    assert_eq!([0x12345678; 10], (*dest), "u8 to u32 with pack failed");
+
+    log::info!("All tests passed!");
 
     loop {
         debug::exit(debug::EXIT_SUCCESS)

src/gpdma/ch.rs

@@ -213,8 +213,6 @@ where
                 .tof()
                 .clear()
         });
-
-        interrupt_clear_clock_sync_delay!(self.sr());
     }
 
     #[inline(always)]
@@ -235,8 +233,6 @@ where
                 TransferEvent::TransferComplete => w.tcf().clear(),
                 TransferEvent::HalfTransferComplete => w.htf().clear(),
             });
-
-            interrupt_clear_clock_sync_delay!(self.sr());
         }
         Ok(triggered)
     }
@@ -633,13 +629,21 @@ where
 
     /// Blocks waiting for a transfer to complete. Reports any errors that occur during a transfer.
     fn wait_for_transfer_complete(&self) -> Result<(), Error> {
+        if !self.is_running() {
+            return Ok(());
+        }
+
         while !self.check_transfer_complete()? {}
         Ok(())
     }
 
     /// Blocks waiting for a half transfer event to trigger. Reports any errors that occur during a
     /// transfer.
     fn wait_for_half_transfer_complete(&self) -> Result<(), Error> {
+        if !self.is_running() {
+            return Ok(());
+        }
+
         while !self.check_half_transfer_complete()? {}
         Ok(())
     }