Convert to ring mode (instead of chain mode)

Author: datdenkikniet

Cargo.toml

@@ -29,6 +29,7 @@ ieee802_3_miim = "0.8"
 cortex-m = "0.7"
 log = { version = "0.4", optional = true }
 defmt = { version = "0.3", optional = true }
+siphasher = "*"
 
 [dependencies.smoltcp]
 version = "0.8.2"

examples/arp.rs

@@ -16,14 +16,15 @@ use cortex_m_rt::{entry, exception};
 
 use cortex_m::interrupt::Mutex;
 use stm32_eth::{
+    dma::{RxDescriptor, TxDescriptor},
     mac::{phy::BarePhy, Phy},
     stm32::{interrupt, CorePeripherals, Peripherals, SYST},
-    Parts,
+    Parts, MTU,
 };
 
 pub mod common;
 
-use stm32_eth::dma::{RxRingEntry, TxError, TxRingEntry};
+use stm32_eth::dma::{RxDescriptorRing, TxDescriptorRing, TxError};
 
 const PHY_ADDR: u8 = 0;
 
@@ -43,22 +44,20 @@ fn main() -> ! {
 
     let (eth_pins, mdio, mdc, _) = common::setup_pins(gpio);
 
-    let mut rx_ring: [RxRingEntry; 2] = Default::default();
-    let mut tx_ring: [TxRingEntry; 2] = Default::default();
+    let mut rx_descriptors: [RxDescriptor; 2] = Default::default();
+    let mut rx_buffers: [[u8; MTU]; 2] = [[0u8; MTU]; 2];
+    let rx_ring = RxDescriptorRing::new(&mut rx_descriptors, &mut rx_buffers);
+
+    let mut tx_descriptors: [TxDescriptor; 2] = Default::default();
+    let mut tx_buffers: [[u8; MTU]; 2] = [[0u8; MTU]; 2];
+    let tx_ring = TxDescriptorRing::new(&mut tx_descriptors, &mut tx_buffers);
 
     let Parts {
         mut dma,
         mac,
         #[cfg(feature = "ptp")]
             ptp: _,
-    } = stm32_eth::new(
-        ethernet,
-        &mut rx_ring[..],
-        &mut tx_ring[..],
-        clocks,
-        eth_pins,
-    )
-    .unwrap();
+    } = stm32_eth::new(ethernet, rx_ring, tx_ring, clocks, eth_pins).unwrap();
     dma.enable_interrupt();
 
     let mut last_link_up = false;
@@ -109,14 +108,32 @@ fn main() -> ! {
                 buf[38..42].copy_from_slice(&TARGET_IP);
             });
 
+            loop {
+                use core::hash::{Hash, Hasher};
+
+                if let Ok(rx_packet) = dma.recv_next(None) {
+                    let mut hasher = siphasher::sip::SipHasher::new();
+                    rx_packet.hash(&mut hasher);
+
+                    defmt::info!(
+                        "Received {} bytes. Hash: {:016X}",
+                        rx_packet.len(),
+                        hasher.finish()
+                    );
+                    break;
+                }
+            }
+
             match r {
                 Ok(()) => {
                     defmt::info!("ARP sent");
                 }
-                Err(TxError::WouldBlock) => defmt::info!("ARP failed"),
+                Err(TxError::WouldBlock) => {
+                    defmt::panic!("ARP failed. {}", dma.tx_state())
+                }
             }
         } else {
-            defmt::info!("Down");
+            // defmt::info!("Down");
         }
 
         cortex_m::interrupt::free(|cs| {

examples/rtic-echo.rs

@@ -29,7 +29,7 @@ mod app {
     use systick_monotonic::Systick;
 
     use stm32_eth::{
-        dma::{EthernetDMA, RxRingEntry, TxRingEntry},
+        dma::{EthernetDMA, RxDescriptor, RxDescriptorRing, TxDescriptor, TxDescriptorRing},
         mac::Speed,
         Parts,
     };
@@ -61,8 +61,10 @@ mod app {
     }
 
     #[init(local = [
-        rx_ring: [RxRingEntry; 2] = [RxRingEntry::new(),RxRingEntry::new()],
-        tx_ring: [TxRingEntry; 2] = [TxRingEntry::new(),TxRingEntry::new()],
+        rx_desc: [RxDescriptor; 2] = [RxDescriptor::new(); 2],
+        tx_desc: [TxDescriptor; 2] = [TxDescriptor::new(); 2],
+        rx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
+        tx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
         storage: NetworkStorage = NetworkStorage::new(),
         dma: core::mem::MaybeUninit<EthernetDMA<'static, 'static>> = core::mem::MaybeUninit::uninit(),
     ])]
@@ -71,8 +73,8 @@ mod app {
         let core = cx.core;
         let p = cx.device;
 
-        let rx_ring = cx.local.rx_ring;
-        let tx_ring = cx.local.tx_ring;
+        let rx_ring = RxDescriptorRing::new(cx.local.rx_desc, cx.local.rx_buffers);
+        let tx_ring = TxDescriptorRing::new(cx.local.tx_desc, cx.local.tx_buffers);
 
         let (clocks, gpio, ethernet) = crate::common::setup_peripherals(p);
         let mono = Systick::new(core.SYST, clocks.hclk().raw());

examples/rtic-timestamp.rs

@@ -43,7 +43,9 @@ mod app {
     use systick_monotonic::Systick;
 
     use stm32_eth::{
-        dma::{EthernetDMA, PacketId, RxRingEntry, TxRingEntry},
+        dma::{
+            EthernetDMA, PacketId, RxDescriptor, RxDescriptorRing, TxDescriptor, TxDescriptorRing,
+        },
         mac::Speed,
         ptp::{EthernetPTP, Timestamp},
         Parts,
@@ -64,16 +66,18 @@ mod app {
     type Monotonic = Systick<1000>;
 
     #[init(local = [
-        rx_ring: [RxRingEntry; 2] = [RxRingEntry::new(),RxRingEntry::new()],
-        tx_ring: [TxRingEntry; 2] = [TxRingEntry::new(),TxRingEntry::new()],
+        rx_desc: [RxDescriptor; 2] = [RxDescriptor::new(); 2],
+        tx_desc: [TxDescriptor; 2] = [TxDescriptor::new(); 2],
+        rx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
+        tx_buffers: [[u8; 1522]; 2] = [[0u8; stm32_eth::MTU]; 2],
     ])]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         defmt::info!("Pre-init");
         let core = cx.core;
         let p = cx.device;
 
-        let rx_ring = cx.local.rx_ring;
-        let tx_ring = cx.local.tx_ring;
+        let rx_ring = RxDescriptorRing::new(cx.local.rx_desc, cx.local.rx_buffers);
+        let tx_ring = TxDescriptorRing::new(cx.local.tx_desc, cx.local.tx_buffers);
 
         let (clocks, gpio, ethernet) = crate::common::setup_peripherals(p);
         let mono = Systick::new(core.SYST, clocks.hclk().raw());

src/dma/desc.rs

@@ -11,26 +11,40 @@ mod smoltcp_phy;
 #[cfg(feature = "smoltcp-phy")]
 pub use smoltcp_phy::*;
 
-pub(crate) mod desc;
-
-pub(crate) mod ring;
+pub(crate) mod raw_descriptor;
 
 mod rx;
-use rx::RxRing;
-pub use rx::{RxError, RxPacket, RxRingEntry};
+pub use rx::{RxDescriptor, RxDescriptorRing, RxError, RxPacket};
 
 mod tx;
-use tx::TxRing;
-pub use tx::{TxError, TxRingEntry};
+pub use tx::{TxDescriptor, TxDescriptorRing, TxError};
 
 #[cfg(feature = "ptp")]
 use crate::ptp::Timestamp;
 
 mod packet_id;
 pub use packet_id::PacketId;
 
+use rx::RxRing;
+use tx::{RunningState, TxRing};
+
+use self::raw_descriptor::DESC_SIZE;
+
+const _RXDESC_SIZE: usize = core::mem::size_of::<RxDescriptor>();
+const _TXDESC_SIZE: usize = core::mem::size_of::<TxDescriptor>();
+
+/// Assert that our descriptors have the same size.
+///
+/// This is necessary as we only have a single Descriptor Skip Length
+/// value which applies to both TX and RX descriptors.
+const _ASSERT_DESCRIPTOR_SIZES: () = assert!(_RXDESC_SIZE == _TXDESC_SIZE);
+
+const DESC_WORD_SKIP: u8 = (core::mem::size_of::<RxDescriptor>() / 4 - DESC_SIZE) as u8;
+
+/// The maximum transmission unit of this Ethernet peripheral.
+///
 /// From the datasheet: *VLAN Frame maxsize = 1522*
-pub(crate) const MTU: usize = 1522;
+pub const MTU: usize = 1522;
 
 /// An error that can occur when retrieving a timestamp from an
 /// RX or TX descriptor handled by the DMA.
@@ -60,8 +74,8 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
     /// usually not accessible.
     pub(crate) fn new(
         eth_dma: ETHERNET_DMA,
-        rx_buffer: &'rx mut [RxRingEntry],
-        tx_buffer: &'tx mut [TxRingEntry],
+        rx_buffer: RxDescriptorRing<'rx>,
+        tx_buffer: TxDescriptorRing<'tx>,
     ) -> Self {
         // reset DMA bus mode register
         eth_dma.dmabmr.modify(|_, w| w.sr().set_bit());
@@ -120,6 +134,9 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
             }
         });
 
+        // Configure word skip length.
+        eth_dma.dmabmr.modify(|_, w| w.dsl().bits(DESC_WORD_SKIP));
+
         let mut dma = EthernetDMA {
             eth_dma,
             rx_ring: RxRing::new(rx_buffer),
@@ -179,6 +196,11 @@ impl<'rx, 'tx> EthernetDMA<'rx, 'tx> {
         self.rx_ring.running_state(&self.eth_dma).is_running()
     }
 
+    ///
+    pub fn tx_state(&self) -> RunningState {
+        self.tx_ring.running_state(&self.eth_dma)
+    }
+
     pub(crate) fn recv_next_impl<'rx_borrow>(
         eth_dma: &ETHERNET_DMA,
         rx_ring: &'rx_borrow mut RxRing,

src/dma/mod.rs

@@ -10,7 +10,7 @@ The main use is obtaining timestamps for frames using [`EthernetDMA::get_timesta
 "
 )]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub struct PacketId(pub u32);
 
 impl PacketId {