Merge pull request #71 from stm32-rs/update-smoltcp

Update smoltcp

Author: datdenkikniet

CHANGELOG.md

@@ -1,5 +1,5 @@
 ## Unreleased
-No changes yet.
+* Update to `smoltcp` v0.9 [#71](https://github.com/stm32-rs/stm32-eth/pull/71).
 
 ## [0.4.0](https://github.com/stm32-rs/stm32-eth/tree/v0.4.0)
 * Remove the `smi` feature and always enable miim/smi. Use `ieee802_3_miim` for SMI access [#45](https://github.com/stm32-rs/stm32-eth/pull/45)

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"

examples/common.rs

@@ -32,7 +32,7 @@ pub fn setup_peripherals(p: stm32_eth::stm32::Peripherals) -> (Clocks, Gpio, Par
     {
         let rcc = p.RCC.constrain();
 
-        let clocks = rcc.cfgr.sysclk(100.MHz()).hclk(100.MHz());
+        let clocks = rcc.cfgr.sysclk(96.MHz()).hclk(96.MHz());
 
         #[cfg(feature = "stm32f4xx-hal")]
         let clocks = {

examples/ip.rs

@@ -4,21 +4,21 @@
 //! For build and run instructions, see README.md
 //!
 //! This example starts a TCP listening server at the address 10.0.0.1/24, on port 80, that
-//!  should transmit `Hello` to any connecting client, and then close the connection.
+//!  should transmit `hello` to any connecting client, and then close the connection.
 
 use defmt_rtt as _;
 use panic_probe as _;
 
 use cortex_m_rt::{entry, exception};
+use smoltcp::iface::{Config, Interface, SocketSet, SocketStorage};
 use stm32_eth::stm32::{interrupt, CorePeripherals, Peripherals, SYST};
 
 use core::cell::RefCell;
 use cortex_m::interrupt::Mutex;
 
-use smoltcp::iface::{InterfaceBuilder, NeighborCache};
-use smoltcp::socket::{TcpSocket, TcpSocketBuffer};
+use smoltcp::socket::tcp::{Socket as TcpSocket, SocketBuffer as TcpSocketBuffer};
 use smoltcp::time::Instant;
-use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
+use smoltcp::wire::{EthernetAddress, IpCidr, Ipv4Address, Ipv4Cidr};
 
 pub mod common;
 
@@ -27,6 +27,7 @@ use stm32_eth::{
     Parts,
 };
 
+const IP_ADDRESS: Ipv4Address = Ipv4Address::new(10, 0, 0, 1);
 const SRC_MAC: [u8; 6] = [0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF];
 
 static TIME: Mutex<RefCell<u64>> = Mutex::new(RefCell::new(0));
@@ -62,27 +63,26 @@ fn main() -> ! {
     .unwrap();
     dma.enable_interrupt();
 
-    let local_addr = Ipv4Address::new(10, 0, 0, 1);
-    let ip_addr = IpCidr::new(IpAddress::from(local_addr), 24);
-    let mut ip_addrs = [ip_addr];
-    let mut neighbor_storage = [None; 16];
-    let neighbor_cache = NeighborCache::new(&mut neighbor_storage[..]);
     let ethernet_addr = EthernetAddress(SRC_MAC);
 
-    let mut sockets: [_; 1] = Default::default();
-    let mut iface = InterfaceBuilder::new(&mut dma, &mut sockets[..])
-        .hardware_addr(ethernet_addr.into())
-        .ip_addrs(&mut ip_addrs[..])
-        .neighbor_cache(neighbor_cache)
-        .finalize();
+    let mut config = Config::new();
+    config.hardware_addr = Some(ethernet_addr.into());
+    let mut iface = Interface::new(config, &mut &mut dma);
+
+    iface.update_ip_addrs(|addr| {
+        addr.push(IpCidr::Ipv4(Ipv4Cidr::new(IP_ADDRESS, 24))).ok();
+    });
+
+    let mut sockets = [SocketStorage::EMPTY];
+    let mut sockets = SocketSet::new(&mut sockets[..]);
 
     let mut server_rx_buffer = [0; 512];
     let mut server_tx_buffer = [0; 512];
     let server_socket = TcpSocket::new(
         TcpSocketBuffer::new(&mut server_rx_buffer[..]),
         TcpSocketBuffer::new(&mut server_tx_buffer[..]),
     );
-    let server_handle = iface.add_socket(server_socket);
+    let server_handle = sockets.add(server_socket);
 
     loop {
         let time: u64 = cortex_m::interrupt::free(|cs| *TIME.borrow(cs).borrow());
@@ -91,31 +91,43 @@ fn main() -> ! {
             *eth_pending = false;
         });
 
-        iface.poll(Instant::from_millis(time as i64)).ok();
+        iface.poll(
+            Instant::from_millis(time as i64),
+            &mut &mut dma,
+            &mut sockets,
+        );
 
-        let socket = iface.get_socket::<TcpSocket>(server_handle);
+        let socket = sockets.get_mut::<TcpSocket>(server_handle);
 
         if !socket.is_listening() && !socket.is_open() {
             socket.abort();
             if let Err(e) = socket.listen(80) {
                 defmt::error!("TCP listen error: {:?}", e)
             } else {
-                defmt::info!("Listening at {}:80...", ip_addr);
+                defmt::info!("Listening at {}:80...", IP_ADDRESS);
             }
         } else {
             match socket.send_slice(b"hello\n") {
                 Ok(_) => {
-                    while iface.get_socket::<TcpSocket>(server_handle).send_queue() != 0 {
+                    while sockets.get::<TcpSocket>(server_handle).send_queue() != 0 {
                         // Poll to get the message out of the door
-                        iface.poll(Instant::from_millis(time as i64 + 1)).ok();
+                        iface.poll(
+                            Instant::from_millis(time as i64 + 1),
+                            &mut &mut dma,
+                            &mut sockets,
+                        );
                     }
 
                     // Abort the connection
-                    let socket = iface.get_socket::<TcpSocket>(server_handle);
+                    let socket = sockets.get_mut::<TcpSocket>(server_handle);
                     socket.abort();
                     defmt::info!("Transmitted hello! Closing socket...");
 
-                    iface.poll(Instant::from_millis(time as i64 + 1)).ok();
+                    iface.poll(
+                        Instant::from_millis(time as i64),
+                        &mut &mut dma,
+                        &mut sockets,
+                    );
                 }
                 Err(_) => {}
             }

examples/rtic-echo.rs

@@ -10,14 +10,12 @@
 use defmt_rtt as _;
 use panic_probe as _;
 
-use smoltcp::{
-    iface::{self, SocketStorage},
-    wire::{self, IpAddress, Ipv4Address},
-};
+use smoltcp::wire::{IpAddress, Ipv4Address};
 
 mod common;
 
-const ADDRESS: (IpAddress, u16) = (IpAddress::Ipv4(Ipv4Address::new(10, 0, 0, 1)), 1337);
+const IP_ADDRESS: Ipv4Address = Ipv4Address::new(10, 0, 0, 1);
+const SOCKET_ADDRESS: (IpAddress, u16) = (IpAddress::Ipv4(IP_ADDRESS), 1337);
 const MAC: [u8; 6] = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05];
 
 #[rtic::app(device = stm32_eth::stm32, dispatchers = [SPI1])]
@@ -35,18 +33,17 @@ mod app {
     };
 
     use smoltcp::{
-        iface::{self, Interface, SocketHandle},
-        socket::TcpSocket,
-        socket::{TcpSocketBuffer, TcpState},
-        wire::EthernetAddress,
+        iface::{self, Interface, SocketHandle, SocketSet, SocketStorage},
+        socket::tcp::{Socket as TcpSocket, SocketBuffer as TcpSocketBuffer, State as TcpState},
+        wire::{EthernetAddress, IpCidr, Ipv4Cidr},
     };
 
-    use crate::NetworkStorage;
-
     #[local]
     struct Local {
-        interface: Interface<'static, &'static mut EthernetDMA<'static, 'static>>,
+        interface: Interface,
         tcp_handle: SocketHandle,
+        dma: EthernetDMA<'static, 'static>,
+        sockets: SocketSet<'static>,
     }
 
     #[shared]
@@ -63,8 +60,9 @@ mod app {
     #[init(local = [
         rx_ring: [RxRingEntry; 2] = [RxRingEntry::new(),RxRingEntry::new()],
         tx_ring: [TxRingEntry; 2] = [TxRingEntry::new(),TxRingEntry::new()],
-        storage: NetworkStorage = NetworkStorage::new(),
-        dma: core::mem::MaybeUninit<EthernetDMA<'static, 'static>> = core::mem::MaybeUninit::uninit(),
+        rx_storage: [u8; 512] = [0u8; 512],
+        tx_storage: [u8; 512] = [0u8; 512],
+        socket_storage: [SocketStorage<'static>; 1] = [SocketStorage::EMPTY; 1],
     ])]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         defmt::info!("Pre-init");
@@ -77,51 +75,56 @@ mod app {
         let (clocks, gpio, ethernet) = crate::common::setup_peripherals(p);
         let mono = Systick::new(core.SYST, clocks.hclk().raw());
 
+        let (rx_storage, tx_storage, socket_storage) = (
+            cx.local.rx_storage,
+            cx.local.tx_storage,
+            cx.local.socket_storage,
+        );
+
         defmt::info!("Setting up pins");
         let (pins, mdio, mdc, _) = crate::common::setup_pins(gpio);
 
         defmt::info!("Configuring ethernet");
 
         let Parts {
-            dma,
+            mut dma,
             mac,
             #[cfg(feature = "ptp")]
                 ptp: _,
         } = stm32_eth::new_with_mii(ethernet, rx_ring, tx_ring, clocks, pins, mdio, mdc).unwrap();
 
-        let dma = cx.local.dma.write(dma);
-
         defmt::info!("Enabling interrupts");
         dma.enable_interrupt();
 
         defmt::info!("Setting up smoltcp");
-        let store = cx.local.storage;
 
-        let mut routes = smoltcp::iface::Routes::new(&mut store.routes_cache[..]);
+        let mut routes = smoltcp::iface::Routes::new();
         routes
             .add_default_ipv4_route(smoltcp::wire::Ipv4Address::UNSPECIFIED)
             .ok();
 
-        let neighbor_cache = smoltcp::iface::NeighborCache::new(&mut store.neighbor_cache[..]);
-
-        let rx_buffer = TcpSocketBuffer::new(&mut store.tcp_socket_storage.rx_storage[..]);
-        let tx_buffer = TcpSocketBuffer::new(&mut store.tcp_socket_storage.tx_storage[..]);
+        let rx_buffer = TcpSocketBuffer::new(&mut rx_storage[..]);
+        let tx_buffer = TcpSocketBuffer::new(&mut tx_storage[..]);
 
         let socket = TcpSocket::new(rx_buffer, tx_buffer);
 
-        let mut interface = iface::InterfaceBuilder::new(dma, &mut store.sockets[..])
-            .hardware_addr(EthernetAddress::from_bytes(&crate::MAC).into())
-            .neighbor_cache(neighbor_cache)
-            .ip_addrs(&mut store.ip_addrs[..])
-            .routes(routes)
-            .finalize();
+        let mut config = iface::Config::new();
+        config.hardware_addr = Some(EthernetAddress::from_bytes(&crate::MAC).into());
+
+        let mut interface = Interface::new(config, &mut &mut dma);
+        interface.update_ip_addrs(|addr| {
+            addr.push(IpCidr::Ipv4(Ipv4Cidr::new(crate::IP_ADDRESS, 24)))
+                .ok();
+        });
 
-        let tcp_handle = interface.add_socket(socket);
+        let mut sockets = SocketSet::new(&mut socket_storage[..]);
 
-        let socket = interface.get_socket::<TcpSocket>(tcp_handle);
-        socket.listen(crate::ADDRESS).ok();
+        let tcp_handle = sockets.add(socket);
 
-        interface.poll(now_fn()).unwrap();
+        let socket = sockets.get_mut::<TcpSocket>(tcp_handle);
+        socket.listen(crate::SOCKET_ADDRESS).ok();
+
+        interface.poll(now_fn(), &mut &mut dma, &mut sockets);
 
         if let Ok(mut phy) = EthernetPhy::from_miim(mac, 0) {
             defmt::info!(
@@ -152,28 +155,36 @@ mod app {
             defmt::info!("Not resetting unsupported PHY. Cannot detect link speed.");
         }
 
-        defmt::info!("Setup done. Listening at {}", crate::ADDRESS);
+        defmt::info!("Setup done. Listening at {}", crate::SOCKET_ADDRESS);
 
         (
             Shared {},
             Local {
                 interface,
                 tcp_handle,
+                dma,
+                sockets,
             },
             init::Monotonics(mono),
         )
     }
 
-    #[task(binds = ETH, local = [interface, tcp_handle, data: [u8; 512] = [0u8; 512]], priority = 2)]
+    #[task(binds = ETH, local = [interface, tcp_handle, dma, sockets, data: [u8; 512] = [0u8; 512]], priority = 2)]
     fn eth_interrupt(cx: eth_interrupt::Context) {
-        let (iface, tcp_handle, buffer) = (cx.local.interface, cx.local.tcp_handle, cx.local.data);
-
-        let interrupt_reason = iface.device_mut().interrupt_handler();
+        let (iface, tcp_handle, buffer, sockets, mut dma) = (
+            cx.local.interface,
+            cx.local.tcp_handle,
+            cx.local.data,
+            cx.local.sockets,
+            cx.local.dma,
+        );
+
+        let interrupt_reason = dma.interrupt_handler();
         defmt::debug!("Got an ethernet interrupt! Reason: {}", interrupt_reason);
 
-        iface.poll(now_fn()).ok();
+        iface.poll(now_fn(), &mut dma, sockets);
 
-        let socket = iface.get_socket::<TcpSocket>(*tcp_handle);
+        let socket = sockets.get_mut::<TcpSocket>(*tcp_handle);
         if let Ok(recv_bytes) = socket.recv_slice(buffer) {
             if recv_bytes > 0 {
                 socket.send_slice(&buffer[..recv_bytes]).ok();
@@ -183,50 +194,10 @@ mod app {
 
         if !socket.is_listening() && !socket.is_open() || socket.state() == TcpState::CloseWait {
             socket.abort();
-            socket.listen(crate::ADDRESS).ok();
+            socket.listen(crate::SOCKET_ADDRESS).ok();
             defmt::warn!("Disconnected... Reopening listening socket.");
         }
 
-        iface.poll(now_fn()).ok();
-    }
-}
-
-/// All storage required for networking
-pub struct NetworkStorage {
-    pub ip_addrs: [wire::IpCidr; 1],
-    pub sockets: [iface::SocketStorage<'static>; 1],
-    pub tcp_socket_storage: TcpSocketStorage,
-    pub neighbor_cache: [Option<(wire::IpAddress, iface::Neighbor)>; 8],
-    pub routes_cache: [Option<(wire::IpCidr, iface::Route)>; 8],
-}
-
-impl NetworkStorage {
-    const IP_INIT: wire::IpCidr =
-        wire::IpCidr::Ipv4(wire::Ipv4Cidr::new(wire::Ipv4Address::new(10, 0, 0, 1), 24));
-
-    pub const fn new() -> Self {
-        NetworkStorage {
-            ip_addrs: [Self::IP_INIT],
-            neighbor_cache: [None; 8],
-            routes_cache: [None; 8],
-            sockets: [SocketStorage::EMPTY; 1],
-            tcp_socket_storage: TcpSocketStorage::new(),
-        }
-    }
-}
-
-/// Storage of TCP sockets
-#[derive(Copy, Clone)]
-pub struct TcpSocketStorage {
-    rx_storage: [u8; 512],
-    tx_storage: [u8; 512],
-}
-
-impl TcpSocketStorage {
-    const fn new() -> Self {
-        Self {
-            rx_storage: [0; 512],
-            tx_storage: [0; 512],
-        }
+        iface.poll(now_fn(), &mut dma, sockets);
     }
 }