Use the Spi driver in SpiDma

Author: bugadani

esp-hal/src/spi/master/dma.rs

@@ -67,7 +67,7 @@ impl<'d> Spi<'d, Blocking> {
     /// ```
     #[instability::unstable]
     pub fn with_dma(self, channel: impl DmaChannelFor<AnySpi<'d>>) -> SpiDma<'d, Blocking> {
-        SpiDma::new(self.spi, channel.degrade())
+        SpiDma::new(self, channel.degrade())
     }
 }
 
@@ -115,7 +115,7 @@ pub struct SpiDma<'d, Dm>
 where
     Dm: DriverMode,
 {
-    spi: SpiWrapper<'d>,
+    spi: Spi<'d, Dm>,
     pub(crate) channel: Channel<Dm, PeripheralDmaChannel<AnySpi<'d>>>,
     #[cfg(all(esp32, spi_address_workaround))]
     address_buffer: DmaTxBuf,
@@ -127,16 +127,21 @@ impl<'d> SpiDma<'d, Blocking> {
     /// Converts the SPI instance into async mode.
     #[instability::unstable]
     pub fn into_async(mut self) -> SpiDma<'d, Async> {
-        self.set_interrupt_handler(self.spi.info().async_handler);
+        self.set_interrupt_handler(self.spi().info().async_handler);
         SpiDma {
-            spi: self.spi,
+            spi: self.spi.into_async(),
             channel: self.channel.into_async(),
             #[cfg(all(esp32, spi_address_workaround))]
             address_buffer: self.address_buffer,
         }
     }
 
-    pub(super) fn new(spi: SpiWrapper<'d>, channel: PeripheralDmaChannel<AnySpi<'d>>) -> Self {
+    pub(super) fn new(
+        spi_driver: Spi<'d, Blocking>,
+        channel: PeripheralDmaChannel<AnySpi<'d>>,
+    ) -> Self {
+        let spi = &spi_driver.spi;
+
         let channel = Channel::new(channel);
         channel.runtime_ensure_compatible(&spi.spi);
         #[cfg(all(esp32, spi_address_workaround))]
@@ -159,13 +164,13 @@ impl<'d> SpiDma<'d, Blocking> {
             ))
         };
 
-        let (_info, state) = spi.dma_parts();
+        let (_info, state) = spi.spi.dma_parts();
 
         state.tx_transfer_in_progress.set(false);
         state.rx_transfer_in_progress.set(false);
 
         Self {
-            spi,
+            spi: spi_driver,
             channel,
             #[cfg(all(esp32, spi_address_workaround))]
             address_buffer,
@@ -225,9 +230,9 @@ impl<'d> SpiDma<'d, Async> {
     /// Converts the SPI instance into async mode.
     #[instability::unstable]
     pub fn into_blocking(self) -> SpiDma<'d, Blocking> {
-        self.spi.disable_peri_interrupt_on_all_cores();
+        self.spi().disable_peri_interrupt_on_all_cores();
         SpiDma {
-            spi: self.spi,
+            spi: self.spi.into_blocking(),
             channel: self.channel.into_blocking(),
             #[cfg(all(esp32, spi_address_workaround))]
             address_buffer: self.address_buffer,
@@ -288,7 +293,7 @@ impl<'d> SpiDma<'d, Async> {
 
 impl<Dm> core::fmt::Debug for SpiDma<'_, Dm>
 where
-    Dm: DriverMode,
+    Dm: DriverMode + core::fmt::Debug,
 {
     /// Formats the `SpiDma` instance for debugging purposes.
     ///
@@ -313,19 +318,19 @@ impl<Dm> SpiDma<'_, Dm>
 where
     Dm: DriverMode,
 {
+    fn spi(&self) -> &SpiWrapper<'_> {
+        &self.spi.spi
+    }
+
     fn driver(&self) -> Driver {
-        Driver {
-            info: self.spi.info(),
-            state: self.spi.state(),
-        }
+        self.spi.driver()
     }
 
     fn dma_driver(&self) -> DmaDriver {
-        let (_info, state) = self.spi.dma_parts();
         DmaDriver {
             driver: self.driver(),
-            dma_peripheral: self.spi.dma_peripheral(),
-            state,
+            dma_peripheral: self.spi().dma_peripheral(),
+            state: self.spi().dma_state(),
         }
     }
 
@@ -439,12 +444,6 @@ where
     }
 
     fn cancel_transfer(&mut self) {
-        // The SPI peripheral is controlling how much data we transfer, so let's
-        // update its counter.
-        // 0 doesn't take effect on ESP32 and cuts the currently transmitted byte
-        // immediately.
-        // 1 seems to stop after transmitting the current byte which is somewhat less
-        // impolite.
         let state = self.dma_driver().state;
         if state.tx_transfer_in_progress.get() || state.rx_transfer_in_progress.get() {
             self.dma_driver().abort_transfer();
@@ -1244,6 +1243,12 @@ pub(super) struct DmaDriver {
 
 impl DmaDriver {
     fn abort_transfer(&self) {
+        // The SPI peripheral is controlling how much data we transfer, so let's
+        // update its counter.
+        // 0 doesn't take effect on ESP32 and cuts the currently transmitted byte
+        // immediately.
+        // 1 seems to stop after transmitting the current byte which is somewhat less
+        // impolite.
         self.driver.configure_datalen(1, 1);
         self.driver.update();
     }
@@ -1520,14 +1525,25 @@ for_each_spi_master!(
                     )*
                 }
             }
+
+            #[inline(always)]
+            fn dma_state(&self) -> &'static State {
+                let (_, state) = self.dma_parts();
+                state
+            }
+
+            #[inline(always)]
+            fn dma_info(&self) -> &'static Info {
+                let (info, _) = self.dma_parts();
+                info
+            }
         }
     };
 );
 
 impl SpiWrapper<'_> {
-    #[inline(always)]
-    fn dma_parts(&self) -> (&'static Info, &'static State) {
-        self.spi.dma_parts()
+    fn dma_state(&self) -> &'static State {
+        self.spi.dma_state()
     }
 
     #[inline(always)]