spi: update to use DmaChannel generic

astapleton · astapleton · commit f31e9c1ff0bc · 2025-08-01T13:13:36.000-07:00
diff --git a/src/spi/dma.rs b/src/spi/dma.rs
@@ -13,7 +13,7 @@ use futures_util::task::AtomicWaker;
 use crate::gpdma::{
     config::DmaConfig,
     periph::{DmaDuplex, DmaRx, DmaTx, Rx, RxAddr, Tx, TxAddr},
-    ChannelRegs, DmaChannel, DmaTransfer, Error as DmaError, Word as DmaWord,
+    DmaChannel, DmaTransfer, Error as DmaError, Word as DmaWord,
 };
 
 use super::{Error, Instance, Spi, Word};
@@ -37,43 +37,43 @@ where
 {
     pub fn use_dma_tx<CH>(
         self,
-        channel: DmaChannel<CH>,
-    ) -> SpiDma<SPI, W, DmaTx<SPI, W, CH>>
+        channel: CH,
+    ) -> SpiDma<SPI, DmaTx<SPI, W, CH>, W>
     where
-        CH: ChannelRegs,
+        CH: DmaChannel,
     {
         SpiDma::new_simplex_transmitter(self, channel)
     }
 
     pub fn use_dma_rx<CH>(
         self,
-        channel: DmaChannel<CH>,
-    ) -> SpiDma<SPI, W, DmaRx<SPI, W, CH>>
+        channel: CH,
+    ) -> SpiDma<SPI, DmaRx<SPI, W, CH>, W>
     where
-        CH: ChannelRegs,
+        CH: DmaChannel,
     {
         SpiDma::new_simplex_receiver(self, channel)
     }
 
     pub fn use_dma_duplex<TX, RX>(
         self,
-        tx_channel: DmaChannel<TX>,
-        rx_channel: DmaChannel<RX>,
-    ) -> SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>
+        tx_channel: TX,
+        rx_channel: RX,
+    ) -> SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>
     where
-        TX: ChannelRegs,
-        RX: ChannelRegs,
+        TX: DmaChannel,
+        RX: DmaChannel,
     {
         SpiDma::new_duplex(self, tx_channel, rx_channel)
     }
 }
 
-pub struct SpiDma<SPI, W: Word, MODE> {
+pub struct SpiDma<SPI, MODE, W: Word = u8> {
     spi: Spi<SPI, W>,
     mode: MODE,
 }
 
-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word,
@@ -115,75 +115,69 @@ where
     }
 }
 
-impl<SPI, W, CH> SpiDma<SPI, W, DmaTx<SPI, W, CH>>
+impl<SPI, CH, W> SpiDma<SPI, DmaTx<SPI, W, CH>, W>
 where
     SPI: Instance,
     W: Word,
-    CH: ChannelRegs,
+    CH: DmaChannel,
 {
-    pub fn new_simplex_transmitter(
-        spi: Spi<SPI, W>,
-        channel: DmaChannel<CH>,
-    ) -> Self {
+    pub fn new_simplex_transmitter(spi: Spi<SPI, W>, channel: CH) -> Self {
         Self {
             spi,
             mode: DmaTx::from(channel),
         }
     }
 
-    pub fn free(self) -> (Spi<SPI, W>, DmaChannel<CH>) {
+    pub fn free(self) -> (Spi<SPI, W>, CH) {
         let spi = self.spi;
-        let channel = self.mode.into();
+        let channel = self.mode.free();
         (spi, channel)
     }
 }
 
-impl<SPI, W, CH> SpiDma<SPI, W, DmaRx<SPI, W, CH>>
+impl<SPI, CH, W> SpiDma<SPI, DmaRx<SPI, W, CH>, W>
 where
     SPI: Instance,
     W: Word,
-    CH: ChannelRegs,
+    CH: DmaChannel,
 {
-    pub fn new_simplex_receiver(
-        spi: Spi<SPI, W>,
-        channel: DmaChannel<CH>,
-    ) -> Self {
+    pub fn new_simplex_receiver(spi: Spi<SPI, W>, channel: CH) -> Self {
         Self {
             spi,
             mode: DmaRx::from(channel),
         }
     }
 
-    pub fn free(self) -> (Spi<SPI, W>, DmaChannel<CH>) {
-        (self.spi, self.mode.into())
+    pub fn free(self) -> (Spi<SPI, W>, CH) {
+        (self.spi, self.mode.free())
     }
 }
 
-impl<SPI, W, TX, RX> SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>
+impl<SPI, TX, RX, W> SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>
 where
     SPI: Instance + TxAddr<W> + RxAddr<W>,
     W: Word + DmaWord,
-    TX: ChannelRegs,
-    RX: ChannelRegs,
+    TX: DmaChannel,
+    RX: DmaChannel,
 {
     pub fn new_duplex(
         spi: Spi<SPI, W>,
-        tx_channel: DmaChannel<TX>,
-        rx_channel: DmaChannel<RX>,
+        tx_channel: TX,
+        rx_channel: RX,
     ) -> Self {
         Self {
             spi,
             mode: DmaDuplex::new(tx_channel, rx_channel),
         }
     }
 
-    pub fn free(self) -> (Spi<SPI, W>, DmaChannel<TX>, DmaChannel<RX>) {
+    pub fn free(self) -> (Spi<SPI, W>, TX, RX) {
         let (tx, rx) = self.mode.free();
         (self.spi, tx, rx)
     }
 }
 
-impl<SPI, W, MODE> Deref for SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> Deref for SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word,
@@ -195,7 +189,7 @@ where
     }
 }
 
-impl<SPI, W, MODE> DerefMut for SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> DerefMut for SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word,
@@ -205,7 +199,7 @@ where
     }
 }
 
-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
@@ -214,7 +208,7 @@ where
     pub fn start_dma_read<'a>(
         &'a mut self,
         words: &'a mut [W],
-    ) -> Result<DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>, Error>
+    ) -> Result<DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>, Error>
     {
         let config = DmaConfig::new().with_request(SPI::rx_dma_request());
 
@@ -240,7 +234,7 @@ where
     }
 }
 
-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
@@ -249,7 +243,7 @@ where
     pub fn start_dma_write<'a>(
         &'a mut self,
         words: &'a [W],
-    ) -> Result<DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>, Error>
+    ) -> Result<DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>, Error>
     {
         let config = DmaConfig::new().with_request(SPI::tx_dma_request());
 
@@ -274,7 +268,7 @@ where
     }
 }
 
-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
@@ -286,8 +280,8 @@ where
         write: &'a [W],
     ) -> Result<
         (
-            DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>,
-            DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>,
+            DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>,
+            DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>,
         ),
         Error,
     > {
@@ -335,19 +329,19 @@ where
     }
 }
 
-impl<SPI, W, MODE> ErrorType for SpiDma<SPI, W, MODE>
+impl<SPI, MODE, W> ErrorType for SpiDma<SPI, MODE, W>
 where
     SPI: Instance,
     W: Word,
 {
     type Error = Error;
 }
 
-impl<SPI, W, CH> SpiBus<W> for SpiDma<SPI, W, DmaTx<SPI, W, CH>>
+impl<SPI, CH, W> SpiBus<W> for SpiDma<SPI, DmaTx<SPI, W, CH>, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
-    CH: ChannelRegs,
+    CH: DmaChannel,
 {
     async fn read(&mut self, _words: &mut [W]) -> Result<(), Self::Error> {
         unimplemented!("Not supported for simplex transmitter")
@@ -378,11 +372,11 @@ where
     }
 }
 
-impl<SPI, W, CH> SpiBus<W> for SpiDma<SPI, W, DmaRx<SPI, W, CH>>
+impl<SPI, CH, W> SpiBus<W> for SpiDma<SPI, DmaRx<SPI, W, CH>, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
-    CH: ChannelRegs,
+    CH: DmaChannel,
 {
     async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
         self.read_dma(words).await
@@ -413,12 +407,12 @@ where
     }
 }
 
-impl<SPI, W, TX, RX> SpiBus<W> for SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>
+impl<SPI, TX, RX, W> SpiBus<W> for SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>
 where
     SPI: Instance,
     W: Word + DmaWord,
-    TX: ChannelRegs,
-    RX: ChannelRegs,
+    TX: DmaChannel,
+    RX: DmaChannel,
 {
     async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
         self.read_dma(words).await
@@ -449,23 +443,23 @@ where
     }
 }
 
-struct SpiDmaFuture<'a, SPI: Instance, W: Word, MODE> {
-    spi: &'a mut SpiDma<SPI, W, MODE>,
+struct SpiDmaFuture<'a, SPI: Instance, MODE, W: Word> {
+    spi: &'a mut SpiDma<SPI, MODE, W>,
     waker: AtomicWaker,
 }
 
-impl<'a, SPI: Instance, W: Word, MODE> SpiDmaFuture<'a, SPI, W, MODE> {
-    fn new(spi: &'a mut SpiDma<SPI, W, MODE>) -> Self {
+impl<'a, SPI: Instance, MODE, W: Word> SpiDmaFuture<'a, SPI, MODE, W> {
+    fn new(spi: &'a mut SpiDma<SPI, MODE, W>) -> Self {
         Self {
             spi,
             waker: AtomicWaker::new(),
         }
     }
 }
 
-impl<SPI: Instance, W: Word, MODE> Unpin for SpiDmaFuture<'_, SPI, W, MODE> {}
+impl<SPI: Instance, MODE, W: Word> Unpin for SpiDmaFuture<'_, SPI, MODE, W> {}
 
-impl<SPI: Instance, W: Word, MODE> Drop for SpiDmaFuture<'_, SPI, W, MODE> {
+impl<SPI: Instance, MODE, W: Word> Drop for SpiDmaFuture<'_, SPI, MODE, W> {
     fn drop(&mut self) {
         if !self.spi.is_transaction_complete() {
             self.spi.abort_transaction();
@@ -477,7 +471,7 @@ impl<SPI: Instance, W: Word, MODE> Drop for SpiDmaFuture<'_, SPI, W, MODE> {
     }
 }
 
-impl<SPI: Instance, W: Word, MODE> Future for SpiDmaFuture<'_, SPI, W, MODE> {
+impl<SPI: Instance, MODE, W: Word> Future for SpiDmaFuture<'_, SPI, MODE, W> {
     type Output = Result<(), Error>;
 
     fn poll(

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ use futures_util::task::AtomicWaker;`
`13`	`13`	`use crate::gpdma::{`
`14`	`14`	`config::DmaConfig,`
`15`	`15`	`periph::{DmaDuplex, DmaRx, DmaTx, Rx, RxAddr, Tx, TxAddr},`
`16`		`- ChannelRegs, DmaChannel, DmaTransfer, Error as DmaError, Word as DmaWord,`
	`16`	`+ DmaChannel, DmaTransfer, Error as DmaError, Word as DmaWord,`
`17`	`17`	`};`
`18`	`18`
`19`	`19`	`use super::{Error, Instance, Spi, Word};`
`@@ -37,43 +37,43 @@ where`
`37`	`37`	`{`
`38`	`38`	`pub fn use_dma_tx<CH>(`
`39`	`39`	`self,`
`40`		`- channel: DmaChannel<CH>,`
`41`		`- ) -> SpiDma<SPI, W, DmaTx<SPI, W, CH>>`
	`40`	`+ channel: CH,`
	`41`	`+ ) -> SpiDma<SPI, DmaTx<SPI, W, CH>, W>`
`42`	`42`	`where`
`43`		`- CH: ChannelRegs,`
	`43`	`+ CH: DmaChannel,`
`44`	`44`	`{`
`45`	`45`	`SpiDma::new_simplex_transmitter(self, channel)`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`pub fn use_dma_rx<CH>(`
`49`	`49`	`self,`
`50`		`- channel: DmaChannel<CH>,`
`51`		`- ) -> SpiDma<SPI, W, DmaRx<SPI, W, CH>>`
	`50`	`+ channel: CH,`
	`51`	`+ ) -> SpiDma<SPI, DmaRx<SPI, W, CH>, W>`
`52`	`52`	`where`
`53`		`- CH: ChannelRegs,`
	`53`	`+ CH: DmaChannel,`
`54`	`54`	`{`
`55`	`55`	`SpiDma::new_simplex_receiver(self, channel)`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`pub fn use_dma_duplex<TX, RX>(`
`59`	`59`	`self,`
`60`		`- tx_channel: DmaChannel<TX>,`
`61`		`- rx_channel: DmaChannel<RX>,`
`62`		`- ) -> SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>`
	`60`	`+ tx_channel: TX,`
	`61`	`+ rx_channel: RX,`
	`62`	`+ ) -> SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>`
`63`	`63`	`where`
`64`		`- TX: ChannelRegs,`
`65`		`- RX: ChannelRegs,`
	`64`	`+ TX: DmaChannel,`
	`65`	`+ RX: DmaChannel,`
`66`	`66`	`{`
`67`	`67`	`SpiDma::new_duplex(self, tx_channel, rx_channel)`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-pub struct SpiDma<SPI, W: Word, MODE> {`
	`71`	`+pub struct SpiDma<SPI, MODE, W: Word = u8> {`
`72`	`72`	`spi: Spi<SPI, W>,`
`73`	`73`	`mode: MODE,`
`74`	`74`	`}`
`75`	`75`
`76`		`-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>`
	`76`	`+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>`
`77`	`77`	`where`
`78`	`78`	`SPI: Instance,`
`79`	`79`	`W: Word,`
`@@ -115,75 +115,69 @@ where`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`-impl<SPI, W, CH> SpiDma<SPI, W, DmaTx<SPI, W, CH>>`
	`118`	`+impl<SPI, CH, W> SpiDma<SPI, DmaTx<SPI, W, CH>, W>`
`119`	`119`	`where`
`120`	`120`	`SPI: Instance,`
`121`	`121`	`W: Word,`
`122`		`- CH: ChannelRegs,`
	`122`	`+ CH: DmaChannel,`
`123`	`123`	`{`
`124`		`- pub fn new_simplex_transmitter(`
`125`		`- spi: Spi<SPI, W>,`
`126`		`- channel: DmaChannel<CH>,`
`127`		`- ) -> Self {`
	`124`	`+ pub fn new_simplex_transmitter(spi: Spi<SPI, W>, channel: CH) -> Self {`
`128`	`125`	`Self {`
`129`	`126`	`spi,`
`130`	`127`	`mode: DmaTx::from(channel),`
`131`	`128`	`}`
`132`	`129`	`}`
`133`	`130`
`134`		`- pub fn free(self) -> (Spi<SPI, W>, DmaChannel<CH>) {`
	`131`	`+ pub fn free(self) -> (Spi<SPI, W>, CH) {`
`135`	`132`	`let spi = self.spi;`
`136`		`- let channel = self.mode.into();`
	`133`	`+ let channel = self.mode.free();`
`137`	`134`	`(spi, channel)`
`138`	`135`	`}`
`139`	`136`	`}`
`140`	`137`
`141`		`-impl<SPI, W, CH> SpiDma<SPI, W, DmaRx<SPI, W, CH>>`
	`138`	`+impl<SPI, CH, W> SpiDma<SPI, DmaRx<SPI, W, CH>, W>`
`142`	`139`	`where`
`143`	`140`	`SPI: Instance,`
`144`	`141`	`W: Word,`
`145`		`- CH: ChannelRegs,`
	`142`	`+ CH: DmaChannel,`
`146`	`143`	`{`
`147`		`- pub fn new_simplex_receiver(`
`148`		`- spi: Spi<SPI, W>,`
`149`		`- channel: DmaChannel<CH>,`
`150`		`- ) -> Self {`
	`144`	`+ pub fn new_simplex_receiver(spi: Spi<SPI, W>, channel: CH) -> Self {`
`151`	`145`	`Self {`
`152`	`146`	`spi,`
`153`	`147`	`mode: DmaRx::from(channel),`
`154`	`148`	`}`
`155`	`149`	`}`
`156`	`150`
`157`		`- pub fn free(self) -> (Spi<SPI, W>, DmaChannel<CH>) {`
`158`		`- (self.spi, self.mode.into())`
	`151`	`+ pub fn free(self) -> (Spi<SPI, W>, CH) {`
	`152`	`+ (self.spi, self.mode.free())`
`159`	`153`	`}`
`160`	`154`	`}`
`161`	`155`
`162`		`-impl<SPI, W, TX, RX> SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>`
	`156`	`+impl<SPI, TX, RX, W> SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>`
`163`	`157`	`where`
`164`	`158`	`SPI: Instance + TxAddr<W> + RxAddr<W>,`
`165`	`159`	`W: Word + DmaWord,`
`166`		`- TX: ChannelRegs,`
`167`		`- RX: ChannelRegs,`
	`160`	`+ TX: DmaChannel,`
	`161`	`+ RX: DmaChannel,`
`168`	`162`	`{`
`169`	`163`	`pub fn new_duplex(`
`170`	`164`	`spi: Spi<SPI, W>,`
`171`		`- tx_channel: DmaChannel<TX>,`
`172`		`- rx_channel: DmaChannel<RX>,`
	`165`	`+ tx_channel: TX,`
	`166`	`+ rx_channel: RX,`
`173`	`167`	`) -> Self {`
`174`	`168`	`Self {`
`175`	`169`	`spi,`
`176`	`170`	`mode: DmaDuplex::new(tx_channel, rx_channel),`
`177`	`171`	`}`
`178`	`172`	`}`
`179`	`173`
`180`		`- pub fn free(self) -> (Spi<SPI, W>, DmaChannel<TX>, DmaChannel<RX>) {`
	`174`	`+ pub fn free(self) -> (Spi<SPI, W>, TX, RX) {`
`181`	`175`	`let (tx, rx) = self.mode.free();`
`182`	`176`	`(self.spi, tx, rx)`
`183`	`177`	`}`
`184`	`178`	`}`
`185`	`179`
`186`		`-impl<SPI, W, MODE> Deref for SpiDma<SPI, W, MODE>`
	`180`	`+impl<SPI, MODE, W> Deref for SpiDma<SPI, MODE, W>`
`187`	`181`	`where`
`188`	`182`	`SPI: Instance,`
`189`	`183`	`W: Word,`
`@@ -195,7 +189,7 @@ where`
`195`	`189`	`}`
`196`	`190`	`}`
`197`	`191`
`198`		`-impl<SPI, W, MODE> DerefMut for SpiDma<SPI, W, MODE>`
	`192`	`+impl<SPI, MODE, W> DerefMut for SpiDma<SPI, MODE, W>`
`199`	`193`	`where`
`200`	`194`	`SPI: Instance,`
`201`	`195`	`W: Word,`
`@@ -205,7 +199,7 @@ where`
`205`	`199`	`}`
`206`	`200`	`}`
`207`	`201`
`208`		`-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>`
	`202`	`+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>`
`209`	`203`	`where`
`210`	`204`	`SPI: Instance,`
`211`	`205`	`W: Word + DmaWord,`
`@@ -214,7 +208,7 @@ where`
`214`	`208`	`pub fn start_dma_read<'a>(`
`215`	`209`	`&'a mut self,`
`216`	`210`	`words: &'a mut [W],`
`217`		`- ) -> Result<DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>, Error>`
	`211`	`+ ) -> Result<DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>, Error>`
`218`	`212`	`{`
`219`	`213`	`let config = DmaConfig::new().with_request(SPI::rx_dma_request());`
`220`	`214`
`@@ -240,7 +234,7 @@ where`
`240`	`234`	`}`
`241`	`235`	`}`
`242`	`236`
`243`		`-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>`
	`237`	`+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>`
`244`	`238`	`where`
`245`	`239`	`SPI: Instance,`
`246`	`240`	`W: Word + DmaWord,`
`@@ -249,7 +243,7 @@ where`
`249`	`243`	`pub fn start_dma_write<'a>(`
`250`	`244`	`&'a mut self,`
`251`	`245`	`words: &'a [W],`
`252`		`- ) -> Result<DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>, Error>`
	`246`	`+ ) -> Result<DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>, Error>`
`253`	`247`	`{`
`254`	`248`	`let config = DmaConfig::new().with_request(SPI::tx_dma_request());`
`255`	`249`
`@@ -274,7 +268,7 @@ where`
`274`	`268`	`}`
`275`	`269`	`}`
`276`	`270`
`277`		`-impl<SPI, W, MODE> SpiDma<SPI, W, MODE>`
	`271`	`+impl<SPI, MODE, W> SpiDma<SPI, MODE, W>`
`278`	`272`	`where`
`279`	`273`	`SPI: Instance,`
`280`	`274`	`W: Word + DmaWord,`
`@@ -286,8 +280,8 @@ where`
`286`	`280`	`write: &'a [W],`
`287`	`281`	`) -> Result<`
`288`	`282`	`(`
`289`		`- DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>,`
`290`		`- DmaTransfer<'a, impl ChannelRegs + use<'a, SPI, W, MODE>>,`
	`283`	`+ DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>,`
	`284`	`+ DmaTransfer<'a, impl DmaChannel + use<'a, SPI, W, MODE>>,`
`291`	`285`	`),`
`292`	`286`	`Error,`
`293`	`287`	`> {`
`@@ -335,19 +329,19 @@ where`
`335`	`329`	`}`
`336`	`330`	`}`
`337`	`331`
`338`		`-impl<SPI, W, MODE> ErrorType for SpiDma<SPI, W, MODE>`
	`332`	`+impl<SPI, MODE, W> ErrorType for SpiDma<SPI, MODE, W>`
`339`	`333`	`where`
`340`	`334`	`SPI: Instance,`
`341`	`335`	`W: Word,`
`342`	`336`	`{`
`343`	`337`	`type Error = Error;`
`344`	`338`	`}`
`345`	`339`
`346`		`-impl<SPI, W, CH> SpiBus<W> for SpiDma<SPI, W, DmaTx<SPI, W, CH>>`
	`340`	`+impl<SPI, CH, W> SpiBus<W> for SpiDma<SPI, DmaTx<SPI, W, CH>, W>`
`347`	`341`	`where`
`348`	`342`	`SPI: Instance,`
`349`	`343`	`W: Word + DmaWord,`
`350`		`- CH: ChannelRegs,`
	`344`	`+ CH: DmaChannel,`
`351`	`345`	`{`
`352`	`346`	`async fn read(&mut self, _words: &mut [W]) -> Result<(), Self::Error> {`
`353`	`347`	`unimplemented!("Not supported for simplex transmitter")`
`@@ -378,11 +372,11 @@ where`
`378`	`372`	`}`
`379`	`373`	`}`
`380`	`374`
`381`		`-impl<SPI, W, CH> SpiBus<W> for SpiDma<SPI, W, DmaRx<SPI, W, CH>>`
	`375`	`+impl<SPI, CH, W> SpiBus<W> for SpiDma<SPI, DmaRx<SPI, W, CH>, W>`
`382`	`376`	`where`
`383`	`377`	`SPI: Instance,`
`384`	`378`	`W: Word + DmaWord,`
`385`		`- CH: ChannelRegs,`
	`379`	`+ CH: DmaChannel,`
`386`	`380`	`{`
`387`	`381`	`async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {`
`388`	`382`	`self.read_dma(words).await`
`@@ -413,12 +407,12 @@ where`
`413`	`407`	`}`
`414`	`408`	`}`
`415`	`409`
`416`		`-impl<SPI, W, TX, RX> SpiBus<W> for SpiDma<SPI, W, DmaDuplex<SPI, W, TX, RX>>`
	`410`	`+impl<SPI, TX, RX, W> SpiBus<W> for SpiDma<SPI, DmaDuplex<SPI, W, TX, RX>, W>`
`417`	`411`	`where`
`418`	`412`	`SPI: Instance,`
`419`	`413`	`W: Word + DmaWord,`
`420`		`- TX: ChannelRegs,`
`421`		`- RX: ChannelRegs,`
	`414`	`+ TX: DmaChannel,`
	`415`	`+ RX: DmaChannel,`
`422`	`416`	`{`
`423`	`417`	`async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {`
`424`	`418`	`self.read_dma(words).await`
`@@ -449,23 +443,23 @@ where`
`449`	`443`	`}`
`450`	`444`	`}`
`451`	`445`
`452`		`-struct SpiDmaFuture<'a, SPI: Instance, W: Word, MODE> {`
`453`		`- spi: &'a mut SpiDma<SPI, W, MODE>,`
	`446`	`+struct SpiDmaFuture<'a, SPI: Instance, MODE, W: Word> {`
	`447`	`+ spi: &'a mut SpiDma<SPI, MODE, W>,`
`454`	`448`	`waker: AtomicWaker,`
`455`	`449`	`}`
`456`	`450`
`457`		`-impl<'a, SPI: Instance, W: Word, MODE> SpiDmaFuture<'a, SPI, W, MODE> {`
`458`		`- fn new(spi: &'a mut SpiDma<SPI, W, MODE>) -> Self {`
	`451`	`+impl<'a, SPI: Instance, MODE, W: Word> SpiDmaFuture<'a, SPI, MODE, W> {`
	`452`	`+ fn new(spi: &'a mut SpiDma<SPI, MODE, W>) -> Self {`
`459`	`453`	`Self {`
`460`	`454`	`spi,`
`461`	`455`	`waker: AtomicWaker::new(),`
`462`	`456`	`}`
`463`	`457`	`}`
`464`	`458`	`}`
`465`	`459`
`466`		`-impl<SPI: Instance, W: Word, MODE> Unpin for SpiDmaFuture<'_, SPI, W, MODE> {}`
	`460`	`+impl<SPI: Instance, MODE, W: Word> Unpin for SpiDmaFuture<'_, SPI, MODE, W> {}`
`467`	`461`
`468`		`-impl<SPI: Instance, W: Word, MODE> Drop for SpiDmaFuture<'_, SPI, W, MODE> {`
	`462`	`+impl<SPI: Instance, MODE, W: Word> Drop for SpiDmaFuture<'_, SPI, MODE, W> {`
`469`	`463`	`fn drop(&mut self) {`
`470`	`464`	`if !self.spi.is_transaction_complete() {`
`471`	`465`	`self.spi.abort_transaction();`
`@@ -477,7 +471,7 @@ impl<SPI: Instance, W: Word, MODE> Drop for SpiDmaFuture<'_, SPI, W, MODE> {`
`477`	`471`	`}`
`478`	`472`	`}`
`479`	`473`
`480`		`-impl<SPI: Instance, W: Word, MODE> Future for SpiDmaFuture<'_, SPI, W, MODE> {`
	`474`	`+impl<SPI: Instance, MODE, W: Word> Future for SpiDmaFuture<'_, SPI, MODE, W> {`
`481`	`475`	`type Output = Result<(), Error>;`
`482`	`476`
`483`	`477`	`fn poll(`