Update to smoltcp 0.10

Author: datdenkikniet

Cargo.toml

@@ -32,15 +32,15 @@ defmt = { version = "0.3", optional = true }
 futures = { version = "0.3", default-features = false, features = ["async-await"], optional = true }
 
 [dependencies.smoltcp]
-version = "0.9"
+version = "0.10"
 default-features = false
 optional = true
 
 [features]
 default = [ "defmt", "ptp" ]
 device-selected = []
 fence = []
-ptp = [ ]
+ptp = [ "smoltcp/packetmeta-id" ]
 async-await = ["dep:futures"]
 
 stm32f107 = ["stm32f1xx-hal/stm32f107", "device-selected"]
@@ -73,7 +73,7 @@ fugit = "0.3"
 defmt-rtt = "0.4"
 panic-probe = { version = "0.3", features = [ "print-defmt" ] }
 systick-monotonic = "1.0"
-smoltcp = { version = "0.9", features = [ "medium-ethernet", "proto-ipv4", "socket-udp", "socket-tcp", "defmt" ], default-features = false }
+smoltcp = { version = "0.10", features = [ "medium-ethernet", "proto-ipv4", "socket-udp", "socket-tcp", "defmt" ], default-features = false }
 
 [dev-dependencies.rtic]
 package = "cortex-m-rtic"

examples/ip.rs

@@ -65,9 +65,8 @@ fn main() -> ! {
 
     let ethernet_addr = EthernetAddress(SRC_MAC);
 
-    let mut config = Config::new();
-    config.hardware_addr = Some(ethernet_addr.into());
-    let mut iface = Interface::new(config, &mut &mut dma);
+    let config = Config::new(ethernet_addr.into());
+    let mut iface = Interface::new(config, &mut &mut dma, Instant::ZERO);
 
     iface.update_ip_addrs(|addr| {
         addr.push(IpCidr::Ipv4(Ipv4Cidr::new(IP_ADDRESS, 24))).ok();

examples/rtic-echo.rs

@@ -108,10 +108,9 @@ mod app {
 
         let socket = TcpSocket::new(rx_buffer, tx_buffer);
 
-        let mut config = iface::Config::new();
-        config.hardware_addr = Some(EthernetAddress::from_bytes(&crate::MAC).into());
+        let config = iface::Config::new(EthernetAddress::from_bytes(&crate::MAC).into());
 
-        let mut interface = Interface::new(config, &mut &mut dma);
+        let mut interface = Interface::new(config, &mut &mut dma, smoltcp::time::Instant::ZERO);
         interface.update_ip_addrs(|addr| {
             addr.push(IpCidr::Ipv4(Ipv4Cidr::new(crate::IP_ADDRESS, 24)))
                 .ok();

examples/timesync/client.rs

@@ -86,7 +86,7 @@ mod app {
     use systick_monotonic::Systick;
 
     use stm32_eth::{
-        dma::{EthernetDMA, PacketId, RxRingEntry, TxRingEntry},
+        dma::{EthernetDMA, RxRingEntry, TxRingEntry},
         mac::Speed,
         ptp::{EthernetPTP, Timestamp},
         Parts,
@@ -189,7 +189,7 @@ mod app {
         )
     }
 
-    #[task(local = [addend_integrator: f32 = 0.0, start_addend, packet_id: u32 = 0, dma, ptp])]
+    #[task(local = [addend_integrator: f32 = 0.0, start_addend, dma, ptp])]
     fn runner(cx: runner::Context) {
         use fugit::ExtU64;
 
@@ -199,11 +199,8 @@ mod app {
 
         let start = monotonics::now();
 
-        let (addend_integrator, start_addend, packet_id) = (
-            cx.local.addend_integrator,
-            *cx.local.start_addend,
-            cx.local.packet_id,
-        );
+        let (addend_integrator, start_addend) =
+            (cx.local.addend_integrator, *cx.local.start_addend);
 
         let mut buf = [0u8; 128];
 
@@ -244,8 +241,7 @@ mod app {
 
         macro_rules! send {
             ($data:expr) => {{
-                let current_id = PacketId(*packet_id);
-                *packet_id += 1;
+                let current_id = dma.next_packet_id();
                 let current_clone = current_id.clone();
 
                 dma.send(14 + $data.len(), Some(current_clone), |buf| {

examples/timesync/server.rs

@@ -27,7 +27,7 @@ mod app {
     use systick_monotonic::Systick;
 
     use stm32_eth::{
-        dma::{EthernetDMA, PacketId, RxRingEntry, TxRingEntry},
+        dma::{EthernetDMA, RxRingEntry, TxRingEntry},
         mac::Speed,
         Parts,
     };
@@ -117,15 +117,15 @@ mod app {
         (Shared {}, Local { dma }, init::Monotonics(mono))
     }
 
-    #[task(local = [packet_id: u32 = 0, dma])]
+    #[task(local = [dma])]
     fn runner(cx: runner::Context) {
         use fugit::ExtU64;
 
         runner::spawn().ok();
 
         let start = monotonics::now();
 
-        let (packet_id, dma) = (cx.local.packet_id, cx.local.dma);
+        let dma = cx.local.dma;
 
         let mut buf = [0u8; 128];
 
@@ -166,8 +166,7 @@ mod app {
 
         macro_rules! send {
             ($data:expr) => {{
-                let current_id = PacketId(*packet_id);
-                *packet_id += 1;
+                let current_id = dma.next_packet_id();
                 let current_clone = current_id.clone();
                 dma.send(14 + $data.len(), Some(current_clone), |buf| {
                     buf[0..6].copy_from_slice(&BROADCAST);

src/dma/mod.rs

@@ -45,6 +45,9 @@ pub struct EthernetDMA<'rx, 'tx> {
     pub(crate) eth_dma: ETHERNET_DMA,
     pub(crate) rx_ring: RxRing<'rx>,
     pub(crate) tx_ring: TxRing<'tx>,
+
+    #[cfg(feature = "ptp")]
+    packet_id_counter: u32,
 }
 
 impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
@@ -120,6 +123,7 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
             eth_dma,
             rx_ring: RxRing::new(rx_buffer),
             tx_ring: TxRing::new(tx_buffer),
+            packet_id_counter: 0,
         };
 
         dma.rx_ring.start(&dma.eth_dma);
@@ -366,6 +370,13 @@ impl EthernetDMA<'_, '_> {
     ) -> Result<Option<Timestamp>, PacketIdNotFound> {
         self.tx_ring.timestamp(packet_id).await
     }
+
+    /// Get the next packet ID.
+    pub fn next_packet_id(&mut self) -> PacketId {
+        let id = PacketId(self.packet_id_counter);
+        self.packet_id_counter += 1;
+        id
+    }
 }
 
 /// A summary of the reasons for the interrupt

src/dma/packet_id.rs

@@ -23,3 +23,19 @@ impl From<u32> for PacketId {
         Self(value)
     }
 }
+
+#[cfg(all(feature = "ptp", feature = "smoltcp-phy"))]
+impl From<smoltcp::phy::PacketMeta> for PacketId {
+    fn from(value: smoltcp::phy::PacketMeta) -> Self {
+        Self(value.id)
+    }
+}
+
+#[cfg(all(feature = "ptp", feature = "smoltcp-phy"))]
+impl From<PacketId> for smoltcp::phy::PacketMeta {
+    fn from(value: PacketId) -> Self {
+        let mut meta = smoltcp::phy::PacketMeta::default();
+        meta.id = value.0;
+        meta
+    }
+}

src/dma/smoltcp_phy.rs

@@ -1,6 +1,6 @@
 use super::rx::RxRing;
 use super::tx::TxRing;
-use super::EthernetDMA;
+use super::{EthernetDMA, PacketId};
 use smoltcp::phy::{ChecksumCapabilities, Device, DeviceCapabilities, RxToken, TxToken};
 use smoltcp::time::Instant;
 
@@ -19,13 +19,23 @@ impl<'a, 'rx, 'tx> Device for &'a mut EthernetDMA<'rx, 'tx> {
 
     fn receive(&mut self, _timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
         if self.tx_available() && self.rx_available() {
+            let rx_packet_id = self.next_packet_id();
+
             let EthernetDMA {
                 rx_ring, tx_ring, ..
             } = self;
 
-            let rx = EthRxToken { rx_ring };
+            let rx = EthRxToken {
+                rx_ring,
+                #[cfg(feature = "ptp")]
+                meta: rx_packet_id,
+            };
 
-            let tx = EthTxToken { tx_ring };
+            let tx = EthTxToken {
+                tx_ring,
+                #[cfg(feature = "ptp")]
+                meta: None,
+            };
             Some((rx, tx))
         } else {
             None
@@ -35,7 +45,11 @@ impl<'a, 'rx, 'tx> Device for &'a mut EthernetDMA<'rx, 'tx> {
     fn transmit(&mut self, _timestamp: Instant) -> Option<Self::TxToken<'_>> {
         if self.tx_available() {
             let EthernetDMA { tx_ring, .. } = self;
-            Some(EthTxToken { tx_ring })
+            Some(EthTxToken {
+                tx_ring,
+                #[cfg(feature = "ptp")]
+                meta: None,
+            })
         } else {
             None
         }
@@ -46,6 +60,8 @@ impl<'a, 'rx, 'tx> Device for &'a mut EthernetDMA<'rx, 'tx> {
 /// an ethernet packet.
 pub struct EthRxToken<'a, 'rx> {
     rx_ring: &'a mut RxRing<'rx>,
+    #[cfg(feature = "ptp")]
+    meta: PacketId,
 }
 
 impl<'dma, 'rx> RxToken for EthRxToken<'dma, 'rx> {
@@ -59,24 +75,41 @@ impl<'dma, 'rx> RxToken for EthRxToken<'dma, 'rx> {
         packet.free();
         result
     }
+
+    #[cfg(feature = "ptp")]
+    fn meta(&self) -> smoltcp::phy::PacketMeta {
+        self.meta.clone().into()
+    }
 }
 
 /// Just a reference to [`EthernetDMA`] for sending a
 /// packet later with [`TxToken::consume()`].
 pub struct EthTxToken<'a, 'tx> {
     tx_ring: &'a mut TxRing<'tx>,
+    #[cfg(feature = "ptp")]
+    meta: Option<PacketId>,
 }
 
 impl<'dma, 'tx> TxToken for EthTxToken<'dma, 'tx> {
     fn consume<R, F>(self, len: usize, f: F) -> R
     where
         F: FnOnce(&mut [u8]) -> R,
     {
+        #[cfg(feature = "ptp")]
+        let meta = self.meta.map(Into::into);
+        #[cfg(not(feature = "ptp"))]
+        let meta = None;
+
         // NOTE(unwrap): an `EthTxToken` is only created if
         // there is a descriptor available for sending.
-        let mut tx_packet = self.tx_ring.send_next(len, None).ok().unwrap();
+        let mut tx_packet = self.tx_ring.send_next(len, meta).ok().unwrap();
         let res = f(&mut tx_packet);
         tx_packet.send();
         res
     }
+
+    #[cfg(feature = "ptp")]
+    fn set_meta(&mut self, meta: smoltcp::phy::PacketMeta) {
+        self.meta = Some(meta.into());
+    }
 }