Erase DMA type params

Author: bugadani

esp-hal/src/aes/mod.rs

@@ -241,7 +241,6 @@ pub mod dma {
             ChannelRx,
             ChannelTx,
             DescriptorChain,
-            DmaChannel,
             DmaDescriptor,
             DmaPeripheral,
             DmaTransferRxTx,
@@ -272,14 +271,11 @@ pub mod dma {
     }
 
     /// A DMA capable AES instance.
-    pub struct AesDma<'d, C = AnyDmaChannel>
-    where
-        C: DmaChannel,
-    {
+    pub struct AesDma<'d> {
         /// The underlying [`Aes`](super::Aes) driver
         pub aes: super::Aes<'d>,
 
-        pub(crate) channel: Channel<'d, C, crate::Blocking>,
+        channel: Channel<'d, AnyDmaChannel, crate::Blocking>,
         rx_chain: DescriptorChain,
         tx_chain: DescriptorChain,
     }
@@ -296,43 +292,23 @@ pub mod dma {
             Self: Sized,
             C: PeripheralDmaChannel,
             C::P: AesPeripheral,
-        {
-            self.with_dma_typed(channel.degrade(), rx_descriptors, tx_descriptors)
-        }
-
-        /// Enable DMA for the current instance of the AES driver
-        pub fn with_dma_typed<C>(
-            self,
-            channel: Channel<'d, C, crate::Blocking>,
-            rx_descriptors: &'static mut [DmaDescriptor],
-            tx_descriptors: &'static mut [DmaDescriptor],
-        ) -> AesDma<'d, C>
-        where
-            C: PeripheralDmaChannel,
-            C::P: AesPeripheral,
         {
             AesDma {
                 aes: self,
-                channel,
+                channel: channel.degrade(),
                 rx_chain: DescriptorChain::new(rx_descriptors),
                 tx_chain: DescriptorChain::new(tx_descriptors),
             }
         }
     }
 
-    impl<'d, C> core::fmt::Debug for AesDma<'d, C>
-    where
-        C: DmaChannel,
-    {
+    impl<'d> core::fmt::Debug for AesDma<'d> {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("AesDma").finish()
         }
     }
 
-    impl<'d, C> DmaSupport for AesDma<'d, C>
-    where
-        C: DmaChannel,
-    {
+    impl<'d> DmaSupport for AesDma<'d> {
         fn peripheral_wait_dma(&mut self, _is_rx: bool, _is_tx: bool) {
             while self.aes.aes.state().read().state().bits() != 2 // DMA status DONE == 2
             && !self.channel.tx.is_done()
@@ -348,11 +324,8 @@ pub mod dma {
         }
     }
 
-    impl<'d, C> DmaSupportTx for AesDma<'d, C>
-    where
-        C: DmaChannel,
-    {
-        type TX = ChannelTx<'d, C>;
+    impl<'d> DmaSupportTx for AesDma<'d> {
+        type TX = ChannelTx<'d, AnyDmaChannel>;
 
         fn tx(&mut self) -> &mut Self::TX {
             &mut self.channel.tx
@@ -363,11 +336,8 @@ pub mod dma {
         }
     }
 
-    impl<'d, C> DmaSupportRx for AesDma<'d, C>
-    where
-        C: DmaChannel,
-    {
-        type RX = ChannelRx<'d, C>;
+    impl<'d> DmaSupportRx for AesDma<'d> {
+        type RX = ChannelRx<'d, AnyDmaChannel>;
 
         fn rx(&mut self) -> &mut Self::RX {
             &mut self.channel.rx
@@ -378,10 +348,7 @@ pub mod dma {
         }
     }
 
-    impl<'d, C> AesDma<'d, C>
-    where
-        C: DmaChannel,
-    {
+    impl<'d> AesDma<'d> {
         /// Writes the encryption key to the AES hardware, checking that its
         /// length matches expected constraints.
         pub fn write_key<K>(&mut self, key: K)

esp-hal/src/dma/gdma.rs

@@ -709,51 +709,56 @@ pub use m2m::*;
 mod m2m {
     #[cfg(esp32s3)]
     use crate::dma::DmaExtMemBKSize;
-    use crate::dma::{
-        dma_private::{DmaSupport, DmaSupportRx},
-        Channel,
-        ChannelRx,
-        DescriptorChain,
-        DmaChannel,
-        DmaDescriptor,
-        DmaEligible,
-        DmaError,
-        DmaPeripheral,
-        DmaTransferRx,
-        ReadBuffer,
-        Rx,
-        Tx,
-        WriteBuffer,
+    use crate::{
+        dma::{
+            dma_private::{DmaSupport, DmaSupportRx},
+            AnyDmaChannel,
+            Channel,
+            ChannelRx,
+            DescriptorChain,
+            DmaChannel,
+            DmaDescriptor,
+            DmaEligible,
+            DmaError,
+            DmaPeripheral,
+            DmaTransferRx,
+            ReadBuffer,
+            Rx,
+            Tx,
+            WriteBuffer,
+        },
+        Mode,
     };
 
     /// DMA Memory to Memory pseudo-Peripheral
     ///
     /// This is a pseudo-peripheral that allows for memory to memory transfers.
     /// It is not a real peripheral, but a way to use the DMA engine for memory
     /// to memory transfers.
-    pub struct Mem2Mem<'d, C, MODE>
+    pub struct Mem2Mem<'d, M>
     where
-        C: DmaChannel,
-        MODE: crate::Mode,
+        M: Mode,
     {
-        channel: Channel<'d, C, MODE>,
+        channel: Channel<'d, AnyDmaChannel, M>,
         rx_chain: DescriptorChain,
         tx_chain: DescriptorChain,
         peripheral: DmaPeripheral,
     }
 
-    impl<'d, C, MODE> Mem2Mem<'d, C, MODE>
+    impl<'d, M> Mem2Mem<'d, M>
     where
-        C: DmaChannel,
-        MODE: crate::Mode,
+        M: Mode,
     {
         /// Create a new Mem2Mem instance.
-        pub fn new(
-            channel: Channel<'d, C, MODE>,
+        pub fn new<CH>(
+            channel: Channel<'d, CH, M>,
             peripheral: impl DmaEligible,
             rx_descriptors: &'static mut [DmaDescriptor],
             tx_descriptors: &'static mut [DmaDescriptor],
-        ) -> Result<Self, DmaError> {
+        ) -> Result<Self, DmaError>
+        where
+            CH: DmaChannel,
+        {
             unsafe {
                 Self::new_unsafe(
                     channel,
@@ -766,13 +771,16 @@ mod m2m {
         }
 
         /// Create a new Mem2Mem instance with specific chunk size.
-        pub fn new_with_chunk_size(
-            channel: Channel<'d, C, MODE>,
+        pub fn new_with_chunk_size<CH>(
+            channel: Channel<'d, CH, M>,
             peripheral: impl DmaEligible,
             rx_descriptors: &'static mut [DmaDescriptor],
             tx_descriptors: &'static mut [DmaDescriptor],
             chunk_size: usize,
-        ) -> Result<Self, DmaError> {
+        ) -> Result<Self, DmaError>
+        where
+            CH: DmaChannel,
+        {
             unsafe {
                 Self::new_unsafe(
                     channel,
@@ -790,21 +798,24 @@ mod m2m {
         ///
         /// You must ensure that your not using DMA for the same peripheral and
         /// that your the only one using the DmaPeripheral.
-        pub unsafe fn new_unsafe(
-            channel: Channel<'d, C, MODE>,
+        pub unsafe fn new_unsafe<CH>(
+            channel: Channel<'d, CH, M>,
             peripheral: DmaPeripheral,
             rx_descriptors: &'static mut [DmaDescriptor],
             tx_descriptors: &'static mut [DmaDescriptor],
             chunk_size: usize,
-        ) -> Result<Self, DmaError> {
+        ) -> Result<Self, DmaError>
+        where
+            CH: DmaChannel,
+        {
             if !(1..=4092).contains(&chunk_size) {
                 return Err(DmaError::InvalidChunkSize);
             }
             if tx_descriptors.is_empty() || rx_descriptors.is_empty() {
                 return Err(DmaError::OutOfDescriptors);
             }
             Ok(Mem2Mem {
-                channel,
+                channel: channel.degrade(),
                 peripheral,
                 rx_chain: DescriptorChain::new_with_chunk_size(rx_descriptors, chunk_size),
                 tx_chain: DescriptorChain::new_with_chunk_size(tx_descriptors, chunk_size),
@@ -855,10 +866,9 @@ mod m2m {
         }
     }
 
-    impl<'d, C, MODE> DmaSupport for Mem2Mem<'d, C, MODE>
+    impl<'d, MODE> DmaSupport for Mem2Mem<'d, MODE>
     where
-        C: DmaChannel,
-        MODE: crate::Mode,
+        MODE: Mode,
     {
         fn peripheral_wait_dma(&mut self, _is_rx: bool, _is_tx: bool) {
             while !self.channel.rx.is_done() {}
@@ -869,12 +879,11 @@ mod m2m {
         }
     }
 
-    impl<'d, C, MODE> DmaSupportRx for Mem2Mem<'d, C, MODE>
+    impl<'d, MODE> DmaSupportRx for Mem2Mem<'d, MODE>
     where
-        C: DmaChannel,
-        MODE: crate::Mode,
+        MODE: Mode,
     {
-        type RX = ChannelRx<'d, C>;
+        type RX = ChannelRx<'d, AnyDmaChannel>;
 
         fn rx(&mut self) -> &mut Self::RX {
             &mut self.channel.rx

esp-hal/src/dma/pdma.rs

@@ -915,7 +915,7 @@ macro_rules! ImplI2sChannel {
                 }
 
                 fn set_isr(handler: InterruptHandler) {
-                    let interrupt = $crate::peripherals::Interrupt::[< I2S $num  >];
+                    let interrupt = $crate::peripherals::Interrupt::[< I2S $num >];
                     unsafe {
                         crate::interrupt::bind_interrupt(interrupt, handler.handler());
                     }