use ReadBuffer, WriteBuffer to force immovable buffers; fix example

astapleton · astapleton · commit 6f3aa814425c · 2025-07-31T19:52:56.000-07:00
diff --git a/examples/dma.rs b/examples/dma.rs
@@ -4,6 +4,8 @@
 
 mod utilities;
 
+use core::mem::MaybeUninit;
+
 use cortex_m_rt::entry;
 use cortex_m_semihosting::debug;
 use stm32h5xx_hal::{
@@ -12,6 +14,114 @@ 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();
@@ -27,85 +137,72 @@ fn main() -> ! {
 
     let channels = dp.GPDMA1.channels(ccdr.peripheral.GPDMA1);
 
-    // 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 (source_buf, dest_buf) = u8_to_u8_sequential();
+    let source_copy = unsafe { &*(source_buf.as_ptr() as *const [u8; 40]) };
+    let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u8; 40]) };
 
     let channel = channels.0;
     let config = DmaConfig::new();
-    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
+    let transfer =
+        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    assert_eq!(src, *dest, "u8 to u8 transfer failed");
+    assert_eq!(source_copy, dest_copy);
 
-    // u32 to u32 with data transform
-    log::info!("u32 to u32 with data transform");
-    let src = [0x12345678u32; 10];
-    let dest = &mut [0u32; 10];
+    let (source_buf, dest_buf) = u32_to_u32_transform();
+    let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u32; 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, &src, dest);
+    let transfer =
+        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    assert_eq!(
-        [0x78563412; 10], *dest,
-        "u32 to u32 with data transform failed"
-    );
+    let expected = [0x78563412; 10];
+    assert_eq!(expected, *dest_copy);
 
-    // u32 to u16 with truncate
-    log::info!("u32 to u16 with truncate");
-    let src = [0x12345678u32; 10];
-    let dest = &mut [0u16; 20];
+    let (source_buf, dest_buf) = u32_to_u16_truncate();
+    let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u16; 20]) };
     let config = DmaConfig::new().with_data_transform(
         DataTransform::builder().left_align_right_truncate(),
     );
-    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
+    let transfer =
+        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    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 expected = [0x1234; 10];
+    assert_eq!(expected, (*dest_copy)[0..10]);
 
-    // u32 to u8 with unpack
-    log::info!("u32 to u8 with unpack");
-    let src = [0x12345678u32; 10];
-    let dest = &mut [0u8; 40];
+    let (source_buf, dest_buf) = u32_to_u8_unpack();
+    let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u8; 40]) };
     let config =
         DmaConfig::new().with_data_transform(DataTransform::builder().unpack());
-    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
+    let transfer =
+        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
     let expected = [0x78, 0x56, 0x34, 0x12];
-    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]);
-    }
+    assert_eq!(expected, (*dest_copy)[0..4]);
+    assert_eq!(expected, (*dest_copy)[36..40]);
+
+    let (source_buf, dest_buf) = u8_to_u32_pack();
+    let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u32; 10]) };
     let config =
         DmaConfig::new().with_data_transform(DataTransform::builder().pack());
-    let transfer = DmaTransfer::memory_to_memory(config, &channel, &src, dest);
+    let transfer =
+        DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
 
     transfer.start().unwrap();
     transfer.wait_for_transfer_complete().unwrap();
-    assert_eq!([0x12345678; 10], (*dest), "u8 to u32 with pack failed");
-
-    log::info!("All tests passed!");
+    let expected = [0x12345678; 10];
+    assert_eq!(expected, (*dest_copy));
+    assert_eq!(expected, (*dest_copy));
 
     loop {
         debug::exit(debug::EXIT_SUCCESS)
diff --git a/src/gpdma.rs b/src/gpdma.rs
@@ -278,22 +278,22 @@ impl<'a, CH: DmaChannel> DmaTransfer<'a, CH> {
     /// Create a new memory-to-memory transfer with the channel, source and destination buffers
     /// provided.
     pub fn memory_to_memory<S, D>(
-        config: DmaConfig<MemoryToMemory, S, D>,
+        config: DmaConfig<MemoryToMemory, S::Word, D::Word>,
         channel: &'a CH,
-        source: &'a [S],
-        destination: &'a mut [D],
+        source: S,
+        mut destination: D,
     ) -> Self
     where
-        S: Word,
-        D: Word,
+        S: ReadBuffer<Word: Word>,
+        D: WriteBuffer<Word: Word>,
     {
         let src_width = core::mem::size_of::<S>();
         let dest_width = core::mem::size_of::<D>();
 
-        let src_ptr = source.as_ptr();
-        let src_size = core::mem::size_of_val(source);
-        let dest_ptr = destination.as_mut_ptr();
-        let dest_size = core::mem::size_of_val(destination);
+        let (src_ptr, src_words) = unsafe { source.read_buffer() };
+        let src_size = core::mem::size_of::<S::Word>() * src_words;
+        let (dest_ptr, dest_words) = unsafe { destination.write_buffer() };
+        let dest_size = core::mem::size_of::<D::Word>() * dest_words;
 
         // Size must be aligned with destination width if source width is greater than destination
         // width and packing mode is used, therefore the maximum size must be dictated by
@@ -312,28 +312,28 @@ impl<'a, CH: DmaChannel> DmaTransfer<'a, CH> {
 
         // We also need to ensure that the destination
 
-        Self::new::<S, D, MemoryToMemory>(
+        Self::new::<S::Word, D::Word, MemoryToMemory>(
             channel, config, src_ptr, dest_ptr, size,
         )
     }
 
     /// Create a new memory-to-peripheral transfer with the channel, source buffer and destination
     /// peripheral provided.
     pub fn memory_to_peripheral<S, D>(
-        config: DmaConfig<MemoryToPeripheral, S, D::Word>,
+        config: DmaConfig<MemoryToPeripheral, S::Word, D::Word>,
         channel: &'a CH,
-        source: &'a [S],
+        source: S,
         mut destination: D,
     ) -> Self
     where
-        S: Word,
+        S: ReadBuffer<Word: Word>,
         D: WriteBuffer<Word: Word>,
     {
-        let src_ptr = source.as_ptr();
-        let src_size = core::mem::size_of_val(source);
+        let (src_ptr, src_words) = unsafe { source.read_buffer() };
+        let src_size = core::mem::size_of::<S::Word>() * src_words;
         let (dest_ptr, _) = unsafe { destination.write_buffer() };
 
-        Self::new::<S, D::Word, MemoryToPeripheral>(
+        Self::new::<S::Word, D::Word, MemoryToPeripheral>(
             channel, config, src_ptr, dest_ptr, src_size,
         )
         .apply_hardware_request_config(config)
@@ -342,21 +342,21 @@ impl<'a, CH: DmaChannel> DmaTransfer<'a, CH> {
     /// Create a new peripheral-to-memory transfer with the channel, source peripheral and
     /// destination buffer provided.
     pub fn peripheral_to_memory<S, D>(
-        config: DmaConfig<PeripheralToMemory, S::Word, D>,
+        config: DmaConfig<PeripheralToMemory, S::Word, D::Word>,
         channel: &'a CH,
         source: S,
-        destination: &'a mut [D],
+        mut destination: D,
     ) -> Self
     where
         S: ReadBuffer<Word: Word>,
-        D: Word,
+        D: WriteBuffer<Word: Word>,
     {
         let (src_ptr, _) = unsafe { source.read_buffer() };
 
-        let dest_ptr = destination.as_mut_ptr();
-        let dest_size = core::mem::size_of_val(destination);
+        let (dest_ptr, dest_words) = unsafe { destination.write_buffer() };
+        let dest_size = core::mem::size_of::<D::Word>() * dest_words;
 
-        Self::new::<S::Word, D, PeripheralToMemory>(
+        Self::new::<S::Word, D::Word, PeripheralToMemory>(
             channel, config, src_ptr, dest_ptr, dest_size,
         )
         .apply_hardware_request_config(config)
diff --git a/src/gpdma/periph.rs b/src/gpdma/periph.rs
