optimized Spi::write

Author: burrbull

CHANGELOG.md

@@ -195,6 +195,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
  - Add missing timer pins [#536]
  - Revised temperature sensor input pins for all MCUs [#529]
+ - Optimized version of blocking SPI write
  - Support `u16` read/write for SPI
  - Use `bool` for BIDI mode type
  - `PwmHz::get_period`: fix computation of return value, prevent division by zero

src/spi.rs

@@ -726,6 +726,19 @@ impl<SPI: Instance> Inner<SPI> {
         self.spi.sr.read().ovr().bit_is_set()
     }
 
+    fn check_errors(&self) -> Result<(), Error> {
+        let sr = self.spi.sr.read();
+        if sr.ovr().bit_is_set() {
+            Err(Error::Overrun)
+        } else if sr.modf().bit_is_set() {
+            Err(Error::ModeFault)
+        } else if sr.crcerr().bit_is_set() {
+            Err(Error::Crc)
+        } else {
+            Ok(())
+        }
+    }
+
     #[inline]
     fn bidi_output(&mut self) {
         self.spi.cr1.modify(|_, w| w.bidioe().set_bit());
@@ -787,6 +800,39 @@ impl<SPI: Instance> Inner<SPI> {
             nb::Error::WouldBlock
         })
     }
+
+    // Implement write as per the "Transmit only procedure"
+    // RM SPI::3.5. This is more than twice as fast as the
+    // default Write<> implementation (which reads and drops each
+    // received value)
+    fn spi_write<const BIDI: bool, W: FrameSize>(&mut self, words: impl IntoIterator<Item = W>) -> Result<(), Error> {
+        if BIDI {
+            self.bidi_output();
+        }
+        // Write each word when the tx buffer is empty
+        for word in words {
+            loop {
+                let sr = self.spi.sr.read();
+                if sr.txe().bit_is_set() {
+                    self.write_data_reg(word);
+                    if sr.modf().bit_is_set() {
+                        return Err(Error::ModeFault);
+                    }
+                    break;
+                }
+            }
+        }
+        // Wait for final TXE
+        while !self.is_tx_empty() {}
+        // Wait for final !BSY
+        while self.is_busy() {}
+        if !BIDI {
+            // Clear OVR set due to dropped received values
+            let _: W = self.read_data_reg();
+        }
+        let _ = self.spi.sr.read();
+        self.check_errors()
+    }
 }
 
 // Spi DMA
@@ -907,35 +953,11 @@ impl<SPI: Instance, const BIDI: bool, W: FrameSize> Spi<SPI, BIDI, W> {
     }
 
     pub fn write(&mut self, words: &[W]) -> Result<(), Error> {
-        if BIDI {
-            self.bidi_output();
-            for word in words {
-                nb::block!(self.check_send(*word))?;
-            }
-        } else {
-            for word in words {
-                nb::block!(self.check_send(*word))?;
-                nb::block!(self.check_read::<W>())?;
-            }
-        }
-
-        Ok(())
+        self.spi_write::<BIDI, W>(words.iter().copied())
     }
 
     pub fn write_iter(&mut self, words: impl IntoIterator<Item = W>) -> Result<(), Error> {
-        if BIDI {
-            self.bidi_output();
-            for word in words.into_iter() {
-                nb::block!(self.check_send(word))?;
-            }
-        } else {
-            for word in words.into_iter() {
-                nb::block!(self.check_send(word))?;
-                nb::block!(self.check_read::<W>())?;
-            }
-        }
-
-        Ok(())
+        self.spi_write::<BIDI, W>(words)
     }
 
     pub fn read(&mut self, words: &mut [W]) -> Result<(), Error> {
@@ -995,19 +1017,7 @@ impl<SPI: Instance, const BIDI: bool, W: FrameSize> SpiSlave<SPI, BIDI, W> {
     }
 
     pub fn write(&mut self, words: &[W]) -> Result<(), Error> {
-        if BIDI {
-            self.bidi_output();
-            for word in words {
-                nb::block!(self.check_send(*word))?;
-            }
-        } else {
-            for word in words {
-                nb::block!(self.check_send(*word))?;
-                nb::block!(self.check_read::<W>())?;
-            }
-        }
-
-        Ok(())
+        self.spi_write::<BIDI, W>(words.iter().copied())
     }
 
     pub fn read(&mut self, words: &mut [W]) -> Result<(), Error> {