Update to smoltcp 0.9 and incorporate all changes that we added with that

update

Author: datdenkikniet

Cargo.toml

@@ -34,7 +34,7 @@ siphasher = "*"
 paste = { version = "1.0", optional = true }
 
 [dependencies.smoltcp]
-version = "0.8.2"
+version = "0.9"
 default-features = false
 optional = true
 
@@ -83,7 +83,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

@@ -282,44 +282,31 @@ 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()
     }
 
     /// Get the current state of Tx DMA
     pub fn tx_state(&self) -> RunningState {
-        self.tx_ring.running_state(self.eth_dma())
-    }
-
-    fn recv_next_impl<'rx_borrow>(
-        eth_dma: &ETHERNET_DMA,
-        rx_ring: &'rx_borrow mut RxRing<rx::Running>,
-        rx_packet_id: Option<PacketId>,
-    ) -> Result<RxPacket<'rx_borrow>, RxError> {
-        rx_ring.recv_next(eth_dma, rx_packet_id.map(|p| p.into()))
+        self.tx_ring.running_state()
     }
 
     /// Receive the next packet (if any is ready), or return `None`
     /// immediately.
     pub fn recv_next(&mut self, packet_id: Option<PacketId>) -> Result<RxPacket, RxError> {
-        Self::recv_next_impl(&self.parts.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())
+    /// Check whether a frame is available for reception.
+    ///
+    /// If this function returns `true`, the next [`TxRing::recv_next`] is
+    /// guaranteed to succeed.
+    pub fn rx_available(&mut self) -> bool {
+        self.rx_ring.available()
     }
 
-    pub(crate) fn send_impl<F: FnOnce(&mut [u8]) -> R, R>(
-        eth_dma: &ETHERNET_DMA,
-        tx_ring: &mut TxRing<tx::Running>,
-        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
+    /// Is Tx DMA currently running?
+    pub fn tx_is_running(&self) -> bool {
+        self.tx_ring.is_running()
     }
 
     /// Send a packet
@@ -329,7 +316,15 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         packet_id: Option<PacketId>,
         f: F,
     ) -> Result<R, TxError> {
-        Self::send_impl(&self.parts.eth_dma, &mut self.tx_ring, length, packet_id, f)
+        self.tx_ring.send(length, packet_id.map(|p| p.into()), f)
+    }
+
+    /// Check whether a descriptor is available for sending.
+    ///
+    /// If this function returns `true`, the next [`EthernetDMA::send`] is
+    /// guarantted to succeed.
+    pub fn tx_available(&mut self) -> bool {
+        self.tx_ring.available()
     }
 
     #[cfg(feature = "ptp")]

src/dma/rx/f_series_desc.rs

@@ -63,7 +63,7 @@ impl RxDescriptor {
     }
 
     /// Is owned by the DMA engine?
-    fn is_owned(&self) -> bool {
+    pub(super) fn is_owned(&self) -> bool {
         (self.inner_raw.read(0) & RXDESC_0_OWN) == RXDESC_0_OWN
     }
 

src/dma/rx/mod.rs

@@ -44,21 +44,11 @@ pub struct RxRing<'data, STATE> {
 }
 
 impl<'data, STATE> RxRing<'data, STATE> {
-    /// Demand that the DMA engine polls the current `RxDescriptor`
-    /// (when in `RunningState::Stopped`.)
-    pub fn demand_poll(&self, eth_dma: &ETHERNET_DMA) {
-        #[cfg(feature = "f-series")]
-        eth_dma.dmarpdr.write(|w| unsafe { w.rpd().bits(1) });
-
-        // On H7, we poll by re-writing the tail pointer register.
-        #[cfg(feature = "stm32h7xx-hal")]
-        eth_dma
-            .dmacrx_dtpr
-            .modify(|r, w| unsafe { w.bits(r.bits()) });
-    }
-
     /// 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() };
+
         #[cfg(feature = "f-series")]
         let rps = eth_dma.dmasr.read().rps().bits();
         #[cfg(feature = "stm32h7xx-hal")]
@@ -164,17 +154,43 @@ impl<'data> RxRing<'data, NotRunning> {
             });
         }
 
-        self.demand_poll(eth_dma);
-
-        RxRing {
+        let me = RxRing {
             ring: self.ring,
             next_entry: self.next_entry,
             state: Default::default(),
-        }
+        };
+
+        me.demand_poll();
+
+        me
     }
 }
 
 impl<'data> RxRing<'data, Running> {
+    /// Demand that the DMA engine polls the current `RxDescriptor`
+    /// (when in `RunningState::Stopped`.)
+    pub fn demand_poll(&self) {
+        // # SAFETY
+        //
+        // On F7, we only perform an atomic write to `damrpdr`.
+        //
+        // On H7, we only perform a Read-Write to `dmacrx_dtpr`,
+        // always with the same value. Running `demand_poll` concurrently
+        // with the other location in which this register is written ([`RxRing::start`])
+        // is impossible, which is guaranteed the state transition from NotRunning to
+        // Running.
+        let eth_dma = unsafe { &*ETHERNET_DMA::ptr() };
+
+        #[cfg(feature = "f-series")]
+        eth_dma.dmarpdr.write(|w| unsafe { w.rpd().bits(1) });
+
+        // On H7, we poll by re-writing the tail pointer register.
+        #[cfg(feature = "stm32h7xx-hal")]
+        eth_dma
+            .dmacrx_dtpr
+            .modify(|r, w| unsafe { w.bits(r.bits()) });
+    }
+
     /// Stop the DMA engine.
     pub fn stop(&mut self, eth_dma: &ETHERNET_DMA) {
         #[cfg(feature = "f-series")]
@@ -185,18 +201,17 @@ impl<'data> RxRing<'data, Running> {
 
         start_reg.modify(|_, w| w.sr().clear_bit());
 
-        while self.running_state(eth_dma) != RunningState::Stopped {}
+        while self.running_state() != RunningState::Stopped {}
     }
 
     /// Receive the next packet (if any is ready), or return `None`
     /// immediately.
     pub fn recv_next(
         &mut self,
-        eth_dma: &ETHERNET_DMA,
         #[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 entry = self.next_entry;
@@ -257,6 +272,11 @@ impl<'data> RxRing<'data, Running> {
             }
         })
     }
+
+    pub fn available(&mut self) -> bool {
+        let (desc, _) = self.ring.get(self.next_entry);
+        !desc.is_owned()
+    }
 }
 
 #[cfg(feature = "ptp")]

src/dma/smoltcp_phy.rs

@@ -1,13 +1,13 @@
-use super::{rx::RxPacket, tx::TxError, EthernetDMA};
-use core::intrinsics::transmute;
+use super::rx::{self, RxRing};
+use super::tx::{self, 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, rx::Running>,
 }
 
-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, tx::Running>,
 }
 
-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()
     }
 }