Properly feature gate all async fns

Add prepare-transmission async fn as well

Author: datdenkikniet

src/dma/mod.rs

@@ -212,12 +212,6 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         self.rx_ring.recv_next(packet_id.map(Into::into))
     }
 
-    /// Receive a packet.
-    #[cfg(feature = "async-await")]
-    pub async fn recv(&mut self, packet_id: Option<PacketId>) -> RxPacket {
-        self.rx_ring.recv(packet_id).await
-    }
-
     /// Is Rx DMA currently running?
     ///
     /// It stops if the ring is full. Call [`EthernetDMA::recv_next()`] to free an
@@ -265,6 +259,26 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     pub fn tx_available(&mut self) -> bool {
         self.tx_ring.next_entry_available()
     }
+
+    /// Receive a packet.
+    ///
+    /// See [`RxRing::recv`].
+    #[cfg(feature = "async-await")]
+    pub async fn recv(&mut self, packet_id: Option<PacketId>) -> RxPacket {
+        self.rx_ring.recv(packet_id).await
+    }
+
+    /// Prepare a packet for sending.
+    ///
+    /// See [`TxRing::prepare_packet`].
+    #[cfg(feature = "async-await")]
+    pub async fn prepare_packet<'borrow>(
+        &'borrow mut self,
+        length: usize,
+        packet_id: Option<PacketId>,
+    ) -> TxPacket<'borrow, 'tx> {
+        self.tx_ring.prepare_packet(length, packet_id).await
+    }
 }
 
 #[cfg(feature = "ptp")]
@@ -315,6 +329,7 @@ impl EthernetDMA<'_, '_> {
     }
 
     /// Get the TX timestamp for the given ID.
+    #[cfg(feature = "async-await")]
     pub async fn tx_timestamp(
         &mut self,
         packet_id: &PacketId,

src/dma/rx/mod.rs

@@ -164,7 +164,7 @@ impl<'a> RxRing<'a> {
     /// will contain the ethernet data.
     #[cfg(feature = "async-await")]
     pub async fn recv(&mut self, packet_id: Option<PacketId>) -> RxPacket {
-        let (entry_num, length) = core::future::poll_fn(|ctx| {
+        let (entry, length) = core::future::poll_fn(|ctx| {
             let res = self.recv_next_impl(packet_id.clone());
 
             match res {
@@ -178,7 +178,7 @@ impl<'a> RxRing<'a> {
         .await;
 
         RxPacket {
-            entry: &mut self.entries[entry_num],
+            entry: &mut self.entries[entry],
             length,
         }
     }

src/dma/tx/mod.rs

@@ -250,23 +250,17 @@ impl TxRing<'_> {
     }
 
     /// Wait until the timestamp for the given ID is available.
+    #[cfg(feature = "async-await")]
     pub async fn timestamp(
         &mut self,
         packet_id: &PacketId,
     ) -> Result<Option<Timestamp>, PacketIdNotFound> {
         core::future::poll_fn(move |ctx| {
-            let entry = if let Some(entry) = self.entry_for_id(packet_id) {
-                entry
-            } else {
-                return Poll::Ready(Err(PacketIdNotFound));
-            };
-
-            if self.entry_available(entry) {
-                Poll::Ready(Ok(self.entry_timestamp(entry)))
-            } else {
-                ctx.waker().wake_by_ref();
-                Poll::Pending
+            let res = self.poll_timestamp(packet_id);
+            if res.is_pending() {
+                crate::dma::EthernetDMA::tx_waker().register(ctx.waker());
             }
+            res
         })
         .await
     }