Update to smoltcp 0.9

We only perform atomic reads/writes for some operations that previously
required a reference to `ETHERNET_DMA`, so we can easily eliminate some lifetimes
that made life a lot harder by simply conjuring that peripheral, inspired
by embassy-net.

Author: datdenkikniet

Cargo.toml

@@ -31,7 +31,7 @@ log = { version = "0.4", optional = true }
 defmt = { version = "0.3", optional = true }
 
 [dependencies.smoltcp]
-version = "0.8.2"
+version = "0.9"
 default-features = false
 optional = true
 
@@ -72,7 +72,7 @@ cortex-m-rtic = "1.0"
 defmt-rtt = "0.4"
 panic-probe = { version = "0.3", features = [ "print-defmt" ] }
 systick-monotonic = "1.0"
-smoltcp = { version = "0.8", features = [ "medium-ethernet", "proto-ipv4", "socket-udp", "socket-tcp", "defmt" ], default-features = false }
+smoltcp = { version = "0.9", features = [ "medium-ethernet", "proto-ipv4", "socket-udp", "socket-tcp", "defmt" ], default-features = false }
 
 [[example]]
 name = "pktgen"

src/dma/mod.rs

@@ -176,38 +176,18 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     /// It stops if the ring is full. Call `recv_next()` to free an
     /// entry and to demand poll from the hardware.
     pub fn rx_is_running(&self) -> bool {
-        self.rx_ring.running_state(&self.eth_dma).is_running()
+        self.rx_ring.running_state().is_running()
     }
 
-    pub(crate) fn recv_next_impl<'rx_borrow>(
-        eth_dma: &ETHERNET_DMA,
-        rx_ring: &'rx_borrow mut RxRing,
-        rx_packet_id: Option<PacketId>,
-    ) -> Result<RxPacket<'rx_borrow>, RxError> {
-        rx_ring.recv_next(eth_dma, rx_packet_id.map(|p| p.into()))
-    }
-
-    /// Receive the next packet (if any is ready), or return `None`
+    /// Receive the next packet (if any is ready), or return [`Err`]
     /// immediately.
     pub fn recv_next(&mut self, packet_id: Option<PacketId>) -> Result<RxPacket, RxError> {
-        Self::recv_next_impl(&self.eth_dma, &mut self.rx_ring, packet_id)
+        self.rx_ring.recv_next(packet_id.map(|p| p.into()))
     }
 
     /// Is Tx DMA currently running?
     pub fn tx_is_running(&self) -> bool {
-        self.tx_ring.is_running(&self.eth_dma)
-    }
-
-    pub(crate) fn send_impl<F: FnOnce(&mut [u8]) -> R, R>(
-        eth_dma: &ETHERNET_DMA,
-        tx_ring: &mut TxRing,
-        length: usize,
-        tx_packet_id: Option<PacketId>,
-        f: F,
-    ) -> Result<R, TxError> {
-        let result = tx_ring.send(length, tx_packet_id.map(|p| p.into()), f);
-        tx_ring.demand_poll(eth_dma);
-        result
+        self.tx_ring.is_running()
     }
 
     /// Send a packet
@@ -217,7 +197,7 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         packet_id: Option<PacketId>,
         f: F,
     ) -> Result<R, TxError> {
-        Self::send_impl(&self.eth_dma, &mut self.tx_ring, length, packet_id, f)
+        self.tx_ring.send(length, packet_id.map(|p| p.into()), f)
     }
 
     #[cfg(feature = "ptp")]
@@ -252,6 +232,22 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     fn collect_timestamps(&mut self) {
         self.tx_ring.collect_timestamps();
     }
+
+    /// Check if there is a packet available for reading.
+    ///
+    /// If this function returns true, it is guaranteed that the
+    /// next call to [`EthernetDMA::recv_next`] will return [`Ok`].
+    pub fn rx_available(&mut self) -> bool {
+        self.rx_ring.next_entry_available()
+    }
+
+    /// Check if sending a packet now would succeed.
+    ///
+    /// If this function returns true, it is guaranteed that
+    /// the next call to [`EthernetDMA::send`] will return [`Ok`]
+    pub fn tx_available(&mut self) -> bool {
+        self.tx_ring.next_entry_available()
+    }
 }
 
 /// A summary of the reasons for the interrupt

src/dma/rx.rs

@@ -352,17 +352,21 @@ impl<'a> RxRing<'a> {
         // Start receive
         eth_dma.dmaomr.modify(|_, w| w.sr().set_bit());
 
-        self.demand_poll(eth_dma);
+        self.demand_poll();
     }
 
     /// Demand that the DMA engine polls the current `RxDescriptor`
-    /// (when in `RunningState::Stopped`.)
-    pub fn demand_poll(&self, eth_dma: &ETHERNET_DMA) {
+    /// (when in [`RunningState::Stopped`].)
+    pub fn demand_poll(&self) {
+        // SAFETY: we only perform an atomic write to `dmarpdr`.
+        let eth_dma = unsafe { &*ETHERNET_DMA::ptr() };
         eth_dma.dmarpdr.write(|w| unsafe { w.rpd().bits(1) });
     }
 
     /// Get current `RunningState`
-    pub fn running_state(&self, eth_dma: &ETHERNET_DMA) -> RunningState {
+    pub fn running_state(&self) -> RunningState {
+        // SAFETY: we only perform an atomic read of `dmasr`.
+        let eth_dma = unsafe { &*ETHERNET_DMA::ptr() };
         match eth_dma.dmasr.read().rps().bits() {
             //  Reset or Stop Receive Command issued
             0b000 => RunningState::Stopped,
@@ -380,16 +384,24 @@ impl<'a> RxRing<'a> {
         }
     }
 
+    /// Check if we can receive a new packet
+    pub fn next_entry_available(&self) -> bool {
+        if !self.running_state().is_running() {
+            self.demand_poll();
+        }
+
+        !self.entries[self.next_entry].desc().is_owned()
+    }
+
     /// Receive the next packet (if any is ready), or return `None`
     /// immediately.
     pub fn recv_next(
         &mut self,
-        eth_dma: &ETHERNET_DMA,
         // NOTE(allow): packet_id is unused if ptp is disabled.
         #[allow(unused_variables)] packet_id: Option<PacketId>,
     ) -> Result<RxPacket, RxError> {
-        if !self.running_state(eth_dma).is_running() {
-            self.demand_poll(eth_dma);
+        if !self.running_state().is_running() {
+            self.demand_poll();
         }
 
         let entries_len = self.entries.len();

src/dma/smoltcp_phy.rs

@@ -1,13 +1,13 @@
-use super::{rx::RxPacket, tx::TxError, EthernetDMA};
-use core::intrinsics::transmute;
+use super::rx::RxRing;
+use super::tx::TxRing;
+use super::EthernetDMA;
 use smoltcp::phy::{ChecksumCapabilities, Device, DeviceCapabilities, RxToken, TxToken};
 use smoltcp::time::Instant;
-use smoltcp::Error;
 
 /// Use this Ethernet driver with [smoltcp](https://github.com/smoltcp-rs/smoltcp)
-impl<'a, 'rx, 'tx, 'b> Device<'a> for &'b mut EthernetDMA<'rx, 'tx> {
-    type RxToken = EthRxToken<'a>;
-    type TxToken = EthTxToken<'a>;
+impl<'a, 'rx, 'tx> Device for &'a mut EthernetDMA<'rx, 'tx> {
+    type RxToken<'token> = EthRxToken<'token, 'rx> where Self: 'token;
+    type TxToken<'token> = EthTxToken<'token, 'tx> where Self: 'token;
 
     fn capabilities(&self) -> DeviceCapabilities {
         let mut caps = DeviceCapabilities::default();
@@ -17,65 +17,63 @@ impl<'a, 'rx, 'tx, 'b> Device<'a> for &'b mut EthernetDMA<'rx, 'tx> {
         caps
     }
 
-    fn receive(&mut self) -> Option<(Self::RxToken, Self::TxToken)> {
-        let self_ = unsafe {
-            // HACK: eliminate lifetimes
-            transmute::<&mut EthernetDMA<'rx, 'tx>, &mut EthernetDMA<'a, 'a>>(*self)
-        };
-        let eth = self_ as *mut EthernetDMA<'a, 'a>;
-        match self_.recv_next(None) {
-            Ok(packet) => {
-                let rx = EthRxToken { packet };
-                let tx = EthTxToken { eth };
-                Some((rx, tx))
-            }
-            Err(_) => None,
+    fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+        if self.tx_available() && self.rx_available() {
+            let EthernetDMA {
+                rx_ring, tx_ring, ..
+            } = self;
+
+            let rx = EthRxToken { rx_ring };
+
+            let tx = EthTxToken { tx_ring };
+            Some((rx, tx))
+        } else {
+            None
         }
     }
 
-    fn transmit(&mut self) -> Option<Self::TxToken> {
-        let eth = unsafe {
-            transmute::<&mut EthernetDMA<'rx, 'tx>, &mut EthernetDMA<'a, 'a>>(*self)
-                as *mut EthernetDMA<'a, 'a>
-        };
-        Some(EthTxToken { eth })
+    fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
+        if self.tx_available() {
+            let EthernetDMA { tx_ring, .. } = self;
+            Some(EthTxToken { tx_ring })
+        } else {
+            None
+        }
     }
 }
 
 /// An Ethernet RX token that can be consumed in order to receive
 /// an ethernet packet.
-pub struct EthRxToken<'a> {
-    packet: RxPacket<'a>,
+pub struct EthRxToken<'a, 'rx> {
+    rx_ring: &'a mut RxRing<'rx>,
 }
 
-impl<'a> RxToken for EthRxToken<'a> {
-    fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> Result<R, Error>
+impl<'dma, 'rx> RxToken for EthRxToken<'dma, 'rx> {
+    fn consume<R, F>(self, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> Result<R, Error>,
+        F: FnOnce(&mut [u8]) -> R,
     {
-        let result = f(&mut self.packet);
-        self.packet.free();
+        // NOTE(unwrap): an `EthRxToken` is only created when `eth.rx_available()`
+        let mut packet = self.rx_ring.recv_next(None).ok().unwrap();
+        let result = f(&mut packet);
+        packet.free();
         result
     }
 }
 
-/// Just a reference to [`Eth`](../struct.EthernetDMA.html) for sending a
-/// packet later with [`consume()`](#method.consume).
-pub struct EthTxToken<'a> {
-    eth: *mut EthernetDMA<'a, 'a>,
+/// Just a reference to [`EthernetDMA`] for sending a
+/// packet later with [`TxToken::consume()`].
+pub struct EthTxToken<'a, 'tx> {
+    tx_ring: &'a mut TxRing<'tx>,
 }
 
-impl<'a> TxToken for EthTxToken<'a> {
-    /// Allocate a [`Buffer`](../struct.Buffer.html), yield with
-    /// `f(buffer)`, and send it as an Ethernet packet.
-    fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> Result<R, Error>
+impl<'dma, 'tx> TxToken for EthTxToken<'dma, 'tx> {
+    fn consume<R, F>(self, len: usize, f: F) -> R
     where
-        F: FnOnce(&mut [u8]) -> Result<R, Error>,
+        F: FnOnce(&mut [u8]) -> R,
     {
-        let eth = unsafe { &mut *self.eth };
-        match eth.send(len, None, f) {
-            Err(TxError::WouldBlock) => Err(Error::Exhausted),
-            Ok(r) => r,
-        }
+        // NOTE(unwrap): an `EthTxToken` is only created if
+        // there is a descriptor available for sending.
+        self.tx_ring.send(len, None, f).ok().unwrap()
     }
 }

src/dma/tx.rs

@@ -355,6 +355,10 @@ impl<'a> TxRing<'a> {
         eth_dma.dmaomr.modify(|_, w| w.st().set_bit());
     }
 
+    pub fn next_entry_available(&self) -> bool {
+        !self.entries[self.next_entry].desc().is_owned()
+    }
+
     pub fn send<F: FnOnce(&mut [u8]) -> R, R>(
         &mut self,
         length: usize,
@@ -373,6 +377,9 @@ impl<'a> TxRing<'a> {
                 if self.next_entry >= entries_len {
                     self.next_entry = 0;
                 }
+
+                self.demand_poll();
+
                 Ok(r)
             }
             None => Err(TxError::WouldBlock),
@@ -381,7 +388,9 @@ impl<'a> TxRing<'a> {
 
     /// Demand that the DMA engine polls the current `TxDescriptor`
     /// (when we just transferred ownership to the hardware).
-    pub fn demand_poll(&self, eth_dma: &ETHERNET_DMA) {
+    pub fn demand_poll(&self) {
+        // SAFETY: we only perform an atomic write to `dmatpdr`
+        let eth_dma = unsafe { &*ETHERNET_DMA::ptr() };
         eth_dma.dmatpdr.write(|w| {
             #[cfg(any(feature = "stm32f4xx-hal", feature = "stm32f7xx-hal"))]
             {
@@ -396,11 +405,14 @@ impl<'a> TxRing<'a> {
     }
 
     /// Is the Tx DMA engine running?
-    pub fn is_running(&self, eth_dma: &ETHERNET_DMA) -> bool {
-        self.running_state(eth_dma).is_running()
+    pub fn is_running(&self) -> bool {
+        self.running_state().is_running()
     }
 
-    fn running_state(&self, eth_dma: &ETHERNET_DMA) -> RunningState {
+    fn running_state(&self) -> RunningState {
+        // SAFETY: we only perform an atomic read of `dmasr`.
+        let eth_dma = unsafe { &*ETHERNET_DMA::ptr() };
+
         match eth_dma.dmasr.read().tps().bits() {
             // Reset or Stop Transmit Command issued
             0b000 => RunningState::Stopped,

src/peripherals.rs

@@ -256,6 +256,10 @@ mod pac_override_impl {
     impl ETHERNET_DMA {
         #[doc = r"Pointer to the register block"]
         pub const PTR: *const DmaRegisterBlock = 0x4002_9000 as *const _;
+
+        pub const fn ptr() -> *const DmaRegisterBlock {
+            Self::PTR
+        }
     }
 
     impl core::ops::Deref for ETHERNET_DMA {