Merge branch 'master' into h7

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)

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(_) => {}
             }

src/dma/mod.rs

@@ -299,16 +299,16 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         self.tx_ring.running_state()
     }
 
-    /// 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.rx_ring.recv_next(packet_id.map(|p| p.into()))
     }
 
-    /// Check whether a frame is available for reception.
+    /// Check if there is a packet available for reading.
     ///
-    /// If this function returns `true`, the next [`TxRing::recv_next`] is
-    /// guaranteed to succeed.
+    /// 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.available()
     }
@@ -328,10 +328,10 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         self.tx_ring.send(length, packet_id.map(|p| p.into()), f)
     }
 
-    /// Check whether a descriptor is available for sending.
+    /// Check if sending a packet now would succeed.
     ///
-    /// If this function returns `true`, the next [`EthernetDMA::send`] is
-    /// guarantted to 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.available()
     }

src/peripherals.rs

@@ -260,6 +260,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 {