Fixes; improvements for starting transactions

Author: astapleton

src/spi.rs

@@ -838,22 +838,23 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
     }
 
     /// Sets up a frame transaction with the given amount of data words.
-    ///
-    /// If this is called when a transaction has already started,
-    /// then an error is returned with [Error::TransactionAlreadyStarted].
     fn setup_transaction(&mut self, length: usize) {
         assert!(
             length <= u16::MAX as usize,
             "Buffer too big! Max transaction size is {}",
             u16::MAX
         );
 
-        self.set_transfer_word_count(length.get() as u16);
+        self.inner.set_transfer_word_count(length as u16);
+
+        self.start_transaction();
+    }
 
+    fn start_transaction(&mut self) {
         // Re-enable
         self.inner.clear_modf();
         self.inner.enable();
-        self.spi().cr1().modify(|_, w| w.cstart().started());
+        self.inner.start_transfer();
     }
 
     /// Checks if the current transaction is complete and disables the
@@ -930,14 +931,7 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
         }
     }
 
-    fn start_write<'a>(
-        &mut self,
-        words: &'a [W],
-    ) -> Result<Transaction<Write<'a, W>, W>, Error> {
-        assert!(
-            !words.is_empty(),
-            "Write buffer should not be non-zero length"
-        );
+    fn setup_write_mode(&mut self) -> Result<(), Error> {
         let communication_mode = self.inner.communication_mode();
         if communication_mode == CommunicationMode::SimplexReceiver {
             return Err(Error::InvalidOperation);
@@ -947,16 +941,25 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
             self.inner.set_dir_transmitter();
         }
 
+        Ok(())
+    }
+
+    fn start_write<'a>(
+        &mut self,
+        words: &'a [W],
+    ) -> Result<Transaction<Write<'a, W>, W>, Error> {
+        assert!(
+            !words.is_empty(),
+            "Write buffer should not be non-zero length"
+        );
+
+        self.setup_write_mode()?;
         self.setup_transaction(words.len());
 
         Ok(Transaction::<Write<'a, W>, W>::write(words))
     }
 
-    fn start_read<'a>(
-        &mut self,
-        buf: &'a mut [W],
-    ) -> Result<Transaction<Read<'a, W>, W>, Error> {
-        assert!(!buf.is_empty(), "Read buffer should not be non-zero length");
+    fn setup_read_mode(&self) -> Result<(), Error> {
         let communication_mode = self.inner.communication_mode();
         if communication_mode == CommunicationMode::SimplexTransmitter {
             return Err(Error::InvalidOperation);
@@ -966,11 +969,29 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
             self.inner.set_dir_receiver();
         }
 
+        Ok(())
+    }
+
+    fn start_read<'a>(
+        &mut self,
+        buf: &'a mut [W],
+    ) -> Result<Transaction<Read<'a, W>, W>, Error> {
+        assert!(!buf.is_empty(), "Read buffer should not be non-zero length");
+
+        self.setup_read_mode()?;
         self.setup_transaction(buf.len());
 
         Ok(Transaction::<Read<'a, W>, W>::read(buf))
     }
 
+    fn check_transfer_mode(&mut self) -> Result<(), Error> {
+        if self.inner.communication_mode() != CommunicationMode::FullDuplex {
+            Err(Error::InvalidOperation)
+        } else {
+            Ok(())
+        }
+    }
+
     fn start_transfer<'a>(
         &mut self,
         read: &'a mut [W],
@@ -980,10 +1001,8 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
             !read.is_empty() && !write.is_empty(),
             "Transfer buffers should not be of zero length"
         );
-        if self.inner.communication_mode() != CommunicationMode::FullDuplex {
-            return Err(Error::InvalidOperation);
-        }
 
+        self.check_transfer_mode()?;
         self.setup_transaction(core::cmp::max(read.len(), write.len()));
 
         Ok(Transaction::<Transfer<'a, W>, W>::transfer(write, read))
@@ -997,9 +1016,7 @@ impl<SPI: Instance, W: Word> Spi<SPI, W> {
             !words.is_empty(),
             "Transfer buffer should not be of zero length"
         );
-        if self.inner.communication_mode() != CommunicationMode::FullDuplex {
-            return Err(Error::InvalidOperation);
-        }
+        self.check_transfer_mode()?;
 
         self.setup_transaction(words.len());
 

src/spi/dma.rs

@@ -1,13 +1,13 @@
-use core::{marker::PhantomData, num::NonZeroUsize};
+use core::marker::PhantomData;
 
 use embedded_dma::{ReadBuffer, WriteBuffer};
 
 use crate::gpdma::{
     config::{Config as DmaConfig, MemoryToPeripheral, PeripheralToMemory},
-    Channel, Transfer as DmaTransfer, Word,
+    Channel, ChannelRegs, Transfer as DmaTransfer, Word as DmaWord,
 };
 
-use super::{Error, FrameSize, Instance, Spi};
+use super::{Error, Instance, Spi, Word};
 
 pub struct DmaRx<SPI, W> {
     _spi: PhantomData<SPI>,
@@ -23,7 +23,7 @@ impl<SPI, W> DmaRx<SPI, W> {
     }
 }
 
-unsafe impl<SPI: Instance, W: FrameSize> ReadBuffer for DmaRx<SPI, W> {
+unsafe impl<SPI: Instance, W: Word> ReadBuffer for DmaRx<SPI, W> {
     type Word = W;
 
     unsafe fn read_buffer(&self) -> (*const Self::Word, usize) {
@@ -45,27 +45,32 @@ impl<SPI, W> DmaTx<SPI, W> {
     }
 }
 
-unsafe impl<SPI: Instance, W: FrameSize> WriteBuffer for DmaTx<SPI, W> {
+unsafe impl<SPI: Instance, W: Word> WriteBuffer for DmaTx<SPI, W> {
     type Word = W;
 
     unsafe fn write_buffer(&mut self) -> (*mut Self::Word, usize) {
         ((*SPI::ptr()).txdr().as_ptr() as *mut W, 1)
     }
 }
 
-pub struct RxDmaTransfer<'a, SPI, W: FrameSize, CH, D> {
+pub struct RxDmaTransfer<'a, SPI, W: Word, CH, D> {
     spi: &'a mut Spi<SPI, W>,
     transfer: DmaTransfer<CH, DmaRx<SPI, W>, D, PeripheralToMemory>,
 }
 
 impl<'a, SPI, W, CH, D> RxDmaTransfer<'a, SPI, W, CH, D>
 where
     SPI: Instance,
-    W: FrameSize + Word,
-    CH: Channel,
+    W: Word + DmaWord,
+    CH: ChannelRegs,
     D: WriteBuffer<Word = W>,
 {
-    pub fn new(spi: &'a mut Spi<SPI, W>, channel: CH, destination: D) -> Self {
+    pub fn new(
+        spi: &'a mut Spi<SPI, W>,
+        channel: Channel<CH>,
+        mut destination: D,
+    ) -> Self {
+        let (_, len) = unsafe { destination.write_buffer() };
         let config = DmaConfig::new().with_request(SPI::rx_dma_request());
         let source = DmaRx::new();
         let transfer = DmaTransfer::peripheral_to_memory(
@@ -74,15 +79,17 @@ where
             source,
             destination,
         );
+        spi.inner.set_transfer_word_count(len as u16);
         Self { spi, transfer }
     }
 
-    pub fn start(&mut self) -> Result<(), crate::gpdma::Error> {
-        self.spi.enable_rx_dma();
+    pub fn start(&mut self) -> Result<(), Error> {
+        self.spi.setup_read_mode()?;
+        self.spi.inner.enable_rx_dma();
         self.transfer.start_with(|_, _| {
-            self.spi.enable();
-            self.spi.start_transfer();
-        })
+            self.spi.start_transaction();
+        })?;
+        Ok(())
     }
 
     pub fn is_dma_complete(&self) -> Result<bool, Error> {
@@ -93,28 +100,33 @@ where
 
     pub fn end_transfer(&mut self) {
         self.spi.end_transaction();
-        self.spi.disable_dma();
+        self.spi.inner.disable_dma();
     }
 
-    pub fn free(self) -> Result<(CH, D), Error> {
+    pub fn free(self) -> Result<(Channel<CH>, D), Error> {
         let (ch, _, d) = self.transfer.free()?;
         Ok((ch, d))
     }
 }
 
-pub struct TxDmaTransfer<'a, SPI, W: FrameSize, CH, S> {
+pub struct TxDmaTransfer<'a, SPI, W: Word, CH, S> {
     spi: &'a mut Spi<SPI, W>,
     transfer: DmaTransfer<CH, S, DmaTx<SPI, W>, MemoryToPeripheral>,
 }
 
 impl<'a, SPI, W, CH, S> TxDmaTransfer<'a, SPI, W, CH, S>
 where
     SPI: Instance,
-    W: FrameSize + Word,
-    CH: Channel,
+    W: DmaWord + Word,
+    CH: ChannelRegs,
     S: ReadBuffer<Word = W>,
 {
-    pub fn new(spi: &'a mut Spi<SPI, W>, channel: CH, source: S) -> Self {
+    pub fn new(
+        spi: &'a mut Spi<SPI, W>,
+        channel: Channel<CH>,
+        source: S,
+    ) -> Self {
+        let (_, len) = unsafe { source.read_buffer() };
         let config = DmaConfig::new().with_request(SPI::tx_dma_request());
         let destination = DmaTx::new();
         let transfer = DmaTransfer::memory_to_peripheral(
@@ -123,15 +135,17 @@ where
             source,
             destination,
         );
+        spi.inner.set_transfer_word_count(len as u16);
         Self { spi, transfer }
     }
 
-    pub fn start(&mut self) -> Result<(), crate::gpdma::Error> {
+    pub fn start(&mut self) -> Result<(), Error> {
+        self.spi.setup_write_mode()?;
         self.transfer.start_with(|_, _| {
-            self.spi.enable_tx_dma();
-            self.spi.enable();
-            self.spi.start_transfer();
-        })
+            self.spi.inner.enable_tx_dma();
+            self.spi.start_transaction();
+        })?;
+        Ok(())
     }
 
     pub fn is_dma_complete(&self) -> Result<bool, Error> {
@@ -142,35 +156,34 @@ where
 
     pub fn end_transfer(&mut self) {
         self.spi.end_transaction();
-        self.spi.disable_dma();
+        self.spi.inner.disable_dma();
     }
 
-    pub fn free(self) -> Result<(CH, S), Error> {
+    pub fn free(self) -> Result<(Channel<CH>, S), Error> {
         let (ch, s, _) = self.transfer.free()?;
         Ok((ch, s))
     }
 }
 
-pub struct DuplexDmaTransfer<'a, SPI, W: FrameSize, TX, RX, S, D> {
+pub struct DuplexDmaTransfer<'a, SPI, W: Word, TX, RX, S, D> {
     spi: &'a mut Spi<SPI, W>,
     tx_transfer: DmaTransfer<TX, S, DmaTx<SPI, W>, MemoryToPeripheral>,
     rx_transfer: DmaTransfer<RX, DmaRx<SPI, W>, D, PeripheralToMemory>,
-    len: usize,
 }
 
 impl<'a, SPI, W, RX, TX, S, D> DuplexDmaTransfer<'a, SPI, W, TX, RX, S, D>
 where
     SPI: Instance,
-    W: FrameSize + Word,
-    TX: Channel,
-    RX: Channel,
+    W: Word + DmaWord,
+    TX: ChannelRegs,
+    RX: ChannelRegs,
     S: ReadBuffer<Word = W>,
     D: WriteBuffer<Word = W>,
 {
     pub fn new(
         spi: &'a mut Spi<SPI, W>,
-        tx_channel: TX,
-        rx_channel: RX,
+        tx_channel: Channel<TX>,
+        rx_channel: Channel<RX>,
         source: S,
         mut destination: D,
     ) -> Self {
@@ -192,11 +205,11 @@ where
             rx_source,
             destination,
         );
+        spi.inner.set_transfer_word_count(dest_len as u16);
         Self {
             spi,
             tx_transfer,
             rx_transfer,
-            len: dest_len,
         }
     }
 
@@ -209,12 +222,12 @@ where
     }
 
     pub fn start(&mut self) -> Result<(), Error> {
-        self.spi.enable_rx_dma();
-        self.rx_transfer.start_nb();
-        self.tx_transfer.start_nb();
-        self.spi.enable_tx_dma();
-        self.spi
-            .setup_transaction(NonZeroUsize::new(self.len).unwrap())?;
+        self.spi.check_transfer_mode()?;
+        self.spi.inner.enable_rx_dma();
+        self.rx_transfer.start_nonblocking();
+        self.tx_transfer.start_nonblocking();
+        self.spi.inner.enable_tx_dma();
+        self.spi.start_transaction();
         Ok(())
     }
 
@@ -228,13 +241,13 @@ where
         self.tx_transfer.wait_for_transfer_complete()?;
         self.rx_transfer.wait_for_transfer_complete()?;
         self.spi.end_transaction();
-        self.spi.disable_dma();
+        self.spi.inner.disable_dma();
         Ok(())
     }
 
     pub fn end_transfer(&mut self) {
         self.spi.end_transaction();
-        self.spi.disable_dma();
+        self.spi.inner.disable_dma();
     }
 
     pub fn abort(&mut self) -> Result<(), Error> {
@@ -244,7 +257,7 @@ where
         Ok(())
     }
 
-    pub fn free(mut self) -> Result<(TX, RX, S, D), Error> {
+    pub fn free(mut self) -> Result<(Channel<TX>, Channel<RX>, S, D), Error> {
         self.end_transfer();
         let (tx, s, _) = self.tx_transfer.free()?;
         let (rx, _, d) = self.rx_transfer.free()?;