Feature-gate async-await

Author: datdenkikniet

Cargo.toml

@@ -29,18 +29,19 @@ ieee802_3_miim = "0.8"
 cortex-m = "0.7"
 log = { version = "0.4", optional = true }
 defmt = { version = "0.3", optional = true }
-futures = { version = "0.3", default-features = false, features = ["async-await"] }
+futures = { version = "0.3", default-features = false, features = ["async-await"], optional = true }
 
 [dependencies.smoltcp]
 version = "0.9"
 default-features = false
 optional = true
 
 [features]
-default = [ "defmt", "ptp" ]
+default = [ "defmt", "ptp", "async-await" ]
 device-selected = []
 fence = []
 ptp = [ ]
+async-await = ["dep:futures"]
 
 stm32f107 = ["stm32f1xx-hal/stm32f107", "device-selected"]
 

src/dma/mod.rs

@@ -1,9 +1,6 @@
 //! Ethernet DMA access and configuration.
 
-use core::task::Poll;
-
 use cortex_m::peripheral::NVIC;
-use futures::task::AtomicWaker;
 
 use crate::{peripherals::ETHERNET_DMA, stm32::Interrupt};
 
@@ -12,6 +9,12 @@ mod smoltcp_phy;
 #[cfg(feature = "smoltcp-phy")]
 pub use smoltcp_phy::*;
 
+#[cfg(feature = "async-await")]
+use futures::task::AtomicWaker;
+
+#[cfg(feature = "ptp")]
+use core::task::Poll;
+
 pub(crate) mod desc;
 
 pub(crate) mod ring;
@@ -115,8 +118,8 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
 
         let mut dma = EthernetDMA {
             eth_dma,
-            rx_ring: RxRing::new(rx_buffer, EthernetDMA::rx_waker()),
-            tx_ring: TxRing::new(tx_buffer, EthernetDMA::tx_waker()),
+            rx_ring: RxRing::new(rx_buffer),
+            tx_ring: TxRing::new(tx_buffer),
         };
 
         dma.rx_ring.start(&dma.eth_dma);
@@ -125,11 +128,13 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         dma
     }
 
+    #[cfg(feature = "async-await")]
     pub(crate) fn rx_waker() -> &'static AtomicWaker {
         static WAKER: AtomicWaker = AtomicWaker::new();
         &WAKER
     }
 
+    #[cfg(feature = "async-await")]
     pub(crate) fn tx_waker() -> &'static AtomicWaker {
         static WAKER: AtomicWaker = AtomicWaker::new();
         &WAKER
@@ -144,8 +149,8 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     /// Enable RX and TX interrupts
     ///
     /// In your handler you must call
-    /// [`EthernetDMA::interrupt_handler()`] to
-    /// clear interrupt pending bits. Otherwise the interrupt will
+    /// [`EthernetDMA::interrupt_handler()`] or [`stm32_eth::eth_interrupt_handler`](crate::eth_interrupt_handler)
+    /// to clear interrupt pending bits. Otherwise the interrupt will
     /// reoccur immediately.
     pub fn enable_interrupt(&self) {
         self.eth_dma.dmaier.modify(|_, w| {
@@ -184,12 +189,15 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
             .dmasr
             .write(|w| w.nis().set_bit().ts().set_bit().rs().set_bit());
 
-        if status.is_tx {
-            EthernetDMA::tx_waker().wake();
-        }
+        #[cfg(feature = "async-await")]
+        {
+            if status.is_tx {
+                EthernetDMA::tx_waker().wake();
+            }
 
-        if status.is_rx {
-            EthernetDMA::rx_waker().wake();
+            if status.is_rx {
+                EthernetDMA::rx_waker().wake();
+            }
         }
 
         status
@@ -205,6 +213,7 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     }
 
     /// Receive a packet.
+    #[cfg(feature = "async-await")]
     pub async fn recv(&mut self) -> RxPacket {
         self.rx_ring.recv().await
     }

src/dma/rx/descriptor.rs

@@ -3,8 +3,10 @@ use crate::dma::{
     ring::{RingDescriptor, RingEntry},
 };
 
+use crate::dma::PacketId;
+
 #[cfg(feature = "ptp")]
-use crate::{dma::PacketId, ptp::Timestamp};
+use crate::ptp::Timestamp;
 
 /// Errors that can occur during RX
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -17,6 +19,8 @@ pub(crate) enum RxDescriptorError {
 }
 
 /// RX timestamp valid
+/// NOTE(allow): unused if not(feature = "ptp")
+#[allow(unused)]
 const RXDESC_0_TIMESTAMP_VALID: u32 = 1 << 7;
 /// Owned by DMA engine
 const RXDESC_0_OWN: u32 = 1 << 31;
@@ -76,8 +80,6 @@ impl RxDescriptor {
     ///
     /// Overrides old timestamp data
     pub fn set_owned(&mut self) {
-        self.cached_timestamp = self.timestamp();
-
         self.write_buffer1();
         self.write_buffer2();
 

src/dma/rx/mod.rs

@@ -1,19 +1,18 @@
-use core::task::Poll;
-
-use futures::task::AtomicWaker;
-
 pub(crate) use self::descriptor::RxDescriptor;
 
 use self::descriptor::RxDescriptorError;
 pub use self::descriptor::RxRingEntry;
 
-use super::{PacketId, PacketIdNotFound};
+use super::PacketId;
 use crate::peripherals::ETHERNET_DMA;
 
 mod descriptor;
 
 #[cfg(feature = "ptp")]
-use crate::ptp::Timestamp;
+use crate::{dma::PacketIdNotFound, ptp::Timestamp};
+
+#[cfg(feature = "async-await")]
+use core::task::Poll;
 
 /// Errors that can occur during RX
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -40,16 +39,14 @@ impl From<RxDescriptorError> for RxError {
 pub struct RxRing<'a> {
     entries: &'a mut [RxRingEntry],
     next_entry: usize,
-    waker: &'static AtomicWaker,
 }
 
 impl<'a> RxRing<'a> {
     /// Allocate
-    pub fn new(entries: &'a mut [RxRingEntry], waker: &'static AtomicWaker) -> Self {
+    pub fn new(entries: &'a mut [RxRingEntry]) -> Self {
         RxRing {
             entries,
             next_entry: 0,
-            waker,
         }
     }
 
@@ -165,14 +162,15 @@ impl<'a> RxRing<'a> {
     ///
     /// The returned [`RxPacket`] can be used as a slice, and
     /// will contain the ethernet data.
+    #[cfg(feature = "async-await")]
     pub async fn recv(&mut self) -> RxPacket {
         let (entry_num, length) = core::future::poll_fn(|ctx| {
             let res = self.recv_next_impl(None);
 
             match res {
                 Ok(value) => Poll::Ready(value),
                 Err(_) => {
-                    self.waker.register(ctx.waker());
+                    crate::dma::EthernetDMA::rx_waker().register(ctx.waker());
                     Poll::Pending
                 }
             }

src/dma/tx/mod.rs

@@ -6,12 +6,9 @@ use super::{PacketIdNotFound, Timestamp};
 
 mod descriptor;
 pub use descriptor::{TxDescriptor, TxRingEntry};
-use futures::task::AtomicWaker;
 
-use core::{
-    sync::atomic::{self, Ordering},
-    task::Poll,
-};
+#[cfg(any(feature = "ptp", feature = "async-await"))]
+use core::task::Poll;
 
 /// Errors that can occur during Ethernet TX
 #[derive(Debug, PartialEq)]
@@ -24,18 +21,16 @@ pub enum TxError {
 pub struct TxRing<'a> {
     pub(crate) entries: &'a mut [TxRingEntry],
     next_entry: usize,
-    waker: &'static AtomicWaker,
 }
 
 impl<'ring> TxRing<'ring> {
     /// Allocate
     ///
     /// `start()` will be needed before `send()`
-    pub fn new(entries: &'ring mut [TxRingEntry], waker: &'static AtomicWaker) -> Self {
+    pub fn new(entries: &'ring mut [TxRingEntry]) -> Self {
         TxRing {
             entries,
             next_entry: 0,
-            waker,
         }
     }
 
@@ -64,7 +59,7 @@ impl<'ring> TxRing<'ring> {
 
         // "Preceding reads and writes cannot be moved past subsequent writes."
         #[cfg(feature = "fence")]
-        atomic::fence(Ordering::Release);
+        core::sync::atomic::fence(core::sync::atomic::Ordering::Release);
 
         // We don't need a compiler fence here because all interactions with `Descriptor` are
         // volatiles
@@ -130,6 +125,7 @@ impl<'ring> TxRing<'ring> {
     ///
     /// When all data is copied into the TX buffer, use [`TxPacket::send()`]
     /// to transmit it.
+    #[cfg(feature = "async-await")]
     pub async fn prepare_packet<'borrow>(
         &'borrow mut self,
         length: usize,
@@ -138,7 +134,7 @@ impl<'ring> TxRing<'ring> {
         let entry = core::future::poll_fn(|ctx| match self.send_next_impl() {
             Ok(packet) => Poll::Ready(packet),
             Err(_) => {
-                self.waker.register(ctx.waker());
+                crate::dma::EthernetDMA::tx_waker().register(ctx.waker());
                 Poll::Pending
             }
         })
@@ -155,10 +151,6 @@ impl<'ring> TxRing<'ring> {
         }
     }
 
-    pub(crate) fn entry_available(&self, index: usize) -> bool {
-        self.entries[index].is_available()
-    }
-
     /// Demand that the DMA engine polls the current `TxDescriptor`
     /// (when we just transferred ownership to the hardware).
     pub fn demand_poll(&self) {
@@ -217,6 +209,10 @@ impl TxRing<'_> {
         )
     }
 
+    pub(crate) fn entry_available(&self, index: usize) -> bool {
+        self.entries[index].is_available()
+    }
+
     fn entry_timestamp(&self, index: usize) -> Option<Timestamp> {
         self.entries[index].timestamp()
     }

src/mac/mod.rs

@@ -210,6 +210,7 @@ impl EthernetMAC {
         }
     }
 
+    #[cfg(feature = "ptp")]
     pub(crate) fn mask_timestamp_trigger_interrupt() {
         // SAFETY: MACIMR only receives atomic writes.
         let mac = &unsafe { &*ETHERNET_MAC::ptr() };

src/peripherals.rs

@@ -322,6 +322,13 @@ mod pac_override_impl {
     impl ETHERNET_PTP {
         #[doc = r"Pointer to the register block"]
         pub const PTR: *const PtpRegisterBlock = 0x4002_8700 as *const _;
+
+        #[doc = r"Return the pointer to the register block"]
+        #[inline(always)]
+        #[allow(unused)]
+        pub const fn ptr() -> *const PtpRegisterBlock {
+            Self::PTR
+        }
     }
 
     impl core::ops::Deref for ETHERNET_PTP {

src/ptp/mod.rs

@@ -2,14 +2,14 @@
 //!
 //! See [`EthernetPTP`] for a more details.
 
-use core::task::Poll;
-
 use crate::{dma::EthernetDMA, hal::rcc::Clocks, mac::EthernetMAC, peripherals::ETHERNET_PTP};
 
 mod timestamp;
-use futures::task::AtomicWaker;
 pub use timestamp::Timestamp;
 
+#[cfg(feature = "async-await")]
+use {core::task::Poll, futures::task::AtomicWaker};
+
 mod subseconds;
 pub use subseconds::{Subseconds, NANOS_PER_SECOND, SUBSECONDS_PER_SECOND, SUBSECONDS_TO_SECONDS};
 
@@ -68,11 +68,6 @@ impl EthernetPTP {
         (stssi, tsa)
     }
 
-    fn waker() -> &'static AtomicWaker {
-        static WAKER: AtomicWaker = AtomicWaker::new();
-        &WAKER
-    }
-
     pub(crate) fn new(
         eth_ptp: ETHERNET_PTP,
         clocks: Clocks,
@@ -225,6 +220,12 @@ impl EthernetPTP {
 /// clear the flag as the register required to do so does not exist.
 #[cfg(not(feature = "stm32f1xx-hal"))]
 impl EthernetPTP {
+    #[cfg(feature = "async-await")]
+    fn waker() -> &'static AtomicWaker {
+        static WAKER: AtomicWaker = AtomicWaker::new();
+        &WAKER
+    }
+
     /// Configure the target time.
     fn set_target_time(&mut self, timestamp: Timestamp) {
         let (high, low) = (timestamp.seconds(), timestamp.subseconds_signed());
@@ -247,6 +248,7 @@ impl EthernetPTP {
     }
 
     /// Wait until the specified time.
+    #[cfg(feature = "async-await")]
     pub async fn wait_until(&mut self, timestamp: Timestamp) {
         self.configure_target_time_interrupt(timestamp);
         core::future::poll_fn(|ctx| {
@@ -274,6 +276,7 @@ impl EthernetPTP {
             EthernetMAC::mask_timestamp_trigger_interrupt();
         }
 
+        #[cfg(feature = "async-await")]
         EthernetPTP::waker().wake();
 
         is_tsint