framesize

Author: burrbull

src/spi.rs

@@ -132,10 +132,10 @@ impl Ms for Master {
 }
 
 #[derive(Debug)]
-pub struct Spi<SPI, PINS, const BIDI: bool = false, OPERATION = Master> {
+pub struct Spi<SPI, PINS, const BIDI: bool = false, FrameSize = u8, OPERATION = Master> {
     spi: SPI,
     pins: PINS,
-    _operation: PhantomData<OPERATION>,
+    _operation: PhantomData<(FrameSize, OPERATION)>,
 }
 
 // Implemented by all SPI instances
@@ -149,8 +149,8 @@ pub trait Instance:
 // Implemented by all SPI instances
 macro_rules! spi {
     ($SPI:ty: $Spi:ident) => {
-        pub type $Spi<PINS, const BIDI: bool = false, OPERATION = Master> =
-            Spi<$SPI, PINS, BIDI, OPERATION>;
+        pub type $Spi<PINS, const BIDI: bool = false, FrameSize = u8, OPERATION = Master> =
+            Spi<$SPI, PINS, BIDI, FrameSize, OPERATION>;
 
         impl Instance for $SPI {
             fn ptr() -> *const spi1::RegisterBlock {
@@ -281,30 +281,58 @@ impl<SPI: Instance, PINS, const BIDI: bool, OPERATION: Ms> Spi<SPI, PINS, BIDI,
     }
 }
 
-impl<SPI: Instance, PINS, OPERATION: Ms> Spi<SPI, PINS, false, OPERATION> {
+impl<SPI: Instance, PINS, FrameSize, OPERATION: Ms> Spi<SPI, PINS, false, OPERATION> {
     pub fn to_bidi_transfer_mode(self) -> Spi<SPI, PINS, true, OPERATION> {
         self.into_mode()
     }
 }
 
-impl<SPI: Instance, PINS, OPERATION: Ms> Spi<SPI, PINS, true, OPERATION> {
+impl<SPI: Instance, PINS, FrameSize, OPERATION: Ms> Spi<SPI, PINS, true, OPERATION> {
     pub fn to_normal_transfer_mode(self) -> Spi<SPI, PINS, false, OPERATION> {
         self.into_mode()
     }
 }
 
-impl<SPI: Instance, PINS, const BIDI: bool> Spi<SPI, PINS, BIDI, Master> {
+impl<SPI: Instance, PINS, const BIDI: bool, FrameSize> Spi<SPI, PINS, BIDI, FrameSize, Master> {
     pub fn to_slave_operation(self) -> Spi<SPI, PINS, BIDI, Slave> {
         self.into_mode()
     }
 }
 
-impl<SPI: Instance, PINS, const BIDI: bool> Spi<SPI, PINS, BIDI, Slave> {
+impl<SPI: Instance, PINS, const BIDI: bool, FrameSize> Spi<SPI, PINS, BIDI, FrameSize, Slave> {
     pub fn to_master_operation(self) -> Spi<SPI, PINS, BIDI, Master> {
         self.into_mode()
     }
 }
 
+impl<SPI, REMAP, PINS, const BIDI: bool, OPERATION> Spi<SPI, REMAP, PINS, u8, OPERATION>
+where
+    SPI: Instance,
+{
+    /// Converts from 8bit dataframe to 16bit.
+    pub fn frame_size_16bit(self) -> Spi<SPI, REMAP, PINS, u16> {
+        self.spi.cr1.modify(|_, w| w.spe().clear_bit());
+        self.spi
+            .cr1
+            .modify(|_, w| w.dff().set_bit().spe().set_bit());
+        Spi::_new(spi, pins)
+    }
+}
+
+impl<SPI, REMAP, PINS, const BIDI: bool, OPERATION> Spi<SPI, REMAP, PINS, u16, OPERATION>
+where
+    SPI: Instance,
+{
+    /// Converts from 16bit dataframe to 8bit.
+    pub fn frame_size_8bit(self) -> Spi<SPI, REMAP, PINS, u8> {
+        self.spi.cr1.modify(|_, w| w.spe().clear_bit());
+        self.spi
+            .cr1
+            .modify(|_, w| w.dff().clear_bit().spe().set_bit());
+        Spi::_new(spi, pins)
+    }
+}
+
 impl<SPI: Instance, SCK, MISO, MOSI> Spi<SPI, (SCK, MISO, MOSI), false, Master> {
     pub fn new(
         spi: SPI,
@@ -556,7 +584,7 @@ impl<SPI: Instance, PINS, const BIDI: bool, OPERATION> Spi<SPI, PINS, BIDI, OPER
     }
 
     #[inline(always)]
-    fn check_read(&mut self) -> nb::Result<u8, Error> {
+    fn check_read(&mut self) -> nb::Result<FrameSize, Error> {
         let sr = self.spi.sr.read();
 
         Err(if sr.ovr().bit_is_set() {
@@ -566,14 +594,14 @@ impl<SPI: Instance, PINS, const BIDI: bool, OPERATION> Spi<SPI, PINS, BIDI, OPER
         } else if sr.crcerr().bit_is_set() {
             Error::Crc.into()
         } else if sr.rxne().bit_is_set() {
-            return Ok(self.read_u8());
+            return Ok(self.read_data_reg());
         } else {
             nb::Error::WouldBlock
         })
     }
 
     #[inline(always)]
-    fn check_send(&mut self, byte: u8) -> nb::Result<(), Error> {
+    fn check_send(&mut self, byte: FrameSize) -> nb::Result<(), Error> {
         let sr = self.spi.sr.read();
 
         Err(if sr.ovr().bit_is_set() {
@@ -592,23 +620,34 @@ impl<SPI: Instance, PINS, const BIDI: bool, OPERATION> Spi<SPI, PINS, BIDI, OPER
             });
             Error::Crc.into()
         } else if sr.txe().bit_is_set() {
-            self.send_u8(byte);
+            self.write_data_reg(byte);
             return Ok(());
         } else {
             nb::Error::WouldBlock
         })
     }
+}
 
-    #[inline(always)]
-    fn read_u8(&mut self) -> u8 {
-        // NOTE(read_volatile) read only 1 byte (the svd2rust API only allows reading a half-word)
-        unsafe { ptr::read_volatile(&self.spi.dr as *const _ as *const u8) }
+pub trait ReadWriteReg<T> {
+    fn read_data_reg(&mut self) -> T;
+    fn write_data_reg(&mut self, data: T);
+}
+
+impl<SPI, REMAP, PINS, const BIDI: bool, OPERATION, FrameSize> SpiReadWrite<FrameSize>
+    for Spi<SPI, REMAP, PINS, FrameSize, OPERATION>
+where
+    SPI: Instance,
+    FrameSize: Copy,
+{
+    fn read_data_reg(&mut self) -> FrameSize {
+        // NOTE(read_volatile) read only 1 byte (the svd2rust API only allows
+        // reading a half-word)
+        unsafe { ptr::read_volatile(&self.spi.dr as *const _ as *const FrameSize) }
     }
 
-    #[inline(always)]
-    fn send_u8(&mut self, byte: u8) {
+    fn write_data_reg(&mut self, data: FrameSize) {
         // NOTE(write_volatile) see note above
-        unsafe { ptr::write_volatile(&self.spi.dr as *const _ as *mut u8, byte) }
+        unsafe { ptr::write_volatile(&self.spi.dr as *const _ as *mut FrameSize, data) }
     }
 }