gpdma: make wakers accessible from DmaChannelImpl

Author: astapleton

src/gpdma.rs

@@ -102,6 +102,7 @@ use config::{
     PeripheralSource, PeripheralToMemory, PeripheralToPeripheral,
     PeripheralToPeripheralDirection, TransferDirection, TransferType,
 };
+use future::InstanceWaker;
 
 /// Supported word types for the STM32H5 GPDMA implementation.
 ///
@@ -146,7 +147,10 @@ impl<DMA: Instance> GpdmaExt<DMA> for DMA {
     }
 }
 
-pub trait Instance: Sealed + Deref<Target = gpdma1::RegisterBlock> {
+#[allow(private_bounds)]
+pub trait Instance:
+    Sealed + InstanceWaker + Deref<Target = gpdma1::RegisterBlock>
+{
     type Rec: ResetEnable;
 
     fn ptr() -> *const gpdma1::RegisterBlock;

src/gpdma/ch.rs

@@ -1,5 +1,7 @@
 use core::{marker::PhantomData, ops::Deref};
 
+use futures_util::task::AtomicWaker;
+
 use crate::stm32::gpdma1::{
     self,
     ch::{CR, DAR, FCR, LBAR, SAR, SR, TR1, TR2},
@@ -12,6 +14,7 @@ use super::{
         AddressingMode, AhbPort, HardwareRequest, PeripheralRequest,
         PeripheralSource, Priority, TransferDirection, TransferType,
     },
+    future::ChannelWaker,
     DmaConfig, Error, Instance, Word,
 };
 
@@ -536,6 +539,8 @@ pub(super) trait Channel {
     /// Disable transfer interrupts for the channel. It is expected that this will be called from
     /// an interrupt handler after a transfer is completed.
     fn disable_transfer_interrupts(&self);
+
+    fn waker(&self) -> &'static AtomicWaker;
 }
 
 impl<DMA, CH, const N: usize> Channel for DmaChannelRef<DMA, CH, N>
@@ -739,6 +744,10 @@ where
             w.tcie().disabled().dteie().disabled().useie().disabled()
         });
     }
+
+    fn waker(&self) -> &'static AtomicWaker {
+        self.ch.waker()
+    }
 }
 
 /// DmaChannel trait provides the API contract that all GPDMA channels exposed to the user

src/gpdma/future.rs

@@ -20,10 +20,10 @@ use super::{
 };
 
 #[allow(private_bounds)]
-impl<'a, CH: DmaChannel + ChannelWaker> IntoFuture for DmaTransfer<'a, CH> {
+impl<'a, CH: DmaChannel> IntoFuture for DmaTransfer<'a, CH> {
     type Output = Result<(), Error>;
     type IntoFuture = DmaTransferFuture<'a, CH>;
-    
+
     fn into_future(self) -> DmaTransferFuture<'a, CH> {
         DmaTransferFuture { transfer: self }
     }
@@ -73,7 +73,7 @@ impl<'a, CH: DmaChannel> Unpin for DmaTransferFuture<'a, CH> {}
 
 impl<'a, CH> Future for DmaTransferFuture<'a, CH>
 where
-    CH: DmaChannel + ChannelWaker,
+    CH: DmaChannel,
 {
     type Output = Result<(), Error>;
 
@@ -92,7 +92,6 @@ impl<DMA, CH, const N: usize> DmaChannelImpl<DmaChannelRef<DMA, CH, N>>
 where
     DMA: Instance,
     CH: ChannelRegs,
-    Self: ChannelWaker,
     DmaChannelRef<DMA, CH, N>: ChannelRegs,
 {
     #[inline(always)]
@@ -114,21 +113,36 @@ macro_rules! gpdma_irq {
     };
 }
 
-trait ChannelWaker {
+pub(super) trait InstanceWaker {
+    fn waker(idx: usize) -> &'static AtomicWaker;
+}
+
+pub(super) trait ChannelWaker {
+    /// Returns a reference to the AtomicWaker for the channel.
     fn waker(&self) -> &'static AtomicWaker;
 }
 
+impl<DMA, CH, const N: usize> ChannelWaker for DmaChannelRef<DMA, CH, N>
+where
+    DMA: Instance,
+    CH: ChannelRegs,
+{
+    #[inline(always)]
+    fn waker(&self) -> &'static AtomicWaker {
+        DMA::waker(N)
+    }
+}
+
 mod gpdma1 {
     use super::*;
 
     static WAKERS_GPDMA1: [AtomicWaker; 8] = [const { AtomicWaker::new() }; 8];
 
     #[allow(private_bounds)]
-    impl<CH: ChannelRegs, const N: usize> ChannelWaker
-        for DmaChannelImpl<DmaChannelRef<GPDMA1, CH, N>>
-    {
-        fn waker(&self) -> &'static AtomicWaker {
-            &WAKERS_GPDMA1[N]
+    impl InstanceWaker for GPDMA1 {
+        #[inline(always)]
+        fn waker(idx: usize) -> &'static AtomicWaker {
+            &WAKERS_GPDMA1[idx]
         }
     }
 
@@ -148,11 +162,10 @@ mod gpdma2 {
     static WAKERS_GPDMA2: [AtomicWaker; 8] = [const { AtomicWaker::new() }; 8];
 
     #[allow(private_bounds)]
-    impl<CH: ChannelRegs, const N: usize> ChannelWaker
-        for DmaChannelImpl<DmaChannelRef<GPDMA2, CH, N>>
-    {
-        fn waker(&self) -> &'static AtomicWaker {
-            &WAKERS_GPDMA2[N]
+    impl InstanceWaker for GPDMA2 {
+        #[inline(always)]
+        fn waker(idx: usize) -> &'static AtomicWaker {
+            &WAKERS_GPDMA2[idx]
         }
     }