Replace Pin with StableDeref bounds for DMA buffers

Author: kalkyl

examples/i2s-controller-demo/src/main.rs

@@ -14,7 +14,6 @@ use small_morse::{encode, State};
 use {
     core::{
         panic::PanicInfo,
-        pin,
         sync::atomic::{compiler_fence, Ordering},
     },
     hal::{
@@ -33,8 +32,8 @@ use {
 #[rtic::app(device = crate::hal::pac, peripherals = true, monotonic = rtic::cyccnt::CYCCNT)]
 const APP: () = {
     struct Resources {
-        signal_buf: pin::Pin<&'static [i16]>,
-        mute_buf: pin::Pin<&'static [i16]>,
+        signal_buf: &'static [i16],
+        mute_buf: &'static [i16],
         #[init(None)]
         queue: Option<Queue<State, U256>>,
         producer: Producer<'static, State, U256>,
@@ -47,7 +46,7 @@ const APP: () = {
         btn1: Pin<Input<PullUp>>,
         btn2: Pin<Input<PullUp>>,
         led: Pin<Output<PushPull>>,
-        transfer: Option<hal::i2s::Transfer<&'static [i16]>>,
+        transfer: Option<Transfer<&'static [i16]>>,
     }
 
     #[init(resources = [queue], spawn = [tick])]
@@ -125,9 +124,9 @@ const APP: () = {
             led: p0.p0_13.into_push_pull_output(Level::High).degrade(),
             uarte,
             uarte_timer: Timer::new(ctx.device.TIMER0),
-            transfer: i2s.tx(pin::Pin::new(&MUTE_BUF[..])).ok(),
-            signal_buf: pin::Pin::new(&SIGNAL_BUF[..]),
-            mute_buf: pin::Pin::new(&MUTE_BUF[..]),
+            transfer: i2s.tx(&MUTE_BUF[..]).ok(),
+            signal_buf: &SIGNAL_BUF[..],
+            mute_buf: &MUTE_BUF[..],
         }
     }
 

examples/i2s-peripheral-demo/src/main.rs

@@ -8,7 +8,6 @@ use embedded_hal::blocking::spi::Write;
 use {
     core::{
         panic::PanicInfo,
-        pin,
         sync::atomic::{compiler_fence, Ordering},
     },
     hal::{
@@ -30,7 +29,7 @@ const RED: [u8; 9] = [0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x10, 0xFF];
 const APP: () = {
     struct Resources {
         rgb: Spim<SPIM0>,
-        transfer: Option<hal::i2s::Transfer<&'static mut [i16]>>,
+        transfer: Option<Transfer<&'static mut [i16]>>,
     }
 
     #[init]
@@ -57,8 +56,6 @@ const APP: () = {
             None,
         );
         i2s.enable_interrupt(I2SEvent::RxPtrUpdated).start();
-        let rx_buf = pin::Pin::new(&mut RX_BUF[..]);
-        let transfer = i2s.rx(rx_buf).ok();
 
         // Configure APA102 RGB LED control
         let p1 = hal::gpio::p1::Parts::new(ctx.device.P1);
@@ -79,7 +76,10 @@ const APP: () = {
             },
             0,
         );
-        init::LateResources { rgb, transfer }
+        init::LateResources {
+            rgb,
+            transfer: i2s.rx(&mut RX_BUF[..]).ok(),
+        }
     }
 
     #[task(binds = I2S, resources = [rgb, transfer])]

nrf-hal-common/Cargo.toml

@@ -25,6 +25,10 @@ fixed = "1.0.0"
 rand_core = "0.5.1"
 cfg-if = "0.1.10"
 
+[dependencies.stable_deref_trait]
+version = "1.2.0"
+default-features = false
+
 [dependencies.void]
 default-features = false
 version = "1.0.2"

nrf-hal-common/src/i2s.rs

@@ -14,6 +14,7 @@ use core::{
     ops::{Deref, DerefMut},
     sync::atomic::{compiler_fence, Ordering},
 };
+pub use stable_deref_trait::StableDeref;
 
 use i2s::{_EVENTS_RXPTRUPD, _EVENTS_STOPPED, _EVENTS_TXPTRUPD, _TASKS_START, _TASKS_STOP};
 
@@ -261,27 +262,26 @@ impl I2S {
             _ => Channels::Right,
         }
     }
-
     /// Receives data into the given `buffer` until it's filled.
     /// Returns a value that represents the in-progress DMA transfer.
     #[allow(unused_mut)]
-    pub fn rx<Word, B>(mut self, mut buffer: core::pin::Pin<B>) -> Result<Transfer<B>, Error>
+    pub fn rx<Word, B>(mut self, mut buffer: B) -> Result<Transfer<B>, Error>
     where
         Word: SupportedWordSize,
-        B: DerefMut + 'static,
-        B::Target: AsMut<[Word]> + Unpin + I2SBuffer,
+        B: DerefMut + StableDeref + 'static + I2SBuffer,
+        B::Target: AsMut<[Word]>,
     {
-        if buffer.as_mut().maxcnt() > MAX_DMA_MAXCNT {
+        if buffer.maxcnt() > MAX_DMA_MAXCNT {
             return Err(Error::BufferTooLong);
         }
         self.i2s
             .rxd
             .ptr
-            .write(|w| unsafe { w.ptr().bits(buffer.as_mut().ptr()) });
+            .write(|w| unsafe { w.ptr().bits(buffer.ptr()) });
         self.i2s
             .rxtxd
             .maxcnt
-            .write(|w| unsafe { w.bits(buffer.as_mut().maxcnt()) });
+            .write(|w| unsafe { w.bits(buffer.maxcnt()) });
         Ok(Transfer {
             inner: Some(Inner { buffer, i2s: self }),
         })
@@ -294,40 +294,38 @@ impl I2S {
     #[allow(unused_mut)]
     pub fn transfer<Word, TxB, RxB>(
         mut self,
-        tx_buffer: core::pin::Pin<TxB>,
-        mut rx_buffer: core::pin::Pin<RxB>,
+        tx_buffer: TxB,
+        mut rx_buffer: RxB,
     ) -> Result<TransferFullDuplex<TxB, RxB>, Error>
     where
         Word: SupportedWordSize,
-        TxB: Deref + 'static,
-        TxB::Target: AsRef<[Word]> + I2SBuffer,
-        RxB: DerefMut + 'static,
-        RxB::Target: AsMut<[Word]> + Unpin + I2SBuffer,
+        TxB: Deref + StableDeref + 'static + I2SBuffer,
+        TxB::Target: AsRef<[Word]>,
+        RxB: DerefMut + StableDeref + 'static + I2SBuffer,
+        RxB::Target: AsMut<[Word]>,
     {
-        if (tx_buffer.as_ref().ptr() as usize) < SRAM_LOWER
-            || (tx_buffer.as_ref().ptr() as usize) > SRAM_UPPER
-        {
+        if (tx_buffer.ptr() as usize) < SRAM_LOWER || (tx_buffer.ptr() as usize) > SRAM_UPPER {
             return Err(Error::DMABufferNotInDataMemory);
         }
-        if tx_buffer.as_ref().maxcnt() != rx_buffer.as_mut().maxcnt() {
+        if tx_buffer.maxcnt() != rx_buffer.maxcnt() {
             return Err(Error::BuffersDontMatch);
         }
-        if tx_buffer.as_ref().maxcnt() > MAX_DMA_MAXCNT {
+        if tx_buffer.maxcnt() > MAX_DMA_MAXCNT {
             return Err(Error::BufferTooLong);
         }
 
         self.i2s
             .txd
             .ptr
-            .write(|w| unsafe { w.ptr().bits(tx_buffer.as_ref().ptr()) });
+            .write(|w| unsafe { w.ptr().bits(tx_buffer.ptr()) });
         self.i2s
             .rxd
             .ptr
-            .write(|w| unsafe { w.ptr().bits(rx_buffer.as_mut().ptr()) });
+            .write(|w| unsafe { w.ptr().bits(rx_buffer.ptr()) });
         self.i2s
             .rxtxd
             .maxcnt
-            .write(|w| unsafe { w.bits(rx_buffer.as_mut().maxcnt()) });
+            .write(|w| unsafe { w.bits(rx_buffer.maxcnt()) });
 
         self.start();
 
@@ -343,30 +341,28 @@ impl I2S {
     /// Transmits the given `tx_buffer`.
     /// Returns a value that represents the in-progress DMA transfer.
     #[allow(unused_mut)]
-    pub fn tx<Word, B>(mut self, buffer: core::pin::Pin<B>) -> Result<Transfer<B>, Error>
+    pub fn tx<Word, B>(mut self, buffer: B) -> Result<Transfer<B>, Error>
     where
         Word: SupportedWordSize,
-        B: Deref + 'static,
-        B::Target: AsRef<[Word]> + I2SBuffer,
+        B: Deref + StableDeref + 'static + I2SBuffer,
+        B::Target: AsRef<[Word]>,
     {
-        if (buffer.as_ref().ptr() as usize) < SRAM_LOWER
-            || (buffer.as_ref().ptr() as usize) > SRAM_UPPER
-        {
+        if (buffer.ptr() as usize) < SRAM_LOWER || (buffer.ptr() as usize) > SRAM_UPPER {
             return Err(Error::DMABufferNotInDataMemory);
         }
 
-        if buffer.as_ref().maxcnt() > MAX_DMA_MAXCNT {
+        if buffer.maxcnt() > MAX_DMA_MAXCNT {
             return Err(Error::BufferTooLong);
         }
 
         self.i2s
             .txd
             .ptr
-            .write(|w| unsafe { w.ptr().bits(buffer.as_ref().ptr()) });
+            .write(|w| unsafe { w.ptr().bits(buffer.ptr()) });
         self.i2s
             .rxtxd
             .maxcnt
-            .write(|w| unsafe { w.bits(buffer.as_ref().maxcnt()) });
+            .write(|w| unsafe { w.bits(buffer.maxcnt()) });
 
         Ok(Transfer {
             inner: Some(Inner { buffer, i2s: self }),
@@ -608,8 +604,68 @@ pub trait I2SBuffer: private::Sealed {
     fn maxcnt(&self) -> u32;
 }
 
-impl private::Sealed for [i8] {}
-impl I2SBuffer for [i8] {
+impl private::Sealed for &[i8] {}
+impl I2SBuffer for &[i8] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32 / 4
+    }
+}
+
+impl private::Sealed for &[i16] {}
+impl I2SBuffer for &[i16] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32 / 2
+    }
+}
+
+impl private::Sealed for &[i32] {}
+impl I2SBuffer for &[i32] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32
+    }
+}
+
+impl private::Sealed for &[u8] {}
+impl I2SBuffer for &[u8] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32 / 8
+    }
+}
+
+impl private::Sealed for &[u16] {}
+impl I2SBuffer for &[u16] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32 / 4
+    }
+}
+
+impl private::Sealed for &[u32] {}
+impl I2SBuffer for &[u32] {
+    fn ptr(&self) -> u32 {
+        self.as_ptr() as u32
+    }
+    fn maxcnt(&self) -> u32 {
+        self.len() as u32 / 2
+    }
+}
+
+impl private::Sealed for &mut [i8] {}
+impl I2SBuffer for &mut [i8] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -618,8 +674,8 @@ impl I2SBuffer for [i8] {
     }
 }
 
-impl private::Sealed for [i16] {}
-impl I2SBuffer for [i16] {
+impl private::Sealed for &mut [i16] {}
+impl I2SBuffer for &mut [i16] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -628,8 +684,8 @@ impl I2SBuffer for [i16] {
     }
 }
 
-impl private::Sealed for [i32] {}
-impl I2SBuffer for [i32] {
+impl private::Sealed for &mut [i32] {}
+impl I2SBuffer for &mut [i32] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -638,8 +694,8 @@ impl I2SBuffer for [i32] {
     }
 }
 
-impl private::Sealed for [u8] {}
-impl I2SBuffer for [u8] {
+impl private::Sealed for &mut [u8] {}
+impl I2SBuffer for &mut [u8] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -648,8 +704,8 @@ impl I2SBuffer for [u8] {
     }
 }
 
-impl private::Sealed for [u16] {}
-impl I2SBuffer for [u16] {
+impl private::Sealed for &mut [u16] {}
+impl I2SBuffer for &mut [u16] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -658,8 +714,8 @@ impl I2SBuffer for [u16] {
     }
 }
 
-impl private::Sealed for [u32] {}
-impl I2SBuffer for [u32] {
+impl private::Sealed for &mut [u32] {}
+impl I2SBuffer for &mut [u32] {
     fn ptr(&self) -> u32 {
         self.as_ptr() as u32
     }
@@ -674,13 +730,13 @@ pub struct Transfer<B> {
 }
 
 struct Inner<B> {
-    buffer: core::pin::Pin<B>,
+    buffer: B,
     i2s: I2S,
 }
 
 impl<B> Transfer<B> {
     /// Blocks until the transfer is done and returns the buffer.
-    pub fn wait(mut self) -> (core::pin::Pin<B>, I2S) {
+    pub fn wait(mut self) -> (B, I2S) {
         let inner = self
             .inner
             .take()
@@ -707,14 +763,14 @@ pub struct TransferFullDuplex<TxB, RxB> {
 }
 
 struct InnerFullDuplex<TxB, RxB> {
-    tx_buffer: core::pin::Pin<TxB>,
-    rx_buffer: core::pin::Pin<RxB>,
+    tx_buffer: TxB,
+    rx_buffer: RxB,
     i2s: I2S,
 }
 
 impl<TxB, RxB> TransferFullDuplex<TxB, RxB> {
     /// Blocks until the transfer is done and returns the buffer.
-    pub fn wait(mut self) -> (core::pin::Pin<TxB>, core::pin::Pin<RxB>, I2S) {
+    pub fn wait(mut self) -> (TxB, RxB, I2S) {
         let inner = self
             .inner
             .take()